make-it-so

What this skill does

### 4. Make it so (implement all tasks)

Implement all the remaining tasks from the spec, one phase at a time. The main agent NEVER implements tasks itself — it always delegates the work to one or more subagents, oversees their spawning, integrates their results, and handles phase-level bookkeeping (review, changelog, specs overview).

**Constraints:**

**Phase Retrieval (main agent):**
- The main agent MUST use the rune skill to retrieve the next phase to work on
- Use `rune next --phase --format json` to get the next incomplete phase
- If `rune next` reports that all tasks are complete, stop the loop and report completion to the user

**Stream Detection (main agent):**
- Once a phase is selected, the main agent MUST run `rune streams --available --json` to detect ready work streams
- 2 or more ready streams → **Parallel Delegation** (worktree per stream)
- 1 ready stream, or the phase has no streams defined → **Single-Subagent Delegation** (no worktree, in place)
- Whichever path is taken, the main agent MUST delegate. It MUST NOT implement tasks itself.

**Parallel Delegation (multiple streams):**

Subagents work in isolated git worktrees so their parallel commits don't race on the shared index or on `tasks.md`.

For each ready stream the main agent MUST:
1. Create a worktree branched from the current working branch:
   - `git worktree add .claude/worktrees/<phase>-stream-<N> -b stream/<phase>-<N>`
2. Spawn one subagent per worktree, all in a single message so they run in parallel (Task tool, `general-purpose` subagent unless a more specific type fits)

Each subagent prompt MUST include:
- The stream number it owns
- The absolute path to its worktree (it MUST `cd` there before doing anything)
- The path to the tasks file inside the worktree
- The list of `front_matter_references` to read before implementing
- These instructions:
  - Use `rune next --phase --stream N --format json` to retrieve all tasks for the stream
  - Read all referenced files before implementing
  - Implement tasks in dependency order. Use tools/skills as needed (context7 for library docs, efficiency-optimizer for verification, etc.)
  - Mark each task complete with `rune complete <task-id>` as it finishes
  - Run all formatting and test commands for the project before committing
  - Stage changes (including any reformatting and the modified `tasks.md`) and commit using the **Subagent Commit Conventions** below
  - Stop when all tasks in the stream are complete, when blocked by tasks in other streams, or on unrecoverable failure
  - Report back: branch name, list of completed task IDs, list of blocking task IDs (if any), and final status (`done` | `blocked` | `failed`)

**Main Agent Oversight (parallel mode):**
- Wait for all spawned subagents to return
- Track which streams reported `done` / `blocked` / `failed`
- After any return, re-run `rune streams --available --json`. If newly unblocked streams appear (because another stream's completion satisfied their deps), spawn fresh subagents for them in new worktrees — same parallel pattern as above
- If every remaining stream reports `blocked` and no new work surfaces, report a circular dependency to the user and stop
- If a subagent reports `failed`, surface the failure to the user and stop the phase rather than masking it

**Integration (main agent, after all parallel subagents have returned `done`):**
1. From the main working branch, merge each completed stream branch in turn:
   - `git merge --no-ff stream/<phase>-<N> -m "[merge]: phase <P> stream <N>"`
2. Conflicts on `tasks.md` are expected (each stream marked different tasks complete). Resolve by accepting both sides' completions
3. After all stream branches are merged, remove their worktrees and delete the branches:
   - `git worktree remove .claude/worktrees/<phase>-stream-<N>`
   - `git branch -d stream/<phase>-<N>`

**Single-Subagent Delegation (single stream or no streams):**

No worktree is needed — there is no parallel commit race when only one subagent is working.

The main agent MUST spawn one subagent (Task tool, `general-purpose` unless a more specific type fits) with a prompt containing:
- The phase number
- The stream number if the phase has exactly one ready stream (otherwise note that streams are not defined for this phase)
- The path to the tasks file
- The list of `front_matter_references` to read before implementing
- These instructions:
  - Use `rune next --phase --stream N --format json` if a single stream is in play, otherwise `rune next --phase --format json`, to retrieve all tasks for the phase
  - Read all referenced files before implementing
  - Implement all tasks (including subtasks) in the order specified, using tools/skills as needed
  - Mark each task complete with `rune complete <task-id>` as it finishes
  - Run all formatting and test commands for the project before committing
  - Stage changes (including any reformatting and the modified `tasks.md`) and commit on the current working branch using the **Subagent Commit Conventions** below
  - Report back: list of completed task IDs and final status (`done` | `failed`)

The main agent waits for the subagent to return and surfaces any failure to the user before continuing.

**Review (main agent):**
- Once the phase is fully integrated (parallel mode) or the single subagent has returned `done` (single-subagent mode), use the design-critic skill over the resulting state and verify it's correct. Issues detected should be fixed (delegate the fix as a follow-up subagent if it involves code, or update the decision log directly)

**Phase Changelog & Specs Overview (main agent):**
- After review, write a single phase-level changelog entry summarising the work done in this phase (subagent commits never touch the changelog — see Subagent Commit Conventions). Read `CHANGELOG.md` (create if missing), prepend the entry if not already present, and commit it as `[doc]: changelog for phase <P>` (or with a ticket prefix if applicable)
- Then check if all tasks in the spec are complete: `rune list specs/{feature_name}/tasks.md --format json` and verify no incomplete tasks remain
- If all tasks complete AND `specs/OVERVIEW.md` exists:
  - Update the spec's status from `Planned` or `In Progress` to `Done`
  - If new files were created in the spec directory during implementation (e.g., `implementation.md`), add them to the spec's detail section file list
- If tasks remain AND `specs/OVERVIEW.md` exists AND the spec's status is `Planned`:
  - Update the spec's status from `Planned` to `In Progress`
- Commit any overview/decision-log updates

**Compact and Continue (main agent):**
- If incomplete tasks remain in the spec, run `/compact` with: `/compact Continuing /make-it-so - implement the next phase. Current progress: [brief summary of completed phase]`
- After compaction completes, immediately continue executing `/make-it-so` to implement the next phase
- If all tasks are complete, do not compact — report completion to the user and stop

---

**Subagent Commit Conventions** (used by ALL subagents — parallel stream subagents and single-subagent mode; the main agent's phase changelog commit is a separate single-file commit and follows its own format):

1. Run all formatting and test commands.
2. Use the command line to get an overview of the staged git changes. If no changes are staged, stage all files. If running the formatting resulted in unstaged changes to files, stage these as well. DO NOT revert code changes unless specifically asked to do so.
3. Subagents MUST NOT touch `CHANGELOG.md`. The main agent writes the per-phase changelog entry after the subagents return (and, in parallel mode, after their branches are merged).
4. Verify the current branch with git. Parallel stream subagents are on `stream/<phase>-<N>`; single-subagent mode is on the user's working branch. The ticket prefix below should be derived from the **base** working branch (the branch the worktree was created from, or — in single-subagent m