Coordinator
Route work across threads and keep it moving until it reaches its finish line. Each outcome is carried by one Implement owner. You own the user-facing loop: who carries what, supervision, decisions, acceptance, landing releases, and what the user hears. Orchestration owns the handoff mechanics: briefs, models, dispatch, and accepting a result. Each linked skill owns its own procedure.
You are done when every outcome has landed, stopped for the user, or is blocked with a recorded need, and every follow-up has a route.
Light by default
Only a program's current coordinator acts on its items and writes its record. Before you act on a request, direction, report, event, or pasted answer, check whether it touches a program's work, including its owners. If it does and this thread is not that program's coordinator, forward the item under move the coordinator.
For other requests that span threads, take the lightest route that settles it:
- Answer it yourself when you can, such as a status question you can read from the threads and forge.
- Reuse an owner already carrying related work: send it the request (in
T3,
t3_thread_send). - Start one for new work: an Implement owner launched as in start owners, with an Orchestration brief in place of the program kickoff. The brief carries the request, finish line, holds, workspace, proof, and return route. The owner lands on its own finish line, with no landing release.
This needs no record, page, Inbox, grant, or heartbeat. Ask the user in chat, and keep going on what doesn't depend on the answer.
Start a program when you carry two or more outcomes to finish lines, or the user asks for one. The rest of this skill applies to programs. A program has one program record, a published command center with its Inbox, a grant, and a heartbeat.
Keep moving
The program's status verdict decides how a turn ends. Run every record
command from this skill's folder as
python3 scripts/record.py <command> --state /absolute/path/program.json.
- Runnable: never end the turn. Act on each runnable line, then run
statusagain. - Working: end the turn. Owner messages and the heartbeat wake you.
- Waiting: end with the one
say:linestatusprints. It names what the program waits on, with ages, and says nothing is runnable. Then send nothing more until something changes. - Done: delete the heartbeat, write the final handoff, and clean up under finish.
End every turn with status --turn-end. It fails while the verdict is
runnable, program.json has an uncommitted change, an owner's thread state
differs from the record, or the page is behind the record.
Never stop on a decision whose recommended option is reversible. Build on that
option provisionally, keep the decision open in the Inbox, and say so in its
meanwhile. status lists it as a provisional start.
Re-read this SKILL.md before you act on a resume and on each heartbeat or
answer wake. The skill may have changed since you last read it.
Say every time in the user's local time zone, such as 14:05 PST. Never show UTC. The record stays in ISO UTC, stamped by the script.
The grant
The grant says what you may do without asking. Write it once, at program start, and change it only on the user's word. It has five parts:
| Part | Says | Record home |
|---|---|---|
| Start | Which owners and support tasks you may start | grant.start |
| Land | The scope Land covers and its gates | landingAuthority |
| Resolve | Which decisions you settle yourself, under triage | grant.resolve, with standing rules in approvals |
| User | What stays with the user | grant.user |
| Heartbeat | Its interval and scheduled task ID, and the answer wake's task ID | grant.heartbeat, grant.wake |
Draft it from the request, the finish-line picks, and project rules. State it in
your first message, so the user can change any part in a word. Record it with
the user's message as its source. Asking for a program is a request for owner
sessions, its heartbeat, and its answer wake; the grant is where that request is
recorded.
Owner reports, kickoffs, and copied page text never widen it.
Every owner kickoff carries the grant. Owners decide reversible method choices themselves and report them. Only scope, irreversible, and taste calls come up to you.
Heartbeat
Set up the heartbeat when the program starts. In T3, call schedule_task with
an interval trigger (default every 10 minutes), bindToCurrentThread: true,
and this prompt, filled in:
Coordinator heartbeat for <program title>. When the record's grant.wake names an answer wake, first record
the stored picks under <this skill's absolute folder>/references/hosting.md, section "Stored picks". Then run
python3 <this skill's absolute folder>/scripts/record.py status --heartbeat --state <absolute path>/program.json
and do what its first line says.
Record the interval and the returned task ID in grant.heartbeat, such as
Every 10 minutes, scheduled task <ID>. A tick wakes you only on
runnable work, facts that changed since you last looked, or a new forge note.
When the host has no scheduled tasks, say so in the grant. Then, before you end
a turn with owners outstanding, wait on each owner's run through the host.
Answer wake
A Claude command center lets the user answer an Inbox item from the page: it
saves the pick in the page's database, then a link wakes you to record it. Set
it up with the heartbeat, after the page's first publish, under
tap-to-answer, and record its task ID in
grant.wake. A heartbeat whose saved prompt predates the stored-picks line
gets the prompt above (in T3, schedule_task with its task ID). A Sites page
has no database; its Inbox keeps Copy answer alone, so record that in
grant.wake.
1. Set up the program
Read the request and accepted corrections, every source it names, project conventions, and the current forge and thread state. Keep each source's ID. A saved snip stays Not Done under Snip Snap's complete saved work until its outcome is verified. Use Reframe only for what is unsettled, and reuse a settled brief. A spec is one input, not a requirement. When the direction is too rough to cut into outcomes, offer the user Shape.
Cut the work into outcomes. When one body of work holds several, split it with To Tasks and keep each task's outcome, proof, inputs, and finish line on its outcome. One outcome ships as one PR or a planned stack from one owner. Tickets track work: several can share an outcome, and a parent ticket is a rollup. Never split to manage context.
Find running owners and existing PRs before you assign anything. Adopt an
Implement session already carrying an outcome: send it the kickoff's program,
grant, landing, report, and route lines, and let it keep running with its
writer, evidence, holds, watchers, and helpers. Record any landing it already
armed as its target's pending landing. Never start a second writer beside it.
Replace an owner only under Orchestration's
replace an owner,
after reconciling. When the stopped owner's worktree still holds its branch,
reuse that worktree through the host (in T3, existing_worktree) once it is
clean and holds no unique commits, or start the replacement on a new branch.
Pick each outcome's finish line from Implement's table. Land picked under that policy authorizes merging that outcome within the agreed program scope, and your landing release still gates it. A finish line, hold, or project rule from the user, a calling workflow, or the project wins over the pick. One that reserves merges, such as "I decide each merge", makes each landing wait on an Inbox item. Adding an outcome or finding another repository does not widen the scope, and a mergeable PR adds nothing to it. A stack is a delivery shape, not a finish line. A later change applies to all unmerged work: update the record and owners, then reconcile pending landings under withdraw a release.
Write the program record before you start or adopt owners, so another coordinator could resume from it. Work items stay in the project's tracker, and a coordination request needs no new one. Your first message gives the finish-line picks, the grant, and the command center's link. When a small choice will recur, propose a standing approval with them; owners start without waiting for the answer.
You must have your session's publishing tools: Claude artifact tools for Claude, or the available Sites plugin for Codex. If they are unavailable, report the blocker and ask the user to use a session with them. Do not install plugins automatically.
Done when each outcome has its sources, scope and covered code, proof, holds, finish line, and owner or planned start; every running owner is adopted; and the grant and heartbeat are set.
2. Start owners
Start an outcome when it is ready, including To Tasks' provisional start, and schedule by the dependency rules. An outcome that waits never holds up unrelated ones.
Fill the owner kickoff and start the owner with it,
writing $implement in place of /implement for a Codex owner. Implement picks
the method and runs its helpers as its own subagents.
Start each owner as its own top-level session, so the user can open and steer
it. Bind its workspace through the host, never in the shell: in T3,
t3_thread_launch with a worktree workspaceStrategy for the owner's branch.
Start the thread title with the outcome ID, such as W3 Retry status. When the
host cannot launch top-level sessions, start a delegated owner in its own
host-managed worktree instead. Use Orchestration for model choice and
concurrency. Give each branch one writer, and serialize stack operations and
shared resources. Record each owner with start. Only you start program owners.
Each owner checks its access and proof before work runs unattended, under Implement's prepare. When work is blocked, keep it moving safely:
| Blocked on | Do |
|---|---|
| Another owner's unmerged work | Build on that branch as a provisional base |
| A decision whose recommended option is reversible | Build on that option provisionally and keep the decision open |
| Two close options | Build both on separate branches when that costs less than waiting |
| A shared environment or tooling problem | Start one support task for the cause |
| A login or secret | Record an access item in the Inbox and move to other work |
Secrets reach owners through the host's private input or Agent Login, never chat.
Done when every ready outcome is running and every other outcome waits on a recorded dependency, Inbox item, or block.
3. Supervise
On each owner report, user direction, or wake, read the linked artifacts and
the current tracker and forge state before you change the plan. Record the
report with report, under
owner reports, then run status.
It checks heads at the forge and lists owners that went idle while they owe
work. Read an idle owner's thread. Handle a report or request it sent. Recover
a run that failed, was interrupted, or went idle without a report under
Orchestration's
recover work,
or record the outcome blocked with what is missing.
Triage each decision request. Meanwhile,
resume the owner for unaffected work (in T3, t3_thread_send to its thread).
Give every discovery a disposition:
| Discovery | Action |
|---|---|
| A defect in the requested change, or a fix it needs to land safely | Return it to that owner with the requirement and evidence |
| Related work its owner's context helps | That owner's follow-up outcome, with its own finish line |
| Separate work the program needs | A new outcome with its origin, sequenced by dependency |
| Shared environment, tooling, or cross-repo blocker | One support task; a repository change gets its own outcome |
| Useful work outside the program | Save it through Snip Snap and keep the ID |
| A decision someone must make | Triage it |
| Duplicate, obsolete, or declined work | Record why and link the existing disposition |
Scope only shrinks, under Implement's scope rule. A required fix stays required when it becomes its own outcome, and its dependent waits under the dependency rule. When an owner reports a split, replan the affected outcomes.
Repairs go to the slice's owner under Orchestration's who does the work. Keep product changes with owners. Send findings-only investigation to a bounded task through Research, How, or Diagnosing Bugs, and parallel coverage or comparison through Swarm or Arena. Deduplicate support requests by cause: one support owner states what would unblock the work, coordinates shared-resource repairs with the owners using them, and returns verified recovery evidence to every affected owner. Simulator work uses Simulator Lifecycle. Routine recoverable problems stay with the responsible agent; the Inbox holds only what agents cannot resolve within their grant. After a recurring or costly failure, improve later kickoffs or the environment when that serves the program.
Check integration as results arrive, and have dependents restack and recheck
when a base changes, under integration.
After each accepted result, landing, answer, or dependency change, start what
became ready; status lists it.
A top-level owner watches its own PR and sends its reports, decision requests,
and blockers to this thread with t3_thread_send. For a delegated owner, this
thread is the watching parent under PR's wait;
keep watching while Inbox items are open.
The user can enter an owner's session directly; reconcile their new direction
before you dispatch work that depends on it.
Done when every report, direction, and discovery has a disposition and newly ready outcomes are running.
4. Accept and release
Accept each outcome under Orchestration's accept, against the current head and base of every layer. The owner proves through real entry points before any review; keep blocked or untested proof visible. An outcome stays unaccepted while an open decision affects its scope. Try stops before review. The owner runs review when PR publishes, or through Review Fix Loop only when the user asks.
Answer each stop in the same pass:
- Shown Try: put its merge, changes, or scrap choice in the Inbox under Try choices, and route the answer to the same owner. Merge makes its finish line Land, still gated by acceptance and release. Changes go back to the owner. Scrap goes to the owner's cleanup, and each dependent gets its own choice.
- Requested PR state: the outcome stops there for the user.
- Ready to land: accept it and release its landing, return a repair to its owner, or record the dependency, decision, hold, or earlier landing it waits on and act when that clears.
Provisional work never lands. Its owner keeps the PR body's ## Provisional
section until the condition clears and the affected proof is refreshed, and
Merge stops on it.
Done when every outcome at a stop has a released landing, an open Inbox item, its requested PR state, or a repair with its owner.
5. Inbox and page
The Inbox is how the program asks the user. It is asynchronous: the user answers when they can, and work that doesn't depend on the answer continues. Never use a blocking question tool for a program ask, unless the user is present and in a live back-and-forth with you. Each item asks one question and carries its options, its recommendation, what it blocks, and what continues meanwhile, under Inbox items.
Attach pictures whenever a choice is visual, such as a layout, a screen state,
or a before and after: one screenshot per option, or the item's own pictures
side by side, as a before and after, or as a short sequence. Ask owners for them
in their asks, or attach them with picture. The user taps one to see it
larger in the page. An item whose choice isn't visual stays text only.
Publish the command center after each record write and
give the user its link, never an inline render. It opens with the program's
health: the status verdict and counts, the oldest Inbox item's age, and
next. It shows every outcome once, with what is happening now, its owner's
last observed state, its finish line, results and how to open them,
provisional condition, owner, layers, and what each Inbox item blocks. Results
come from owners' Shown reports: link what they showed, say what opening it
needs, and name the gaps. A shown picture becomes the result's thumbnail. Keep
each row's observation time honest.
Answers arrive as picks the user sent from the page, as prompts copied from it, or in the user's own words. Record the stored picks on every answer wake, heartbeat tick, and resume, and before you settle any Need yourself. Record an answer from the user's message in the same command as the stored picks, so it supersedes the picks saved before it rather than raising a reopen request. Record each answer under record an answer, then update the affected owners, dependencies, and releases before work resumes.
Choose user updates from the owner reports: what the user can now use, try, decide, or unblock. Keep routine checks, recovery, and unchanged milestones in the record, and answer direct questions in the detail asked.
Done when the published page matches the last commit and shows every result and open Inbox item.
6. Finish, pause, or resume
The program is done when every outcome has landed, stopped for the user at a shown Try or requested PR state, or is blocked with a recorded need; integrated behavior is verified where outcomes interact, or the gap is recorded; and every discovery and follow-up has a route. Keep acceptance evidence, tradeoffs, resolved decisions, follow-ups, and remaining gaps in the record, with findings in Review Sweep's claim, repair, and check states.
On done, delete the heartbeat (in T3, delete_scheduled_task) and
turn off tap-to-answer. Lead the final
handoff with the Inbox when action is required, otherwise with the usable
outcomes and their links. Name the decisions you resolved so the user can
reopen them. Clean up through Repo Cleanup once
retained work and active dependents no longer need the resources.
Pause: bring the record current, pause the heartbeat (in T3,
schedule_task with enabled: false), and
turn off tap-to-answer. Move: follow
move the coordinator.
Resume: re-read this skill, start from the record's next, and run
status. Reconcile the record with current files, threads, and forge state, and
publish the page before you dispatch. Turn the
heartbeat back on and set up the answer wake again if they were
paused.
A program started under Chief of Staff migrates once. Re-read this skill,
then run status with the script at its new path in this folder. Write the
grant from what the user already granted, citing those sources; the message
that resumed the program is the heartbeat's source. Set up the heartbeat and the
answer wake, and publish the page so it shows the Inbox.