Przejdź do treści
Biblioteka skilli
AI i agenci · Planowanie

session-coordinator

/session-coordinator

Dzieli zadanie między osobne sesje Claude Code, każdą w osobnym worktree, i zbiera wyniki po recenzji i akceptacji użytkownika.

Licencja
MIT
Ostatnia zmiana repozytorium
10.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Dzieli zadanie między osobne sesje Claude Code, każdą w osobnym worktree, i zbiera wyniki po recenzji i akceptacji użytkownika.

Oryginalny opis (EN)

Coordinate work across separate Claude Code sessions that the user can open, watch and steer - split a task, start one session per piece (each in its own worktree, with a model and effort suited to it), follow their reports, get each branch reviewed, and bring the results together with the user's approval. Use when the user types /session-coordinator or asks for the work to run in sessions they can peek into or steer. For hidden background agents whose results you review and merge yourself, use /coordinator instead. Also covers offloading work to external agents the user names: other agent CLI

Jak działa

  1. 0. Board first (before planning or dispatching anything)
  2. 1. Plan the split
  3. 2. Start the sessions
  4. 3. Write the brief
  5. 4. While sessions run
  6. 5. Review
  7. 6. Bring it together
  8. 7. Working from the kanban board
  9. 8. Report to the user
Sekcje z nagłówków SKILL.md, w oryginale · 196 linii, 2 058 słów
Podgląd SKILL.md
---
name: session-coordinator
description: "Coordinate work across separate Claude Code sessions that the user can open, watch and steer - split a task, start one session per piece (each in its own worktree, with a model and effort suited to it), follow their reports, get each branch reviewed, and bring the results together with the user's approval. Use when the user types /session-coordinator or asks for the work to run in sessions they can peek into or steer. For hidden background agents whose results you review and merge yourself, use /coordinator instead. Also covers offloading work to external agents the user names: other agent CLIs and harnesses (e.g. opencode, Gemini CLI, Codex, Aider) and the hosted, self-hosted or local models behind them."
---

# Session coordinator

Same job as `/coordinator` (decide, brief, check, report; don't implement), but every piece of work
runs in its **own session**: a real Claude Code session the user sees in the sidebar, can open,
read, steer or stop. The user is a co-driver. Plan for them stepping into any session at any time.

How it differs from `/coordinator`:

| | `/coordinator` | `/session-coordinator` |
| --- | --- | --- |
| Workers | Background subagents (`Agent`) | Sessions (`start_session`) |
| User can watch and steer | No | Yes, at any time |
| Results come back | Full report, this turn | A note (first ~400 chars of the session's report) when it ends a turn |
| Milestone updates | `SendMessage` to `"main"`, queued for your next turn | `send_message` to `"parent"`; arrives as a cross-session message. The user also sees it live in the session |
| Work lands on | Your checkout, or worktrees you merge | Each session's own branch (or PR) |
| Merging | You merge, then show the user | Only when the user tells you to |
| Best for | Fast, contained work you want finished and reviewed in one go | Bigger or longer pieces, work the user wants to shape, anything ending in its own PR |

Small steps (one command, one edit, reading a file) you still do yourself. A quick lookup you need
for planning can go to a subagent; the work itself goes to sessions.

Judgment calls and outward-facing actions stay with you, as in `/coordinator`. A session may push,
open a PR or merge only if the brief says the user already approved that exact step.

Before first use, load the deferred tools with ToolSearch, e.g.
`select:mcp__ccd_session__start_session,mcp__ccd_session_mgmt__list_sessions,mcp__ccd_session_mgmt__get_session,SendMessage`, plus the board tools in step 0.

## 0. Board first (before planning or dispatching anything)

Do this as soon as the skill starts, in the same message as your first other tool call. It is not
an optional last step.

1. Load the board tools: `select:mcp__kanban__find_project,mcp__kanban__create_project,mcp__kanban__link_repo,mcp__kanban__list_projects,mcp__kanban__next_item,mcp__kanban__claim_item,mcp__kanban__report_progress,mcp__kanban__create_item,mcp__kanban__comment`.
   - If they don't resolve, or the first call fails to connect, there's no board. Say so in one line
     and skip the rest of this step. That's the only way to skip it.
2. **Find this repo's project.** Each board project lists the code repos it belongs to.
   - Get the remote with `git remote get-url origin`, or the first remote `git remote` lists if
     there's no `origin`. Call `find_project` with it. With no remote, or no match, try the folder
     name too.
   - **The user named or linked a project** (a board URL like `#/<project>/board` counts): use it.
     If this repo isn't linked to it, offer to `link_repo` it.
   - **One match**: use it. **Several**: ask which one.
   - **None**: ask with a choice: create a project for this repo (`create_project`, linked), or link
     the repo to an existing one (`link_repo`, from `list_projects`). "Add it to the board" means
     yes to putting the work on the board, not a choice of project. If which project is unclear,
     ask. Never create or link one silently.
3. Take or create the item:
   - The user named an item: use it.
   - Otherwise check `next_item` for this project. If nothing fits, `create_item` with the user's
     request as the title and body.
   - `claim_item` it with a one-line plan.
4. After you've planned the split (section 1), create one item per task, with `Parent: #N` in the
   body, **before** that task's agent or session starts.

**Gate:** no agent or session starts until its item exists on the board, unless step 1 found no
board. If you notice you skipped this, stop and do it now, then tell the user.

## 1. Plan the split

1. Restate the goal and what "done" means. If it's unclear, ask.
2. Split into pieces that can each run in their own session: one owner, a clear finish line, their
   own files, nothing that needs another piece's unmerged changes. Pieces that depend on each other
   run one after another: start the second when the first's branch is merged (with the user's yes).
3. Rank each piece (`../coordinator/routing.md`). Then show the user the plan in a few lines: each session's or
   terminal's title, what it does, rank, model, effort, and provider for external models.
   **Budget gate**: with more than 3 sessions, or any on your top model at high effort, wait for
   their go-ahead before starting.
4. Put the plan on your task list, one step per session, with the step's `session` set to its name,
   and one board item per session (step 0.4).

## 2. Start the sessions

One `start_session` call per piece, in one message, after a bold title line and one sentence each.
If you start two or more, call `mark_chapter` first with a short batch title.

- `initiation: "user_asked"` (the user asked for sessions by invoking this skill).
- `context: "fresh"` with a full `prompt` (the brief, section 3) and `background` (goal so far,
  decisions, how this piece fits; at least 80 characters). Use `"fork"` only when the piece truly
  needs this whole conversation and the conversation is short.
- `use_worktree: true` (fresh sessions only) for anything that writes code, so each session gets its own branch.
  `false` only for read-only pieces (research, review of an existing branch).
- `name`: a short handle ([a-z0-9-]); `branch_name`: a slug for the branch.
- `model` and `effort`: **from the task's rank and tier** in `../coordinator/routing.md` (the coordinator skill's routing file; read it first). Cap them at
  yours, since higher values are ignored. A review session runs on **a different model from the
  author's**.
