Deliver Slice

Core Invariants

• Preserve phase ownership and statuses: implement-slice ends at ready for review; finalize-slice moves it to and leaves it in review.
• Never mark the slice done; complete-slice remains user-owned.
• Follow implement-slice execution routing: main-local for small or cohesive work; Terra workers only for genuine parallelism, large mechanical/discovery work, or specialist value.
• Use a fresh-context agent for finalization so implementation assumptions are not treated as review evidence.
• Stop when implementation remains in progress, user input is required, or finalization finds a genuine external blocker.

Workflow

1. Resolve one slice using implement-slice rules.

   • Accept only a ready slice for a new delivery.
   • If the named slice is already ready for review or in review, skip implementation and continue with finalization.
   • If it is in progress, resume through implement-slice; finalize only after it reaches ready for review.

2. Read both phase skills completely.

   • Read ../implement-slice/SKILL.md and every reference it requires for this slice.
   • Read ../finalize-slice/SKILL.md and every reference it requires for this slice.
   • Treat both phase contracts as authoritative. This skill only orchestrates them.

3. Execute implementation.

   • Follow implement-slice without weakening its execution-routing, human handoff, scope, note, or status rules.
   • When workers are used, wait for them, integrate their disjoint changes, and close them.
   • After implementation completes, run one batched root checkpoint: confirm local or worker completion gates, implementation notes, slice/roadmap status, target base, and current HEAD. Inspect only missing, conflicting, or integration-sensitive evidence; do not run a second broad implementation review.
   • If implementation does not reach ready for review, stop. Report remaining work; do not start finalization.

4. Preserve the review checkpoint.

   • Confirm slice and roadmap statuses are ready for review.
   • Capture implementation notes before finalization starts.
   • Create a minimal immutable handoff with project path, slice path, target branch, current HEAD, implementation-note location, and prior verification commands plus exact results.
   • Do not precompute changed paths, diff stat, worktree status, or untracked paths solely for the handoff. Mutable review-surface discovery belongs to the fresh finalizer and should happen once.
   • Keep the handoff factual. Do not pass implementation conclusions, recommendations, or suspected findings as facts.

5. Execute finalization in fresh context.

   • Spawn one fresh subagent with fork_turns: "none" and the parent model inherited.
   • Give it repository instructions, the immutable handoff, and: Use $finalize-slice to finalize this slice completely.
   • Dispatch it immediately after the batched root checkpoint and minimal handoff are complete.
   • Tell it that other agents may have edited the worktree, not to revert unrelated changes, and to preserve user changes.
   • Treat the fresh finalizer as the primary independent reviewer. Default to zero additional reviewers.
   • Let it add one or two focused reviewers only for concrete unresolved uncertainty, specialist risk, high semantic complexity, or explicit adversarial review. File count and mechanical relocation size alone do not justify another reviewer.
   • Require it to report status, resolved findings, accepted gaps, changed files, and any material decision needing user input.
   • Close the finalizer after its result is captured.

6. Finish.

   • Confirm final slice and roadmap status from artifacts instead of trusting the subagent report alone.
   • Leave clean delivery in review.
   • Leave user completion and learning capture to complete-slice.

Completion

Report implementation files, resolved finalization findings, accepted gaps or risks, and resulting status. If finalization needed no fixes, preserve its exact No findings. result inside the delivery summary.