Wave

FlowCommand

cckit wave reads your open efforts and proposes the incoming waves of work.

What a wave is

An effort is a goal broken into many issues. Some issues block others, so they can’t all start at once. A wave is the set of issues that are unblocked right now — everything ready to be worked in parallel.

cckit wave looks at your open efforts, works out that set, and writes a brief: one task per issue, each scoped to its own isolated worktree so the parallel work can’t collide. It doesn’t run anything itself — it hands the brief to the agent, and the agent does the work.

Here’s the whole shape, then the steps below walk each part:

• One wave → many agents. The brief lists each unblocked issue as a self-contained task. The agent (Claude Code) spawns one subagent per task. They run at the same time, in separate worktrees, each implementing its issue and opening a pull request.
• The captain gates and merges. The captain is cckit watch — one long-running process that steers the whole wave. It checks every open pull request the subagents opened; the clean ones — tests passing, no conflicts — get merged; the rest are reported with exactly what to fix.
• Merging unblocks the next wave. Closing this wave’s issues frees the ones that depended on them. Re-run cckit wave and it proposes the next set. The board drains itself, wave by wave.

One turn of the loop

1. Propose the wave — cckit wave reads the board, finds the issues unblocked right now, and writes the brief: one subagent task per issue, each in its own worktree.

   cckit wave

2. Fan out — the agent spawns one subagent per issue from that brief. They run in parallel, each implementing its issue and opening a pull request.

3. Gate + merge — the captain (cckit watch, the process that steers the wave) checks every open pull request. The clean ones are merged; the rest are reported with what to fix.

   cckit watch --merge

4. Advance — merging unblocks the next wave. Re-run cckit wave and the loop repeats until there’s nothing left to propose.

Why 'captain'?

The subagents are a fleet — each one off in its own worktree, opening its own pull request. The captain is the one process watching over all of them: cckit watch polls every PR, merges the ones that are ready, and calls out the ones that aren’t. One captain, many boats.

Why a brief, not a launcher

cckit emits the plan as instructions and the agent enacts it. That keeps the work inside Claude Code’s own tools — Task subagents, worktrees, background runs — instead of a separate process you can’t see.

The commands

Do this	Command
Propose the wave (fan-out brief)	cckit wave
Scope to one effort	cckit wave --effort <N>
Gate + merge the wave	cckit watch --merge
Let the captain self-pace	cckit watch --loop
Machine-readable plan	cckit plan --llm

Links to learn more

• Efforts, waves & worktrees — where the waves come from.
• Driving cckit from agents — the full agent-facing surface.