@gtrabanco/pi-agentic-workflow 0.19.1 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtrabanco/pi-agentic-workflow",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "description": "Pi package: canonical agentic-workflow skills, friendly slash commands, and per-command model routing.",
   "keywords": [
     "pi-package",
@@ -58,7 +58,7 @@
   },
   "dependencies": {
     "@gtrabanco/agentic-workflow": "0.2.0",
-    "@gtrabanco/agentic-workflow-schema": "4.5.0"
+    "@gtrabanco/agentic-workflow-schema": "4.6.0"
   },
   "devDependencies": {
     "@types/node": "24.13.3",

package/skills/execute-phase/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: execute-phase
 user-invocable: true
-version: 5.0.1
+version: 5.1.0
 argument-hint: <NN-slug> [P<k>|step] [--max-attempts N] [--force]
 allowed-tools: [Bash, Read, Edit, Write, MultiEdit]
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
@@ -39,7 +39,8 @@ done:
 ✓ Unit doc read and step selected (explicit P<k> or first unfinished)
 ✓ Step executed and committed (one commit per step, conventional format)
 ✓ Evidence rows updated (command → exit/digest → output → verified-by)
-✓ Progress log updated with a dated `YYYY-MM-DD HH:MM` entry (what, commit, next)
+✓ Progress log updated with a dated `YYYY-MM-DD HH:MM` entry that names the
+  phase id (what, commit, next)
 ✓ Diff guard passed (on implement steps) — see `diff-guard` in PREFLIGHT.md
 ✓ → Next: block printed as the absolute last output
 ```
@@ -139,10 +140,13 @@ After each step: run the project's verification gate (type-check + tests + build
 ### 7. Whole-unit mode
 
 When invoked as `<NN-slug>` with no step: loop all remaining steps, one commit
-each. After each step: gates, execute, diff guard (if implement), evidence/
-progress update, commit. Skip intermediate review checkpoints; the mandatory end
-review covers the full accumulated diff. On gate red at any step: repair that
-step (up to `--max-attempts`), then continue the loop. Terminal:
+each. This is an **explicit operator choice only** — the lane's hand-offs
+always name exactly one phase (`<NN-slug> P<k>`), so a bare `<NN-slug>` from a
+lane hand-off is a defect; re-read the hand-off before looping. After each
+step: gates, execute, diff guard (if implement), evidence/progress update,
+commit. Skip intermediate review checkpoints; the mandatory end review covers
+the full accumulated diff. On gate red at any step: repair that step (up to
+`--max-attempts`), then continue the loop. Terminal:
 
 ```text
 UNIT LOOP — <unit> COMPLETE
@@ -195,12 +199,17 @@ These files must be loaded when their topic is active:
 
 ## Relationship to other skills
 
-`unit-lane` conducts (triage → steps → doc updates); this executes (one step at a
-time or all remaining). `fold-findings` handles review finding repairs. The review
-pack axes (`review-implementation`, `review-code`, `review-security`, `review-perf`,
+`unit-lane` conducts (triage → judgment steps → close-out ladder) and hands
+execution off **one phase per turn** (`<NN-slug> P<k>` with the catalog tier);
+this executes the named phase — or, as an explicit operator choice only, all
+remaining steps. The closing hand-off names exactly one phase and the tier
+while phases remain, and resumes the lane after the last one.
+`fold-findings` handles review finding repairs. The review pack axes
+(`review-implementation`, `review-code`, `review-security`, `review-perf`,
 `review-a11y`, `review-debt`) compose the review step; `workflow-status` routes
-here. `triage-issue` feeds issues into the lane. This skill is the **step executor**
-a turn invokes to perform one triaged step of a unit under the full gate machinery.
+here. `triage-issue` feeds issues into the lane. This skill is the **step
+executor** a turn invokes to perform one triaged step of a unit under the full
+gate machinery.
 
 ## Portability (agents other than Claude Code)
 
@@ -215,15 +224,30 @@ a turn invokes to perform one triaged step of a unit under the full gate machine
 
 ## Done when
 
-- Requested scope is implemented (all remaining steps, one explicit step), gate
-  is green, unit doc Evidence/Progress are current, and the work is committed.
+- Requested scope is implemented (the named phase, or all remaining steps in an
+  explicit operator run), gate is green, unit doc Evidence/Progress are current
+  (the Progress entry names the phase id), and the work is committed.
 - **The closing `→ Next:` block is printed.**
 
 ## Closing recommendation
 
+Exactly one end-state applies — pick by the unit's Tasks section, never print a
+phase id the Tasks section does not define:
+
+Phases remain:
+
+```
+→ Next: /execute-phase <NN-slug> P<k+1> (tier: <tier>) — one phase per turn; <tier> is the catalog's implement entry
+  · whole-unit operator run complete → /review-change (mandatory end review)
+  · findings (REVIEW-FAIL) → /fold-findings repairs them; a fresh /review-change follows the fold
+  · merge gate after REVIEW-PASS → /audit-pr — the merge gate
+```
+
+The last phase just closed (a lane-run unit):
+
 ```
-→ Next: /unit-lane <NN-slug> — the conductor continues with the next triaged step
-  · all steps done → /review-change — the mandatory end review
+→ Next: /unit-lane <NN-slug> — resume the conductor for the remaining judgment steps
+  · whole-unit operator run complete → /review-change (mandatory end review)
   · findings (REVIEW-FAIL) → /fold-findings repairs them; a fresh /review-change follows the fold
   · merge gate after REVIEW-PASS → /audit-pr — the merge gate
 ```

package/skills/fold-findings/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: fold-findings
 user-invocable: true
-version: 1.7.0
+version: 1.8.0
 argument-hint: [finding-id …]
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT
@@ -102,9 +102,9 @@ no schema field). Six fields, always present:
 - Repaired: <F-ids with (VF-<n>) refs, joined ` + `, or `none`>
 - Refuted/open: <F-ids joined ` + `, or `none`>
 - Gate: <command> → exit <n> at head <40-hex sha> · n/a when nothing was folded
-- Batch class: <all-repair-in-place | frozen (replan present) | none>
+- Batch class: <all-repair-in-place | frozen (replan present) | frozen (product owner present) | none>
 - Fold diff: <shortstat from a real `git diff` run> · none when nothing was folded
-- Branch: <RE-REVIEW-REQUIRED (delta) | RE-REVIEW-OPTIONAL | RE-REVIEW-SKIPPED | REPLAN-ROUTE>
+- Branch: <RE-REVIEW-REQUIRED (delta) | RE-REVIEW-OPTIONAL | RE-REVIEW-SKIPPED | REPLAN-ROUTE | PRODUCT-ROUTE>
 ```
 
 - The `Gate` line carries the actual exit codes observed at the head the gate
@@ -114,9 +114,9 @@ no schema field). Six fields, always present:
 - The `Fold diff` shortstat comes from a real `git diff` run over the batch's
   commits.
 - The `Batch class` derives from the taken queue's frozen rows only — the fold
-  never reclassifies (`all-repair-in-place`, `frozen (replan present)`, or
-  `none` for an empty queue); the vocabulary comes from
-  `review-implementation`'s closed class set.
+  never reclassifies (`all-repair-in-place`, `frozen (replan present)`,
+  `frozen (product owner present)`, or `none` for an empty queue); the
+  vocabulary comes from `review-implementation`'s closed class set.
 
 **Freeze-batch (replan present).** When the taken queue contains any row whose
 frozen class is `replan-in-unit` or `decision-required`, nothing folds: no
@@ -129,6 +129,16 @@ and surface the decision to the user, never a planner. `<unit>` is the bare fold
 `node scripts/unit-route.mjs <unit>` is the discovery step the fold already
 ran; it is never the recommendation.
 
+**Freeze-batch (product owner present).** Any taken `fix-now` row whose `Route`
+cell begins `product owner`, `product-owned` or `owned by product` (head-anchored,
+identical to `scripts/unit-route.mjs`'s `PRODUCT_ROUTE` regex,
+per `#293`) freezes the batch too —
+nothing folds, no `folded: yes` flips, no commits: the fold loop repairs source,
+never authority (`pre-execution-review` POLICY §4, `#293`). The receipt records
+the `PRODUCT-ROUTE` branch and the retained row ids; the consumer is the
+router's printed `route: product` lane hand-off. Full condition and hand-off
+table: [`FOLD_PROCESS.md`](references/FOLD_PROCESS.md) §Batch classification.
+
 ## Guardrails
 
 Scope is the ledger (or explicit ID subset); unlisted discoveries are proposals
@@ -175,6 +185,7 @@ or touched outside the queue.
   · any BLOCKED (<F1> + <F2> + …) → supply the listed missing inputs, then re-run /fold-findings
   · any REPLAN (<F1> + <F2> + …) → /unit-lane <slug> or /unit-lane --fix <n> — the lane re-runs its plan step, appends the phases to the unit's SPEC; its review step gates before /execute-phase on this unit
   · any DECISION (<F1> + <F2> + …) → stop and surface the decision to the user — a `route: decision` conclusion names no planner, so the unit waits on the user before any plan or code change
+  · any PRODUCT (<F1> + <F2> + …) → /unit-lane <slug> or /unit-lane --fix <n> — the lane repairs the half, its review step re-judges it
 ```
 
 Every `· ` sub-bullet is exactly one physical line — never hard-wrapped across
@@ -187,12 +198,13 @@ carry `<slug>` or `<n>` into a live hand-off.
 
 ## Closing-block decision branch (choose one, at emission)
 
-The closing block picks exactly one of four outcomes. The **no-decision →
+The closing block picks exactly one of five outcomes. The **no-decision →
 re-review default** holds whenever the turn carries no recorded prior consumer
 decision to skip.
 
 | Batch state | Branch | `→ Next:` (consumer) |
 |---|---|---|
+| freeze-batch (≥ 1 product-owned row) | `PRODUCT-ROUTE` | `/unit-lane <slug>` (feature) or `/unit-lane --fix <n>` (fix) when the router concludes `product` — the lane repairs the half through its `design` step, its `review` step re-judges it; the conclusion printed by `node scripts/unit-route.mjs <unit>` (discovery step the fold already ran) |
 | freeze-batch (≥ 1 replan-class row) | `REPLAN-ROUTE` | `/unit-lane <slug>` (feature) or `/unit-lane --fix <n>` (fix) when the router concludes `replan` — user confirms, the lane's `plan` step appends the phases and its `review` step gates, then `/execute-phase` on this unit; on `route: decision` stop and surface the decision to the user — the conclusion printed by `node scripts/unit-route.mjs <unit>` (discovery step the fold already ran) |
 | `all-repair-in-place` + docs-only + no folded row severity `high` + prior consumer skip decision | `RE-REVIEW-SKIPPED` | skip — consumer has explicitly decided to skip the re-review |
 | `all-repair-in-place` + docs-only + no folded row severity `high` | `RE-REVIEW-OPTIONAL` | `/review-change` (default, delta mode) — or the consumer's recorded skip decision |

package/skills/fold-findings/references/FOLD_PROCESS.md

@@ -44,6 +44,7 @@
    | Condition over the taken batch | Batch class | Fold behavior |
    |---|---|---|
    | ≥ 1 row with frozen class `replan-in-unit` or `decision-required` | `frozen (replan present)` | **freeze-batch** — nothing folds, no `folded: yes` flips, no commits; the receipt records the REPLAN-ROUTE and every retained (unfolded) row id; the loop stops; the consumer is the conclusion printed by `node scripts/unit-route.mjs <unit>` (discovery step the fold already ran), where `<unit>` is the bare folder number or the full slug (both resolve): on `route: replan` the planner command the router printed — `/unit-lane <slug>` (feature) or `/unit-lane --fix <n>` (fix) — the lane appends the phases and its `review` step gates, then `/execute-phase` on this unit; on `route: decision` stop and surface the decision to the user, never a planner |
+   | ≥ 1 row with frozen class `fix-now` whose `Route` cell begins `product owner`, `product-owned` or `owned by product` (head-anchored, identical to `scripts/unit-route.mjs`'s `PRODUCT_ROUTE` regex: `/^(?:product[- ]owner\|product[- ]owned\|owned by product)\b/i`, per `#293`) | `frozen (product owner present)` | **freeze-batch** — nothing folds, no `folded: yes` flips, no commits; the receipt records the PRODUCT-ROUTE and every retained (unfolded) row id; the loop stops; the consumer is the conclusion printed by `node scripts/unit-route.mjs <unit>`: `route: product` and the lane hand-off — `/unit-lane <slug>` (feature) or `/unit-lane --fix <n>` (fix) — the lane repairs the half, its `review` step re-judges it, then `/execute-phase` on this unit |
    | all taken rows foldable, none replan-class | `all-repair-in-place` | fold as today (group → fix → gate → commit → flip) |
    | empty queue (zero findings taken) | `none` | receipt only |
 
@@ -51,8 +52,9 @@
    class set (`CLASSIFY.md`); the receipt invents no parallel vocabulary.
 
    The emitted branch follows the closing-block decision inputs in the skill:
-   a freeze-batch always selects `REPLAN-ROUTE`; otherwise the docs-only
-   file-set test (E-D3) and the frozen-severity-`high` override (E-D2) select
+   a freeze-batch selects `REPLAN-ROUTE` for a `frozen (replan present)` batch
+   and `PRODUCT-ROUTE` for a `frozen (product owner present)` batch; otherwise
+   the docs-only file-set test (E-D3) and the frozen-severity-`high` override (E-D2) select
    `RE-REVIEW-OPTIONAL` vs `RE-REVIEW-REQUIRED (delta)`.
 8. **Disputes.** Non-reproducible/already-fixed/wrong findings become
    `DISPUTED <evidence → user decision>`; never edit classification or create an
@@ -82,7 +84,7 @@ present:
 - Repaired: <F-ids with (VF-<n>) refs, joined ` + `, or `none`>
 - Refuted/open: <F-ids joined ` + `, or `none`>
 - Gate: <command> → exit <n> at head <40-hex sha> · n/a when nothing was folded
-- Batch class: <all-repair-in-place | frozen (replan present) | none>
+- Batch class: <all-repair-in-place | frozen (replan present) | frozen (product owner present) | none>
 - Fold diff: <shortstat from a real `git diff` run> · none when nothing was folded
-- Branch: <RE-REVIEW-REQUIRED (delta) | RE-REVIEW-OPTIONAL | RE-REVIEW-SKIPPED | REPLAN-ROUTE>
+- Branch: <RE-REVIEW-REQUIRED (delta) | RE-REVIEW-OPTIONAL | RE-REVIEW-SKIPPED | REPLAN-ROUTE | PRODUCT-ROUTE>
 ```

package/skills/review-change/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: review-change
 user-invocable: true
-version: 3.11.0
+version: 3.12.0
 argument-hint: <path-or-glob> [--adversarial N] [--synthesize]
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT

package/skills/review-change/references/PERSIST_AND_DECIDE.md

@@ -138,9 +138,10 @@ exact command tokens.
         fix); the lane re-runs its plan step on this branch, its review step
         gates, then `/execute-phase <unit>` (yes: list the finding ids; no: omit
         this line)
-      · any finding owned by product? → /unit-lane <unit> — the lane's design
-        step repairs the half, its review step re-judges it (yes: list the ids;
-        no: omit this line)
+      · any finding owned by product? → `node scripts/unit-route.mjs <unit>` prints
+        `route: product` + the lane hand-off — `/unit-lane <unit>` for a feature,
+        `/unit-lane --fix <n>` for a fix: the lane repairs the half, its review
+        step re-judges it (yes: list the ids; no: omit this line)
       · independent proposals → present to the user; only the user routes them
         to /triage-issue
      · adversarial recommendation checklist fired AND this run was

package/skills/review-implementation/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: review-implementation
 user-invocable: false
-version: 1.10.0
+version: 1.11.0
 argument-hint: <path-or-glob>
 allowed-tools: Read, Grep, Glob, Bash, WebFetch
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"

package/skills/review-implementation/references/CLASSIFY.md

@@ -175,7 +175,7 @@ finding in its `Route` cell.
 |---|---|---|
 | `source` | fold locally: `/fold-findings`, then re-run `/review-change` on the changed HEAD | — |
 | `plan` | run `node scripts/unit-route.mjs <unit>` → `route: replan`; the planning author re-cuts the artifact (SPEC `## Phases`, an obligation row, an acceptance mapping, a ledger) on the same branch with the user's confirmation, then the lane's **`review` step** precedes `execute-phase` | fold it in code and leave the plan describing the old build |
-| `product` | `/unit-lane <unit>` repairs the half through its `design` step, its `review` step re-judges it | patch the product claim into agreement in code |
+| `product` | run `node scripts/unit-route.mjs <unit>` → `route: product` → `/unit-lane <slug>` (feature) or `/unit-lane --fix <n>` (fix): the lane repairs the half through its `design` step, its `review` step re-judges it | patch the product claim into agreement in code |
 | `environment` / `runtime` | the existing retry/`BLOCKED` paths | translate into a PASS, or an issue |
 
 - `fix-now` with a `plan` or `product` owner keeps its severity but is **not**

package/skills/triage-issue/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: triage-issue
 user-invocable: true
-version: 2.10.0
+version: 2.11.0
 argument-hint: <issue-number> [more issue numbers…] | <audit-id> F<k> [F<j>…] | --prioritize-now <unit> F<k> [F<j>…]
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT

package/skills/triage-issue/references/REVIEW_FINDING_PROCESS.md

@@ -24,6 +24,13 @@ after `/fold-findings` leaves rows unresolved.
      `decision-required`. Ask the user; do not guess or weaken the finish line.
    - A finding disproved by current evidence is `disputed`. Preserve the row
      and show the evidence; do not mark it folded or silently delete it.
+   - A `fix-now` finding whose owning stage is `product` — the finding is
+     against the product half, not the code — is `product-repair` (#293). Run
+     `node scripts/unit-route.mjs <unit>`; its `route: product` line prints the
+     lane hand-off (`/unit-lane <unit>` for a feature, `/unit-lane --fix <n>`
+     for a fix): the lane repairs the half, its review step re-judges it. Never
+     fold it into the current unit — the fold loop repairs source, not
+     authority (`pre-execution-review` POLICY §4).
 
 4. Never implement the new phases in this triage turn. After a replan, ask the
    user to continue manually with `/execute-phase <unit> P<n>` (or the fix
@@ -34,7 +41,7 @@ Return exactly one block per finding:
 ```text
 REVIEW FINDING <F-k> — <short title>
 Checked: <commands and evidence>
-VERDICT: fix-now | replan-in-unit | decision-required | disputed
+VERDICT: fix-now | replan-in-unit | decision-required | product-repair | disputed
 Action taken: <current-unit fold/phase | unit-lane | user decision>
 ```
 

package/skills/unit-lane/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: unit-lane
 user-invocable: true
-version: 1.4.0
+version: 1.5.0
 argument-hint: <NN-slug | "<idea>"> [--retriage] | --fix <issue-number> | --from-issue <issue-number>
 description: >
   One-shot lane conductor for a delivery unit: triage, implement, evidence, and
@@ -85,8 +85,9 @@ re-derives, reorders, or invents steps — it executes only what the catalog say
 
 ### 3. Execute triaged steps in order
 
-For each step the triage returned, follow its reference file. Execute **one step
-per turn-commit**:
+For each step the triage returned, follow its reference file. Judgment steps
+(research, design, plan, evidence, docs, review) run inline, **one step per
+turn-commit**:
 
 1. Read the step's reference — for example:
    [research](references/RESEARCH.md), [design](references/DESIGN.md),
@@ -100,6 +101,23 @@ per turn-commit**:
 5. Commit with a conventional commit message.
 6. For implement steps, run the diff guard (step 4 below).
 
+Execution steps (implement, tests) **never run inline at the conductor's
+tier** — per-step model routing is reachable only across a turn boundary, so
+execution work hands off one phase per turn:
+
+```
+→ Next: /execute-phase <NN-slug> P<k> (tier: <tier>) — run phase P<k>; the lane resumes after the last phase
+  · no unfinished phase → continue the close-out ladder (step 6)
+```
+
+`<k>` is the first unfinished phase (the unit doc's Progress log records the
+phases done so far; `bun scripts/unit-route.mjs <NN-slug>` prints it) and
+`<tier>` is the `implement` entry of the triage block's `Tiers:` line. Never
+print the bare whole-unit `/execute-phase <NN-slug>` — whole-unit loop mode
+survives only as an explicit operator choice. When the last phase's turn
+closes, `execute-phase` resumes the lane and the remaining judgment steps
+(evidence, review, docs, release) run here.
+
 ### 4. Diff-size guard (after each implement step)
 
 Run `bun scripts/diff-guard.mjs --base <last-reviewed-ref> --unit <NN>`. Paste
@@ -116,12 +134,26 @@ Before every commit:
 - **Progress log**: `YYYY-MM-DD HH:MM — <what was done> → <commit sha> — next:
   <what is next>`
 
-### 6. Close the unit
+### 6. Close the unit — the close-out ladder
+
+When all triaged steps are done, in order:
+
+1. Run the review step (the in-doc `REVIEW-VERDICT` per
+   [review](references/REVIEW.md)).
+2. Resolve every `## Future` row with the user (planned now — registered on
+   explicit request only —, kept deferred, or discarded, dated).
+3. Update the unit doc's status and the index row (release step: branch
+   hygiene, PR creation, forge reconciliation).
+4. **Receipt stage.** The in-doc verdict is not the machine receipt. Verify
+   the PR's review receipt (`bun scripts/review-receipt.mjs verify --pr <N>`):
+   - **exit 0** (a current `review-change:pass` receipt at the settled head) →
+     the closing `→ Next:` recommends `/audit-pr <PR-url>` as the terminal
+     stage, with the receipt stated as its precondition.
+   - **otherwise** → the closing block is `→ Next: /review-change <NN-slug>`
+     (the receipt's sole owner) and `/audit-pr` is not printed — the gate is
+     never named before its precondition exists.
 
-When all triaged steps are done, run the review pack axis summary, update the
-unit doc's status, resolve every `## Future` row with the user (planned now —
-registered on explicit request only —, kept deferred, or discarded, dated),
-and print the closing block.
+A turn that ends with an unchecked ladder step is not done.
 
 ## Guardrails
 
@@ -140,16 +172,25 @@ and print the closing block.
 - Findings never authorize scope growth — record them, route to their owner
 - Never commit red (test failure) — fix or replan, never silence tests
 - Never alter a triaged step's order
+- Never run an execution phase inline or print a bare whole-unit
+  `/execute-phase` command — one phase per hand-off, tier attached
+- Never print `/audit-pr` before the PR's review receipt verifies current —
+  the receipt stage precedes the gate, always
 
 ## Relationship to other skills
 
 `unit-lane` absorbed the retired fixed-pipeline skills (design-feature,
-plan-feature, review-spec, review-plan) into catalog steps. The review pack axes
-(`review-implementation`, `review-code`, `review-security`, `review-perf`,
-`review-a11y`, `review-debt`) compose the review step; `triage-issue` feeds
-issues into the lane; `workflow-status` computes the next lane invocation.
-`init-workspace` seeds the unit doc template and catalog conventions into target
-projects.
+plan-feature, review-spec, review-plan) into catalog steps. `execute-phase` is
+the lane's executor: the lane conducts (triage, plan, evidence, review,
+close-out) and hands execution off one phase per turn at the phase's tier;
+its closing block names the next single phase and resumes the lane after the
+last one. The review pack axes (`review-implementation`, `review-code`,
+`review-security`, `review-perf`, `review-a11y`, `review-debt`) compose the
+review step; `/review-change` owns the SHA-bound receipt the close-out ladder
+verifies; `/audit-pr` is the terminal merge gate. `triage-issue` feeds issues
+into the lane; `workflow-status` computes the next lane invocation.
+`init-workspace` seeds the unit doc template and catalog conventions into
+target projects.
 
 ## Portability (agents other than Claude Code)
 