- **External agents** the user named (other agent CLIs, hosted or local models): `../coordinator/routing.md` decides
  whether Claude sessions join them, and covers how to check and run them. Each one runs in its own
  **Terminal tab** in its own worktree, so the user can watch it and type into it like a session.
  Link the tab. They can't message you: they write milestones to `<proof>/<task>/progress.md`.

- `wake_when_done`: leave it unset. The app continues you when sessions end a turn anyway; `true`
  only also wakes you if the session never gets its task.

Link every session you mention as `[its title](#local_<id>)`, using the id from the tool result.

## 3. Write the brief

A fresh session has none of this conversation. The user may also read the brief to understand the
session, so write it for both.

```
Goal        What to build/find and why it matters to the user.
Context     Paths, current state, what exists, what was tried. Facts, never "see above".
Decisions   Choices already made (quote the user when it matters). Don't revisit them.
Limits      Files and areas it owns; what it must not touch. Commit to your own branch; no push,
            PR or merge unless stated. Use scratch data (a copy of any data directory, sync or
            background jobs off, a free port), never the user's real data.
Done when   A concrete, checkable finish line.
Checks      Exact commands and what to try by hand (including the UI in a browser).
Report      End your turn with: branch name, files changed, each check's outcome, what's not done
            or not verified, open questions. Put the most important line first: only the first
            ~400 characters reach the coordinator automatically.
Milestones  The 2-4 points to send the coordinator an update: load mcp__ccd_session_mgmt__send_message
            and send to session_id "parent". One or two lines, plus proof: the passing check's
            output, or for UI the URL and steps (you show screenshots in your own session; the
            coordinator opens the URL itself). Image files go in <absolute proof folder>: use
            `<coordinator scratchpad>/proof/<session name>/`. Sessions on this Mac can write there.
            If the send fails, put the milestones at the top of your final report.
Steering    The user may step in and redirect you. Their instructions win over this brief; mention
            any change of direction in your report.
```

On a question the brief doesn't cover: the session should ask in its own session (the user can see
and answer it there), or end its turn with the question at the top of its report.

## 4. While sessions run

