execute

Execute

You are executing one phase of planned work.

Inputs:

• the active runtime phase sheet (state/.../phases/phase-NN.md)
• plan.toml / plan.md
• design.md (canonical design reference)
• slice-nnn.md (scope)

Process

1. Confirm the phase's entrance criteria (EN-) are met for the active phase.
2. Read design.md + plan.toml + the runtime phase sheet before coding. If the sheet is not yet filled, run /phase-plan first; use /preflight if confirmed inputs, assumptions, and tensions are not yet surfaced.
3. Identify the concrete files or components you expect to touch first and run /retrieve-memory against those paths before deep reading or editing, so any scope-bound gotchas or patterns surface early.
4. Ensure status matches reality before implementation proceeds:
   • first phase starting → move the slice: doctrine slice status <id> started (bare number), if not already there.
   • flip the phase to in_progress with doctrine slice phase (see lib:reference/using-doctrine.md). This auto-records the conformance boundary — the handler stamps code_start_oid = HEAD into the phase sheet. No extra call; the binding rides the transition you already issue. (It self-skips in a dispatch coordination context, where the funnel beat is the recorder instead.)
5. Implement phase tasks in small coherent units, TDD red/green/refactor write a failing test, make it pass, then refactor. Test behaviour, not trivial implementation. Build and improve test helpers and fixtures as you go.
6. After each meaningful unit, run /harvest.
7. If that unit produced a durable gotcha, pattern, or subsystem fact worth future retrieval, run /record-memory before moving on.
8. Lint as you go (cargo clippy, zero warnings) and keep the tree buildable.
9. Follow the repo's commit policy: frequent, small conventional commits scoped with the slice id (e.g. feat(SL-NNN): …). Bias toward a clean tree; don't let .doctrine/** workflow edits drift in a stale uncommitted pile.
10. If /preflight or implementation reveals unresolved design ambiguity, unexpected obstacles, tradeoffs, or policy ambiguity, stop and /consult before improvising past it.
11. Keep the runtime phase sheet current as work progresses — never record progress in authored plan.toml / plan.md (the storage rule).
12. Before declaring the phase ready, run the verification gate — doctrine check gate (lint + test + format) — and review the touched subsystems and notes once more for missed memory-capture candidates. At phase wrap, weigh a per-phase review per the code-review skill's ## Cadence — default on below the adherence bar, mandatory on any tripwire.
13. When exit criteria (EX-) and verification (VT-, plus any agent/human VA-/VH- modes) are satisfied, flip the phase to completed with doctrine slice phase. This closes the conformance boundary — the handler captures code_end_oid = HEAD, applies the ancestor/non-merge guard, and upserts the phase's row into the slice's arm-neutral registry. Deterministic, on the critical path — not a "remember to also record" step; slice record-delta is only the manual fallback (correct a range, or bootstrap a pre-binding phase). Then hand off: /phase-plan for the next phase, or — when the slice's phases are all done — doctrine slice status <id> audit and /audit.

Optional: solo isolation (opt-in)

Default execution runs in-tree — the path above is unchanged unless isolation is requested.

Opt-in only — never automatic. Run the phase on its own worktree fork only when the user or the plan explicitly asks for isolation. Absent that annotation, implement in-tree.

When isolation is requested, before implementing (i.e. before step 5) invoke /worktree with:

• mode = solo, allow_work_in_place = true (solo MAY degrade to in-tree on sandbox denial);
• branch = slice/SL-NNN-slug (the slice id is in scope — e.g. slice/SL-NNN-<slug>), worktree dir keyed by the durable id (.worktrees/SL-NNN).

/worktree handles detection, the creation ladder (doctrine worktree fork), provisioning, the spawn guards, and the green baseline; the fork branch it returns is the deliverable.

Assert a clean direct-writer entry. Solo /execute is its own orchestrator — worker mode is never used here (that is /dispatch's path). Worker-ness is a property of the process: if DOCTRINE_WORKER is set in this shell, every doctrine-mediated authored write refuses mid-work. Confirm it is unset before the TDD loop (doctrine worktree status prints the resolved mode); if it is set, unset it — there is no stale on-disk state to clear.

Carry out the TDD loop (steps 5–12) inside the fork. When green, land the fork onto the coordination branch — /execute is the sole caller of land:

doctrine worktree land --fork slice/SL-NNN-slug   # merge --no-ff, ancestry preserved (NEVER squash)
doctrine worktree gc   --fork slice/SL-NNN-slug   # reap the spent fork once the oracle proves it landed

See lib:reference/dispatch-mechanics.md §§ "The import severs ancestry — so "did it land?" needs a patch-id oracle" and "The squash blind spot", for why land/gc behave as they do.

Outcomes

• Phase objectives are implemented with traceable evidence, ending green.
• Phase status matches reality during implementation, not only at closure.
• Notes and durable memory stay current throughout execution.