@@ -162,17 +203,20 @@ projects.
 
 ## Done when
 
-- Every triaged step is executed and committed.
+- Every triaged step is executed and committed — execution phases one
+  `/execute-phase <NN-slug> P<k>` turn each, never inline.
 - The unit doc's Evidence rows, Progress log, and References section are current.
-- The diff guard passed for all implement steps.
+- The diff guard passed for all implement steps (or an exception is recorded).
 - The review step is complete (or skipped per catalog).
+- The close-out ladder ran: receipt verified current, or the closing block
+  hands off to `/review-change` before any `/audit-pr` mention.
 - **The closing `→ Next:` block is printed.**
 
 ## Closing recommendation
 
 ```
-→ Next: /unit-lane <NN-slug> — continue to the next triaged step
-  · all steps done → /review-change (review the accumulated diff)
+→ Next: /execute-phase <NN-slug> P<k> (tier: <tier>) — run the next unfinished phase
+  · execution done, receipt current (verify --pr <N> exit 0) → /audit-pr <PR-url> — terminal merge gate; the current review-change:pass receipt is its precondition
+  · execution done, PR open, receipt missing → /review-change <NN-slug> — post the SHA-bound receipt first
   · re-triage needed → /unit-lane <NN-slug> --retriage
-  · finished and merge-ready → /audit-pr (merge gate)
 ```