- **Don't poll and don't predict.** The app continues you with a `<side-sessions-event>` when sessions
  end their turn. Until then, answer the user or do your own small steps.
- A milestone update arrives: check its proof yourself (Read the file, or open the URL in the browser
  pane), then pass it to the user in a line (image via
  `SendUserFile` when worth seeing).
- When a note arrives: it's a claim. Look at the result (`get_session`, the branch's diff and log)
  before telling the user something is done.
- **Follow-ups go to the session that has the context**: `SendMessage` with `to` set to its
  `local_...` id. Never start a new session for a fix to an existing one. "Delivered" or "queued"
  means it arrived, not that it has been acted on; wait for the next note.
- If the user drove a session themselves, read what changed before sending it anything; don't undo
  their steering.
- A session waiting on the user's answer: tell the user in one line, with its link. Don't answer for
  them.
- Find your sessions with `list_sessions` `{"linked": true}`, never a search.
- On a turn started by a side-sessions event you can't start new sessions (except a step the user
  just asked for); propose them instead and let the user start them.

## 5. Review

For each code-writing session, before calling its piece done:
- Start a **review session** on a different model (or a subagent here, if it's small), pointed at the
  author's branch by its full ref (`refs/heads/...`) and the original goal, not the author's report.
- Require reproduction: each finding needs steps or a script. Unreproduced concerns are "possible".
- The reviewer reads and tests; it doesn't fix.
- You triage, then send the confirmed findings to the **author session** with `SendMessage`. The user
  may also read the review and steer the fix themselves.

## 6. Bring it together

Each session's work stays on its own branch. Nothing is in your checkout until it's merged.

- When a step needs the pieces together (testing it all, a final build), tell the user, name each
  branch by its full ref, and **ask whether to merge them here**. Merge only if the user themselves
  says so, not because a session asked. Never push those branches.
- After merging: run all the checks on the merged result and look at the UI yourself. A pass in each
  worktree doesn't count.
- If the user doesn't want them merged, say where each piece is (branch, PR) and leave it.
- Once the user is happy, you may offer to archive the finished sessions, and do it only on their yes.

## 7. Working from the kanban board

When step 0 found a board, it shows the sessions' work too.

The project and the parent item come from step 0. From there:

1. The parent item is the one step 0 claimed.
2. Give each session its **own item**: `create_item` with `Parent: #N` and the brief in the body,
   unassigned. Tell the session to `claim_item` it first and `report_progress` on that item only
   (with `branch` when it has one, `blocked` + question when stuck, `needs_review` when done).
   Every session acts as the same board actor (`KANBAN_AGENT`), so a session must never touch the
   parent item. A session in another repo uses the same project: give it the project id in the brief.
3. You own the parent: post a summary as sessions finish; `needs_review` when everything is in.
   Never mark items done; the human approves.

## 8. Report to the user

Lead with the outcome, then:
- **Each session**: link, what it did, its branch or PR, its state (done, waiting on you, running).
- **What you verified yourself** versus what's from session reports.
- **Not done, not verified, caveats.**
- **What needs the user**: merges, pushes, PRs, answers to waiting sessions.
- **Cost**: sessions, models, effort, and reported usage or duration where available
  ("not available" rather than a guess).

The most common failure is a brief that leans on this conversation ("as discussed", "the findings
above"). Every brief must stand on its own, for the session and for the user reading it.

Wersje

W bazie nie ma innych skilli o nazwie session-coordinator.

Migawka bazy z 13.11.2026 · wersja paczki 87ba91c188d3 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100coordinator
    Dzieli zadanie na części, zleca je agentom w tle, zbiera wyniki, zleca przegląd i sprawdza efekt sam, zanim pokaże gotową pracę wraz z kosztem.
  • 86coordinate
    Koordynuje kilku agentów kodujących w jednym repozytorium, każdego w osobnym worktree, z planem przed pracą.
  • 100multi-agent
    Dzieli pracę między agentów, z jednym worktree i plikiem promptu na zadanie, oraz prowadzi integrację przez koordynatora.
  • 100parallel-work
    Prowadzi kilka zadań naraz, każde we własnym drzewie roboczym i sesji, koordynowanych z głównego katalogu.
  • 90d2r-coordinator
    Dzieli projekt modyfikacji Diablo II Resurrected na równoległe ścieżki dla agentów AI, scala zmiany i raportuje właścicielowi.
  • 100coordinator
    Koordynuje jedno drzewo robocze projektu w Herdr: zamienia prośby na małe zadania, uruchamia agenta dla każdego, a człowiekowi zgłasza tylko to, co wymaga jego decyzji.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.