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.
- Autor
- takasurazeem ↗
- Repozytorium
- agent-coordinator ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 10.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 10.11.2026, bez odwołań do wycofanych modeli i API.
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
- 0. Board first (before planning or dispatching anything)
- 1. Plan the split
- 2. Start the sessions
- 3. Write the brief
- 4. While sessions run
- 5. Review
- 6. Bring it together
- 7. Working from the kanban board
- 8. Report to the user
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.