package/skills/unit-lane/references/IMPLEMENT.md

@@ -2,42 +2,55 @@
 
 ## Purpose
 
-Execute the plan's tasks against the code. One phase per commit. Layer order
-respected. Guard enforced.
+Hand the plan's phases to the executor, one phase per turn. The conductor
+never runs an execution phase inline — per-step model routing is reachable
+only across a turn boundary (issue #291 AC3/AC4).
 
 ## Inputs
 
 - The unit's Tasks section (filled by the plan step)
-- The project's architecture doc (layer rules)
-- The diff guard baseline from the triage step's reference
+- The triage block's `Tiers:` line (the `implement` entry is the execution tier)
+- The unit's Progress log (which phases are done)
 
 ## Fixed output contract
 
-After each phase commit, update the unit doc's **Evidence** section and
-**Progress log**:
+At each execution boundary, print exactly one phase hand-off and end the turn:
+
+```
+→ Next: /execute-phase <NN-slug> P<k> (tier: <tier>) — run phase P<k>; the lane resumes after the last phase
+  · no unfinished phase → continue the close-out ladder
+```
+
+`<k>` = first unfinished phase (lowest `P<n>` bullet the Progress log does not
+record; `bun scripts/unit-route.mjs <NN-slug>` prints it). `<tier>` = the
+`implement` entry of the triage block's `Tiers:` line. Never the bare
+whole-unit command.
+
+When the last phase's turn closes, `execute-phase` resumes the lane. Verify
+its work landed in the unit doc before continuing:
 
 | AC | What was run | Exit / digest | Output (≤2 lines) | Verified-by |
 |---|---|---|---|---|
-| P1 | <git commit sha> | 0 · <sha> | <result ≤2 lines> | <model> |
+| P1 | <phase validator> | 0 · <sha> | <result ≤2 lines> | <executor model> |
 
 ## Checklist (pass only if)
 
-- [ ] Phases executed in P1, P2, … order from the Tasks section
-- [ ] One phase per commit (no bundling)
-- [ ] Layer order respected (inner layers don't import outer)
-- [ ] `git status --porcelain` is empty after each commit
-- [ ] Diff guard passed after each phase (see step 4 in SKILL.md)
-- [ ] Red run avoided — tests pass before committing, or tests-first red-run
-    evidence recorded
+- [ ] Every phase handed off as `/execute-phase <NN-slug> P<k> (tier: <tier>)`
+      — exactly one phase, never a bare whole-unit command
+- [ ] Phases ran in P1, P2, … order from the Tasks section
+- [ ] Each executor turn recorded its Evidence row and dated Progress entry
+- [ ] Diff guard run at the lane's resume (see step 4 in SKILL.md)
+- [ ] `git status --porcelain` is empty when the lane resumes
 
 ## Allowed
 
-- Changes scoped to the phase's acceptance criteria only
-- Bug fixes in affected paths that the phase touches
+- Changes scoped to the phase's acceptance criteria only (enforced by the
+  executor's own gates)
 - Documentation updates in the same commit as the code change
 
 ## Forbidden
 
+- Never run an execution phase inline at the conductor's tier
 - No unrelated refactors in the same commit
 - No new abstractions or dependencies beyond what the unit doc demands
 - Never commit red (test failure)

package/skills/unit-lane/references/REVIEW.md

@@ -5,6 +5,18 @@
 Proportional + materiality review. A finding blocks only when a user-visible
 outcome the ACs would miss, or a contract violation.
 
+## Receipt boundary (issue #291 AC1)
+
+The in-doc `REVIEW-VERDICT` is prose evidence, **not** the machine receipt
+`/audit-pr` consumes. The receipt's sole owner is `/review-change`
+(`bun scripts/review-receipt.mjs emit`). At close-out, with the PR open:
+
+- `bun scripts/review-receipt.mjs verify --pr <N>` exit 0 → the closing block
+  recommends `/audit-pr <PR-url>` as the terminal stage.
+- otherwise → the closing block is `→ Next: /review-change <NN-slug>` and
+  `/audit-pr` is never printed first. `n/a: no PR` is not a silent pass — the
+  release step opens the PR before close-out, so the hand-off always fires.
+
 ## Inputs
 
 - The unit's Evidence section (reviewer re-runs it)
@@ -42,4 +54,6 @@ REVIEW-VERDICT: PASS | FAIL
 - Never alter the acceptance criteria during review
 - Never approve without re-running the evidence
 - Never skip an axis the catalog demands
-- Never reuse a finding from a previous cycle without re-evaluating it
+- Never reuse a finding from a previous cycle without re-evaluating it
+- Never treat the in-doc verdict as the merge gate's receipt — the close-out
+  ladder verifies `review-receipt.mjs` before any `/audit-pr` mention

package/skills/unit-lane/references/TESTS.md

@@ -2,7 +2,11 @@
 
 ## Purpose
 
-Run and verify the tests the triage determined are applicable.
+Run and verify the tests the triage determined are applicable. Test execution
+rides the executor's phases (each phase's `validator:` runs the project's
+gate); when the tests step is the turn's own boundary, it hands off like
+implement does — one `/execute-phase <NN-slug> P<k> (tier: <tier>)` turn,
+never inline.
 
 ## Inputs