@gtrabanco/pi-agentic-workflow 0.31.0 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtrabanco/pi-agentic-workflow",
-  "version": "0.31.0",
+  "version": "0.34.0",
   "description": "Pi package: canonical agentic-workflow skills, friendly slash commands, and per-command model routing.",
   "keywords": [
     "pi-package",

package/skills/audit-pr/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: audit-pr
 user-invocable: true
-version: 5.6.2
+version: 5.6.3
 argument-hint: <pr-number> (optional — defaults to the current branch's PR)
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT

package/skills/audit-pr/references/03_AUDIT_PROCESS.md

@@ -29,8 +29,9 @@
    - **BLOCKED** — one or more gates fail; output the ranked blocker list.
 6. **Persist blockers to the fold ledger (BLOCKED verdict only).** Every blocker
    on a **BLOCKED** verdict is, by definition, fix-now — merge is gated on it.
-   Append each to the unit's fix-now fold ledger `review-findings.md` (same
-   location and fixed schema
+   Append each to the unit's fix-now fold ledger — its `## Findings` section for
+   a migrated unit (issue #308), `review-findings.md` for a legacy one; probe the
+   doc first and write to exactly one carrier (same fixed schema
    `| id | file:line | axis | severity | class | route | folded |` as
    `review-change`'s persist step) — the **same ledger**, not a separate one
    (D4: the fold cycle consumes one list). **Merged unit → no write** — check

package/skills/execute-phase/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: execute-phase
 user-invocable: true
-version: 6.2.1
+version: 6.2.2
 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>"
@@ -35,7 +35,8 @@ done:
 
 ```
 ✓ Required user inputs were answered concretely (not defaulted). Nothing here
-  is inferred: a gap runs `node scripts/needs-input.mjs <unit-dir>` and the
+  is inferred: a gap runs `bun scripts/needs-input.mjs <unit-dir>` (node fallback
+if bun is not installed) and the
   `open-questions@1` block is pasted, then the run stops.
 ✓ Triage verified — unit doc Evidence section header matches
   `bun scripts/unit-route.mjs --triage <slug>` output block (PREFLIGHT.md)
@@ -66,8 +67,8 @@ This skill **never interviews**. It reads its inputs — the unit doc's `Tasks`,
 one is a **gap**, resolved in one fixed order and never by inference:
 **(0) provenance** (search the repo's own docs and record where) →
 **(1) research** (2–3 concrete options with trade-offs; asking for more research
-is a legitimate answer) → **(2) halt**: run `node scripts/needs-input.mjs
-<unit-dir>`, paste the `open-questions@1` block verbatim, stop. Interactive the
+is a legitimate answer) → **(2) halt**: run `bun scripts/needs-input.mjs
+<unit-dir>` (node fallback if bun is not installed), paste the `open-questions@1` block verbatim, stop. Interactive the
 block is the pause point, unattended it is a hard fail. Grammar and exit codes:
 `orchestration-envelope`'s `references/TURN_CONTRACT.md` §Open questions.
 
@@ -81,9 +82,13 @@ path-protection checkpoint.
 ## Step 0 — Discover the project
 
 Per the agent guide's **Workflow conventions** + **documentation map**, read the
-unit doc at `docs/features/<NN-slug>/SPEC.md`. Verify it carries `## Tasks` (P1…Pn),
-`## Evidence`, and `## Progress` sections. If absent, the unit is not ready —
-stop and suggest `unit-lane` triage first.
+unit doc at `docs/features/<NN-slug>/SPEC.md`. Verify it carries `## Tasks` (P1…Pn)
+**and the receipt sections of the shape it is written in** (#308 accepts both):
+the legacy shape carries `## Evidence` + `## Progress log`, a re-cut unit doc carries
+`## Specs`, `## Findings` + `## Log` (its evidence and gate runs are `E`/`G` log
+lines, its progress is `P` lines). If neither pair is present, the unit is not ready —
+stop and suggest `unit-lane` triage first. `scripts/unit-route.mjs` resolves the
+shape; never judge a re-cut unit by the legacy headings and stop it.
 
 ## Process
 

package/skills/execute-phase/references/EXECUTION_CONTRACT.md

@@ -52,8 +52,10 @@ Something forbidden looks necessary → stop, record it in `decisions.md` or
 
 ## Step completion gate
 
-The step completion gate verifies that Evidence rows are complete for the
-step's acceptance criteria, the unit doc is committed clean, and the diff guard
+The step completion gate verifies that the step's acceptance criteria have
+complete evidence in the unit's own carrier — the `## Evidence` table rows for a
+legacy-shape unit, `## Log` `E` lines (command, exit, ≤2 lines of output) for a
+re-cut one (#308) — that the unit doc is committed clean, and that the diff guard
 (if applicable) passed. The mark's shape, ownership, and reuse rule are
 declared in `LEDGERS.md` (§gate-ran@1).
 
@@ -76,7 +78,8 @@ GATE-RAN | HEAD <40-hex sha> | <cmds> | exit <code>
 ✓ Verification gate green — type-check + tests + build actually RUN (paste exit
   status), never assumed
 ✓ Every task of this step checked off in the unit doc's `Tasks` section, each
-  mapped to an Evidence row (code path or test name)
+  mapped to an Evidence row (legacy shape) or an `E` log line (re-cut shape) —
+  code path or test name
 ✓ Tests updated/added for every behavior this step changed
 ✓ Tests-first red run recorded (core/domain + orchestration steps, n/a for
   test-after UI/adapter steps) — the failing first run's command, exit status,
@@ -88,10 +91,12 @@ GATE-RAN | HEAD <40-hex sha> | <cmds> | exit <code>
   consumers)
 ✓ Architecture doc respected (dependency directions, layer boundaries)
 ✓ Architectural invariants preserved or backed by an explicit recorded decision
-✓ Evidence rows complete for the step's ACs — unit doc committed clean
-  (one dated `YYYY-MM-DD HH:MM` Progress entry, all Evidence rows current)
-✓ Docs COMMITTED with the step — the unit doc carries all required sections
-  (Tasks, Evidence, Progress, References); no orphan files remain
+✓ The step's ACs have complete evidence in the unit's carrier — unit doc committed
+  clean (one dated `YYYY-MM-DD HH:MM` Progress entry or `P` log line, all evidence
+  current)
+✓ Docs COMMITTED with the step — the unit doc carries all required sections of its
+  own shape (Tasks + Evidence + Progress + References for legacy; Specs + Tasks +
+  Findings + Log + References for re-cut); no orphan files remain
 ```
 
 A step that cannot tick every box is **not done**: fix within the step's
@@ -123,8 +128,9 @@ planned work, and inference never prove implementation. A present ledger whose
 status is `draft`, `contradicted`, or `resolved` stops implementation and routes
 to discovery or resolution first. If no ledger exists, inspect the repository
 directly and record `n/a: no normalized repository state`; NRS is optional.
-Unit doc evidence rows (Evidence, Progress) are the single source of truth
-for step completion — no separate ACCEPTANCE.md, progress.md, or TASKS.md.
+Unit doc evidence is the single source of truth for step completion — the
+`## Evidence`/`## Progress log` sections of a legacy-shape doc, the `## Log` lines of
+a re-cut one (#308) — never a separate ACCEPTANCE.md, progress.md, or TASKS.md.
 
 ## Architectural invariants
 

package/skills/execute-phase/references/FOLDING.md

@@ -24,10 +24,12 @@ findings end up "solved" locally but absent from the merged PR:
 ✓ Gate RUN and green (exit codes pasted)
 ✓ Never edit an existing test's expectation to match behaviour — a setup
   repair keeps assertions at least as strong and never touches expectations
-✓ Evidence rows updated where the finding touched them (the finding's row
-  in the unit doc's Evidence ledger flipped `folded: no → yes` — the one and
-  only state transition, `ledger-ownership@1` / `fold-findings:folded-flag`
-  is the sole writer)
+✓ Evidence rows updated where the finding touched them, in the unit's own findings
+  carrier: a legacy row flipped `folded: no → yes`; a migrated unit's row leaves
+  `## Findings` and its fold is a `## Log` `F` line naming the fold commit — that
+  carrier has no `folded` column to flip (#308). Either close is the one and only
+  state transition, and `ledger-ownership@1` / `fold-findings:folded-flag` is the
+  sole writer of it
 ✓ Progress log advanced with a dated entry noting the fold
 ✓ `git add` + `git commit` RUN (sha pasted) — e.g.
   `fix(<scope>): fold review findings — <summary>`
@@ -56,8 +58,9 @@ No auto-merge. Explicit `P<k>` stops after one step; omitted-step mode gates
 and commits every remaining step before the same final review.
 ## Gate-run marks (gate-ran@1)
 
-Every verification gate this cycle runs records a `GATE-RAN` mark in the unit
-doc's Evidence section at the head it actually ran:
+Every verification gate this cycle runs records a `GATE-RAN` mark at the head it
+actually ran — a row in the legacy `review-findings.md`, a `## Log` `G` line for a
+re-cut unit (#308):
 `GATE-RAN | HEAD <40-hex sha> | <cmds> | exit <code>`. A green run is recorded;
 a red run is also recorded (exit code ≠ 0 is evidence, not silence). Any skill
 may consume a green mark only at the identical HEAD — a changed head re-runs
@@ -70,5 +73,5 @@ the gate. The recorders are `execute-phase:gate-ran-marks` and
 When the final triaged step closes: mark the unit done, push the branch, and
 open the PR with `gh pr create` (per the project's Workflow conventions) —
 regardless of the review still to come. The PR body carries the unit doc's
-Evidence section as its verification record and closes the unit's tracked
-issues via `Closes #N`.
+verification record (its `## Evidence` rows, or a re-cut unit's `## Log` `E`/`G`
+lines) and closes the unit's tracked issues via `Closes #N`.

package/skills/execute-phase/references/PREFLIGHT.md

@@ -125,7 +125,10 @@ block text, no-forgery and legacy detail:
 Consume `skills/verification-contract/SKILL.md`. For a current-format unit,
 the Evidence section in the unit doc **is** the acceptance manifest — each
 acceptance criterion has a corresponding Evidence row with command, exit/digest,
-and output. No sibling file; the unit doc's Evidence section header carries the
+and output. A re-cut unit (#308) has no Evidence section by design: its acceptance
+manifest is `## Specs`, and each criterion's receipt is a `## Log` `E` line; the
+gate below reads that carrier instead, and never stops a migrated unit for lacking
+a section its own template retired. No sibling file; the unit doc's Evidence section header carries the
 last-reviewed sha. The unit doc's triage block (pasted verbatim from
 `scripts/unit-route.mjs --triage`) is the step authority: `execute-phase` runs
 only what the triage block demands.
@@ -136,8 +139,9 @@ only what the triage block demands.
 - Missing/mismatched Evidence (unit doc has been edited since last execution)
   → print the verification contract's fixed `EVIDENCE GATE` block and stop.
   `--force` never bypasses a changed acceptance state.
-- Unit with no Evidence section → the unit doc template was incomplete;
-  create the section before proceeding.
+- Unit with no Evidence section and no `## Log` → the unit doc template was
+  incomplete; create the section its shape requires before proceeding. A doc with
+  `## Log` is the re-cut shape: its `E`/`G` lines are the rows, never a gap.
 
 Run this check before each step in whole-unit mode. The executor may add tests
 but may not narrow acceptance criteria, weaken assertions, or edit the Acceptance

package/skills/fold-findings/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: fold-findings
 user-invocable: true
-version: 1.9.0
+version: 1.9.2
 argument-hint: [finding-id …]
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT
@@ -49,19 +49,30 @@ postpone/wontfix/promote/documented-tradeoff rows; those belong to `/triage-issu
 
 Per Workflow conventions, read:
 
-1. The unit's `review-findings.md` under `docs/features/<NN>-<slug>/` or
-   `docs/fix/<n>-<topic>/`; schema is owned by `review-change`/`audit-pr`:
-
-   ```
-   | id | file:line | axis | severity | class | route | folded |
-   ```
-
-   After `VERDICT: BLOCKED`, append missing rows (`class: fix-now`, `folded: no`,
-   next free `Fn`, dedupe `file:line`+axis), commit as
-   `docs(<unit>): reconstruct fold ledger from audit-pr blockers`, then fold;
-   never report “no findings”.
-2. Queue `folded: no` rows; explicit IDs restrict it and leave other rows
-   untouched. Group by root cause, verifier and rollback boundary.
+1. The unit's findings carrier: a migrated unit (issue #308) keeps its OPEN rows
+   in its own `SPEC.md` under `## Findings`, with folded history and marks as
+   `## Log` lines; a legacy unit keeps `review-findings.md` under
+   `docs/features/<NN>-<slug>/` or `docs/fix/<n>-<topic>/`. Probe the doc first and
+   fall back to the file — a unit with the section never reads both. Each carrier
+   has **its own** schema, owned by `review-change`/`audit-pr` and stated for both
+   shapes in `pre-execution-review/references/LEDGERS.md`:
+
+   - legacy (7 cols): `\| id \| file:line \| axis \| severity \| class \| route \| folded \|`
+     — closing a row flips `folded: no → yes`, and this skill is that flip's sole writer
+   - migrated (6 cols, `findings-table@1`): `\| id \| S# / file:line \| axis \| severity \|
+     class \| route \|` — every row it holds is OPEN; closing one **deletes the row** and
+     appends a `## Log` `F` line naming the fold commit. There is no `folded` column to
+     flip, and `class` here is the repairing owner (`product`/`plan`/`source`/
+     `environment`/`runtime`), not a disposition.
+
+   Never write one carrier's row into the other's grammar. After `VERDICT: BLOCKED`,
+   append missing rows in the carrier's own schema (next free `Fn`, dedupe
+   `file:line`+axis; legacy `class: fix-now`, `folded: no`), commit as
+   `docs(<unit>): reconstruct fold ledger from audit-pr blockers`, then fold; never
+   report “no findings”.
+2. Queue the carrier's open rows — a legacy `folded: no` row, a migrated row of
+   `## Findings` (all of them are open); explicit IDs restrict the queue and leave
+   other rows untouched. Group by root cause, verifier and rollback boundary.
 3. The project's verification gate and forge CLI (use the declared forge).
 4. Whether the branch has an open PR; this decides immediate push after commit.
 
@@ -126,7 +137,7 @@ conclusion the already-run router printed, never the invocation itself: on
 `route: replan` the planner command it printed — `/unit-lane <slug>` for a
 feature unit or `/unit-lane --fix <n>` for a fix unit; on `route: decision` stop
 and surface the decision to the user, never a planner. `<unit>` is the bare folder number or the full slug (both resolve). The invocation
-`node scripts/unit-route.mjs <unit>` is the discovery step the fold already
+`bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed) 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`
@@ -212,8 +223,8 @@ 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) |
+| 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 `bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed; 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 `bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed; 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 |
 | empty batch (class `none`) | `RE-REVIEW-OPTIONAL` | `/review-change` by default — safe: the head is unchanged |

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

@@ -43,8 +43,10 @@
 
    | 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 |
+   | ≥ 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 `bun scripts/unit-route.mjs <unit>` (node fallback
+if bun is not installed) (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 `bun scripts/unit-route.mjs <unit>` (node fallback
+if bun is not installed): `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 |
 
@@ -60,7 +62,7 @@
    `DISPUTED <evidence → user decision>`; never edit classification or create an
    issue.
 9. **Replan.** If the smallest correct group exceeds a reviewable correction,
-   run `node scripts/unit-route.mjs <unit>` — its `route: replan` line prints the
+   run `bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed) — its `route: replan` line prints the
    planner command (`/unit-lane <slug>` for a feature, `/unit-lane --fix <n>` for
    a fix) that appends the proposed
    phases to the unit's SPEC. The `<unit>` argument accepts the bare folder number

package/skills/orchestration-envelope/references/TURN_CONTRACT.md

@@ -17,7 +17,8 @@
 ```
 
 **A box that runs a command discloses what the command needs.** When a box
-invokes a script with a placeholder (`node scripts/x.mjs <unit-dir>`), the same
+invokes a script with a placeholder (`bun scripts/x.mjs <unit-dir>`; node fallback
+if bun is not installed), the same
 skill's text must name the artifact that placeholder requires — the script
 declares it (`PREREQUISITES` in `scripts/needs-input.mjs`) and
 `scripts/promise-coherence.mjs` checks the disclosure. A box that instructs a

package/skills/pre-execution-review/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: pre-execution-review
 user-invocable: false
-version: 2.8.0
+version: 2.8.2
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT
 description: >

package/skills/pre-execution-review/references/LEDGERS.md

@@ -8,13 +8,35 @@ Plan snapshot binds them, and `execute-phase` may not invent a substitute.
 |---|---|---|---|
 | Planning evidence | `### Planning evidence` inside the unit doc (XS/S) · separate file (M/L) | `unit-lane:planning-evidence` | `execute-phase`, `fold-findings`, `audit-pr` |
 | Obligations | `### Obligations` inside the unit doc (XS/S) · separate file (M/L) | `unit-lane:obligations` | `execute-phase`, `fold-findings`, `audit-pr` |
-| Findings | `review-findings.md` (one per unit, both stages) | reviewers append; only the stage's author resolves | `execute-phase` on re-review, `audit-pr` |
+| Findings | the unit doc's `## Findings` (a migrated unit, issue #308) · `review-findings.md` (a legacy unit) | reviewers append; only the stage's author resolves | `execute-phase` on re-review, `audit-pr` |
 
 XS/S embeds both tables in the SPEC to stay within the size's artifact budget;
 the Plan snapshot then binds them through the whole-SPEC row (kind `spec`), and
 the `planning-evidence` / `obligations` snapshot rows are `absent`, not forged.
 M/L freeze the separate files and bind them with their own rows. Never both.
 
+**One findings carrier per unit, one read path.** A unit opened after the
+`spec-by-reference` re-cut (issue #308) carries its OPEN rows in the unit doc's
+`## Findings` table and its folded history, review marks (`REVIEW-RAN`), finding
+marks (`VF-<n>`) and gate runs (`GATE-RAN`) as `## Log` lines whose kind token is
+the `log-kind@1` vocabulary. That unit has **no `review-findings.md`**. A legacy
+unit keeps the side ledger it was written with and is never rewritten to migrate
+it. Readers probe the doc first and fall back to the file; a unit with the
+section never reads both, so a stale side file can never outvote the doc. The
+carrier change retires nothing the review machinery produces: each mark a legacy
+ledger row carried is a log line here, with the same identifier, the same head
+SHA and the same exit code — no new receipt enters without one retiring.
+
+Both carriers are **one truth class**: the `review-findings` row below owns the
+writers of the OPEN rows and every mark in either carrier — the map keys one *file* per
+class, so a migrated unit's `## Findings`/`## Log` are that ledger inside the unit doc,
+never a new class or a second owner set. One mark, two grammars: review run =
+`review-mark@1` row / `## Log` `R` line; gate run = `gate-ran@1` row / `G` line; finding
+verification = `finding-mark@1` row / `V` line; folded finding = the `folded: no → yes`
+flip / the row leaving for an `F` line; OPEN finding = seven-column row / six-column
+`findings-table@1` row. A migrated unit has no `folded` cell to flip; a legacy unit has
+no `R`/`V` grammar.
+
 ### 1. Planning evidence
 
 Row shape — the base row, the closed `authority-kind` / `freshness` vocabularies,
@@ -167,7 +189,9 @@ documentation, not by this map.
 A review that ends with no fix-now finding writes no finding row, so the map gives
 it a row of its own in the unit's `review-findings.md` ledger, under
 `review-change:review-mark`. [POLICY.md](POLICY.md) §8 owns *when* an act marks;
-this owns the shape:
+this owns the shape. A **migrated** unit writes the same mark as a `## Log` `R` line —
+`- **R<n>** — <date>, review at HEAD <40-hex> · verdict <verdict> · cycle <n> · gate
+exit <code>` — and `scripts/workflow-status.mjs` reads either carrier, never both:
 
 ```text
 review-mark@1
@@ -203,6 +227,10 @@ or a re-review trigger. The mark's `confirmed | refuted` value and the
 `recheck` cell (the method the finding's axis demands) are what let a driver
 outside the repo consume the verification the review performed.
 
+A **migrated** unit signs the same way as a `## Log` `V` line — `- **V<n>** —
+<file:line> · reviewer <name> · HEAD <40-hex> · recheck <method + reproducer> ·
+confirmed | refuted` — whose `recheck` cell `fold-findings` consumes.
+
 `fold-findings` reads the `recheck` cell to **materialize** the finding's
 reproducer as its regression check — it never re-derives it; a `recheck` cell
 that cannot be materialized yields `BLOCKED <missing input>`. This consumption

package/skills/review-change/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: review-change
 user-invocable: true
-version: 3.12.1
+version: 3.13.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/OUTPUT_AND_GUARDRAILS.md

@@ -27,7 +27,8 @@ lost, and none becomes reviewer-created backlog (D3):
   always fix-now / replan-in-unit — never a postpone/tradeoff/wontfix/new-issue
   escape.
 - **fix-now / `replan-in-unit`** (too large to fold as-is) → keeps its fix-now
-  class and ledger row; run `node scripts/unit-route.mjs <unit>` — its
+  class and ledger row; run `bun scripts/unit-route.mjs <unit>` (node fallback
+  if bun is not installed) — its
   `route: replan` line prints the planner command (`/unit-lane <unit>` for a
   feature, `/unit-lane --fix <n>` for a fix). The lane re-runs its plan step on
   this branch, the user confirms the appended SPEC phase(s), its review step

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

@@ -4,16 +4,35 @@ When the unit's review receipt is missing or stale, the re-entry command is the
 **emitted** `next.continuation` (`rendering` for display) — quote it, never author
 exact command tokens.
 
-11. **Persist fix-now findings to the fold ledger.** The unit's **fix-now fold
-   ledger** is `review-findings.md`, located beside its other docs
+11. **Persist fix-now findings to the fold ledger.** A migrated unit (issue #308)
+   carries the ledger in its own `SPEC.md`: OPEN rows in `## Findings`, and the
+   review, gate and finding-verification marks as `## Log` lines (the `R`, `G` and
+   `V` kinds of the published `log-kind@1` vocabulary) carrying their exit codes and
+   head SHA. A legacy unit keeps the side file beside its other docs
    (`docs/features/<NN>-<slug>/review-findings.md` for a feature,
-   `docs/fix/<n>-<topic>/review-findings.md` for a fix), fixed schema:
-
+   `docs/fix/<n>-<topic>/review-findings.md` for a fix). Probe the doc first and
+   write to exactly one carrier — a unit with the `## Findings` section never
+   gains a side file. Each carrier has **its own** fixed schema; a row is never
+   written in the other's grammar:
 
    ```
    | id | file:line | axis | severity | class | route | folded |
    ```
 
+   is the legacy schema, and only a legacy unit is written with it. A migrated unit
+   writes `findings-table@1` — six columns, no `folded` cell, and `class` holding
+   the owner that repairs the row (`product`/`plan`/`source`/`environment`/`runtime`)
+   while `route` holds the disposition (`fold`/`replan-in-unit`/`decision-required`/
+   `product owner — …`) — the grammar the unit doc itself publishes:
+
+   ```
+   | id | S# / file:line | axis | severity | class | route |
+   ```
+
+   `folded: no → yes` is therefore a **legacy-only** flip: in a migrated carrier a
+   closing fold deletes the row and appends its `## Log` `F` line, and `ledger-ownership@1`
+   / `fold-findings:folded-flag` stays the sole writer of whichever close it is.
+
    **Merged unit → no write** (a PR exists and its state is `MERGED` — check
    `gh pr view --json state` when a PR is open; otherwise the unit is unmerged
    by definition). Otherwise, for each **fix-now** finding of severity `high`
@@ -22,11 +41,12 @@ exact command tokens.
    `CLASSIFY.md`):
    append a row
    (create the file with the header row when missing), carrying the
-   verbatim `Sev` value into `severity`; `folded` always starts `no` — that
+   verbatim `Sev` value into `severity`; a legacy row's `folded` always starts `no`
+   (a migrated row has no such cell — every row in `## Findings` is open) — that
    row comes from a **confirmed** candidate only and carries its
-   `finding-mark@1` signature on a **separate `VF-` row** (reviewer, head SHA,
-   recheck + reproducer), as modeled in `LEDGERS.md` (§finding-mark@1) and the
-   fixture.
+   `finding-mark@1` signature as a **separate `VF-` row** in a legacy carrier, or as
+   a `## Log` `V` line in a migrated one (reviewer, head SHA, recheck + reproducer),
+   as modeled in `LEDGERS.md` (§finding-mark@1) and the fixture.
    `ledger-ownership@1` / `fold-findings:folded-flag` is the sole writer of
    the `folded: no → yes` flip.
    A `low` finding is **never persisted to the fold ledger** — report-only
@@ -138,7 +158,8 @@ 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? → `node scripts/unit-route.mjs <unit>` prints
+      · any finding owned by product? → `bun scripts/unit-route.mjs <unit>` (node fallback
+        if bun is not installed) 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)

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

@@ -170,12 +170,20 @@ cycles without convergence, the review prints
 LOOP CAP REACHED — <unit>
 - Finding ids: <every open id>
 - Cycles: 2 (REVIEW-RAN marks + forge receipts)
-- Route: /triage-issue --prioritize-now <unit> F<k> … (or the programmatic outer driver)
+- Expected diff: <per finding: files cited and whether it hits a normative surface>
+- Decision: the owner decides — no route is auto-selected
 ```
 
 A **third cycle never starts** unless the user explicitly instructs it — it is
-the user's escape, never a reviewer election. The residue routes to
-`triage-issue --prioritize-now` (or the programmatic outer driver), and a unit
-that needs a third cycle has a planning or root-cause defect, not a review
-deficit. Re-runs count **separate review invocations**, not in-session steps:
-`/review-change` is invoked by the user in a fresh turn each time.
+the user's escape, never a reviewer election. The cap **stops and hands the
+decision back**, emitting no route of its own: this is the moment with the least
+evidence about the findings, and an auto-selected escape is how a fix escapes
+its own gate (F34).
+
+**`--prioritize-now` is an escape, never the default.** The owner may force
+`/triage-issue --prioritize-now <unit> F<k>` for an **in-scope** finding whose
+expected diff is small: at most two files, no `normative-surfaces@1` surface, no
+published contract or package version. Size is the only gate — a `security` or
+`package` row is never "too expensive to fold now".
+Re-runs are **separate review invocations** and not in-session steps:
+`/review-change` is invoked by the user in a fresh turn.

package/skills/review-implementation/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: review-implementation
 user-invocable: false
-version: 1.11.1
+version: 1.12.0
 argument-hint: <path-or-glob>
 allowed-tools: Read, Grep, Glob, Bash, WebFetch
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
@@ -69,6 +69,13 @@ then the current-unit contract (fix-now / replan-in-unit / decision-required
 for in-scope work), then `proposal` for genuinely independent future
 capabilities. One pass — no per-pass or per-reviewer classification.
 
+Every classified row also carries an explicit `scope: in-unit | new-unit` cell
+(`#308` review, F33) filled from evidence — the row's `file:line` against the
+unit's `## Impact` set and the files the unit's own commits touch — never from
+an impression of size or axis. Scope decides disposition (in-unit is always
+`fix-now`); size decides only whether that fix folds directly or needs
+`replan-in-unit`. `triage-issue` consumes the cell and never re-derives it.
+
 ## Context budget
 
 The input is the synthesized table, not the diff. Read at most 10 non-diff
@@ -97,7 +104,8 @@ each classification as its table row immediately and drop raw file content.
   rubric.
 - Sits in **Stage 4** of the feature workflow (verification & review).
 - `fix-now` folds into the current unit; `replan-in-unit` runs
-  `node scripts/unit-route.mjs <unit>`, whose `route: replan` line names the
+  `bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed),
+  whose `route: replan` line names the
   planner that appends user-confirmed phases before `execute-phase`;
   `decision-required` blocks for the user; independent work becomes proposals
   the user routes to `triage-issue` (D3).

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

@@ -96,6 +96,22 @@ reviewer-created issue creation are **forbidden** (AC 10). A previously approved
 trade-off is **cited as existing evidence**, never reinvented by review.
 `disputed` remains a later fold/user outcome, not a reviewer shortcut.
 
+### Scope is evidence, not impression (F33)
+
+Every classified row carries a `scope: in-unit | new-unit` cell, contrasted
+with what the unit declared:
+
+| Answer | Test |
+|---|---|
+| **in-unit** | path in the unit's `## Impact` set, in files its commits touch, or a surface it created/moved/claimed unchanged |
+| **new-unit** | path outside that set **and** the defect already exists at the base commit |
+| **undecidable** | the set is missing or the path is ambiguous — state the gap; never guess `new-unit` to escape |
+
+**Scope decides disposition, never size:** an in-unit defect is `fix-now`
+whatever its axis (`security`/`package` included); size only chooses fold vs
+`replan-in-unit`. "The unit did it" outranks "the path looks foreign".
+`triage-issue` consumes the cell, never re-derives it.
+
 ### Step 3 — Independent future capabilities → proposals, never issues
 
 Only a **truly independent future capability** — work the current unit does not
@@ -109,7 +125,7 @@ the user routes a proposal to `triage-issue`.
 An in-scope fix-now too large to fold as-is (multi-file redesign, or evidence
 the unit should have been split) keeps its **fix-now** class — size is never a
 reason to downgrade. Set its `Route` to **`replan-in-unit`**: run
-`node scripts/unit-route.mjs <unit>` — its `route: replan` line prints the
+`bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed) — its `route: replan` line prints the
 planner command (`/unit-lane <unit>` for a feature, `/unit-lane --fix <n>` for a
 fix) — and the unit's SPEC `## Phases`
 ledger gets one or more new phases covering the work, on the SAME branch, the
@@ -152,7 +168,8 @@ your domains):
 
 - **fix-now** → fold directly into the current unit's open phase; never a
   tracked issue, never a standalone planner (AC 12).
-- **fix-now / `replan-in-unit`** → `node scripts/unit-route.mjs <unit>` prints
+- **fix-now / `replan-in-unit`** → `bun scripts/unit-route.mjs <unit>` (node fallback
+  if bun is not installed) prints
   `route: replan`; the planner command it prints re-cuts the SPEC `## Phases`
   ledger
   (user confirms), the lane's `review` step gates, then `execute-phase`
@@ -174,8 +191,8 @@ finding in its `Route` cell.
 | Owning stage | Hand-off | Never |
 |---|---|---|
 | `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` | 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 |
+| `plan` | run `bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed) → `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` | run `bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed) → `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,15 +1,16 @@
 ---
 name: triage-issue
 user-invocable: true
-version: 2.11.0
+version: 2.12.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
 description: >
   Verify an issue, persisted audit finding, or unresolved review finding against
   current code, classify it, and write only the contracted forge/ledger
-  outcome. Supports independent batches and an immediate-fix review-finding
-  route. Triggers: "triage-issue", "triage issue N", "triage this finding",
+  outcome. Supports independent batches and a routed review-finding
+  route: a `fix-now` row is handed to `/fold-findings`, never implemented
+  here. Triggers: "triage-issue", "triage issue N", "triage this finding",
   "is this trigger met".
 ---
 
@@ -25,7 +26,7 @@ premature work (acting on a deferred item whose trigger is unmet) and silent rot
 ✓ One fixed-format verdict block per issue (Trigger / Checked / Evidence / VERDICT / Action) — plus the summary table when batched
 ✓ Nothing deferred was implemented inline
 ✓ Audit-finding mode (`<audit-id> F<k>`): the audit file carries its `↳ triaged` note, and any opened issue cites `Origin: product audit <id>, finding F<k>`
-✓ Review-finding mode (`--prioritize-now <unit> F<k>`): every named unresolved finding gets a verdict, an immediate-fix attempt, or an explicit replan/user-decision route
+✓ Review-finding mode (`--prioritize-now <unit> F<k>`): every named unresolved finding gets a verdict **and a route** — a `fix-now` row is routed to `/fold-findings` (or an explicit `/execute-phase <unit> P<n>`), never implemented in this turn
 ✓ Batched input? The closing recommendation maps every issue/finding ID to its own next command, joined with ` + `; it never collapses to one generic action
 ✓ Artifact language: explicit user instruction > the project's declared docs language > English. The CONVERSATION language never decides — a Spanish prompt still produces English PRs/issues/commits/SPECs unless one of the first two says otherwise
 ✓ The closing `→ Next:` block is printed as the ABSOLUTE last output
@@ -47,10 +48,14 @@ first on purpose).
   from a persisted `product-audit` report instead of existing issues (see
   *Audit-finding mode* below). Batching works the same way.
 - **Review findings** — `triage-issue --prioritize-now <unit> F<k> [F<j> …]`
-  triages unresolved rows from the current feature/fix unit's
-  `review-findings.md`. This route is for findings that `fold-findings` could
-  not close. `--prioritize-now` means attempt to resolve every named finding
-  immediately; it does not permit a downgrade, postponement, or silent drop.
+  triages unresolved rows from the current feature/fix unit's findings carrier:
+  its `## Findings` section in `SPEC.md` for a migrated unit (issue #308), or
+  `review-findings.md` for a legacy one — probe the doc first, never both. This
+  route is for findings that `fold-findings` could not close. `--prioritize-now`
+  forces the fold route for the named rows in this turn instead of queuing them
+  for a later turn; it does not permit a downgrade, postponement, or silent
+  drop, and it never authorizes implementing them here — the fold owns the fix
+  and the `folded:` flip.
 
 
 ## Step 0 — Discover the project (always first)
@@ -86,7 +91,7 @@ read another `references/` path. After Step 0:
 - Before applying an urgency or disposition label, read
   [label vocabulary](references/LABELS.md); this file is the sole definition of
   names, colors, and mutation rules.
-- Only when the verdict is `fix-in-unit`, read
+- Only when the verdict writes a row (`fix-in-unit` or `fix-now`), read
   [fold ledger](references/FOLD_LEDGER.md) before writing the row.
 
 Every resource is one hop from this file. A missing source artifact or required
@@ -121,9 +126,10 @@ triage-issue ────┤                    or fold-findings (ledger row)
                  └─ wontfix ─────────▶ propose close
 ```
 
-In review-finding mode, `replan-in-unit` runs `node scripts/unit-route.mjs
-<unit>`: its `route: replan` line prints the planner command — `/unit-lane
-<unit>` for a feature, `/unit-lane --fix <n>` for a fix — which re-runs the
+In review-finding mode, `replan-in-unit` runs `bun scripts/unit-route.mjs
+<unit>` (node fallback if bun is not installed): its `route: replan` line prints
+the planner command — `/unit-lane <unit>` for a feature, `/unit-lane --fix <n>`
+for a fix — which re-runs the
 lane's `plan` catalog step and appends new `P<n>` phases to the same unit. The
 lane's own `review` step is the gate before execution. The user manually runs
 those phases; this skill never implements them.

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

@@ -1,14 +1,22 @@
 ## Ledger-append mechanism (`fix-in-unit` → fold-into-ledger sub-route)
 
 When the *fold into the unit's ledger* sub-route (step 3 above) applies,
-append one row to the open unit's `review-findings.md` — the same fold ledger
-`review-change` and `audit-pr` write to, in their **fixed 7-column schema,
-never redefined here**:
+append one row to the open unit's findings carrier — probe the unit doc first: a
+migrated unit (#308) carries its OPEN rows in `SPEC.md ## Findings` and never gains
+a side file, a legacy unit keeps `review-findings.md`. It is the same fold ledger
+`review-change` and `audit-pr` write to, in the **carrier's own fixed schema, never
+redefined here** — the legacy 7-column row:
 
 ```
 | id | file:line | axis | severity | class | route | folded |
 ```
 
+and the migrated 6-column `findings-table@1` row (`id`, `S# / file:line`, `axis`,
+`severity`, `class` = the owner that repairs it, `route` = the disposition), whose
+rows are open by definition: closing one deletes the row and appends a `## Log` `F`
+line. Writing a 7-column row, or a `folded` flip, into a migrated unit's table is a
+carrier violation, not a formatting slip.
+
 The appended row: `folded` starts `no` (this skill never sets `folded: yes` —
 that transition belongs solely to `/fold-findings`), and the `route` cell
 carries a **provenance marker** identifying this row was born from a triage

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

@@ -22,8 +22,9 @@
      issue on that unit's own branch, never as a new standalone unit. Pick
      exactly one of these sub-routes:
      - *repairable as-is* → **fold into the unit's** current/next phase, or
-       append a provenance-marked row to the unit's `review-findings.md` (see
-       *Ledger-append mechanism* below).
+       append a provenance-marked row to the unit's findings carrier — `SPEC.md
+       ## Findings` for a migrated unit (#308), `review-findings.md` for a legacy
+       one, never both (see *Ledger-append mechanism* below).
      - *changes the unit's shape* → **incremental replan** on the same unit:
        name the exact command — `/unit-lane <slug>` (the lane re-reads the
        SPEC, re-triages, and re-runs its `design`/`plan` catalog steps) — or a

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

@@ -4,8 +4,12 @@ Use this route only for `/triage-issue --prioritize-now <unit> F<k> [F<j> …]`
 after `/fold-findings` leaves rows unresolved.
 
 1. Read the target unit's SPEC, frozen acceptance, current PR HEAD, the full
-   `review-findings.md`, and the evidence for every named row. Confirm that
-   each row is still `folded: no`; never triage a row already folded.
+   findings carrier — the unit doc's `## Findings` for a migrated unit (#308),
+   `review-findings.md` for a legacy one, probed in that order and never both —
+   and the evidence for every named row. Confirm the row is still open in its own
+   carrier: `folded: no` in a legacy ledger, still present in `## Findings` for a
+   migrated unit (a folded row has left that table for a `## Log` `F` line); never
+   triage a row already folded.
 2. Reproduce or verify every finding against the current code. Keep the
    finding's original ID, severity, class, and route in the report. Do not
    turn a review finding into a generic issue just to make it disappear.
@@ -13,11 +17,16 @@ after `/fold-findings` leaves rows unresolved.
 
    - A complete correction that fits the current unit and is reviewable now
      remains on the current unit. Route it to `/fold-findings` or an explicit
-     `/execute-phase <unit> P<n>`.
+     `/execute-phase <unit> P<n>` — **never implement it in this turn**. The
+     fold owns the fix, the gate and the `folded:` flip: writing the flip here
+     would make this skill the second owner of a state
+     `ledger-ownership@1` assigns solely to `fold-findings:folded-flag`
+     (`LEDGERS.md`), so a row this skill appends starts `folded: no` and stays
+     that way until the fold closes it.
    - A correction too large for the current fold is `replan-in-unit`. Run
-     `node scripts/unit-route.mjs <unit>`; its `route: replan` line prints the
-     planner command — `/unit-lane <unit>` for a feature, `/unit-lane --fix <n>`
-     for a fix — which re-runs the lane's `plan` step and appends concrete
+     `bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed);
+     its `route: replan` line prints the planner command — `/unit-lane <unit>` for a
+     feature, `/unit-lane --fix <n>` for a fix — which re-runs the lane's `plan` step and appends concrete
      `P<n>` phases to the unit's SPEC, preserving the finding's acceptance
      evidence. The lane's `review` step gates execution.
    - A product, architecture, or acceptance decision that blocks safe work is
@@ -26,8 +35,8 @@ after `/fold-findings` leaves rows unresolved.
      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>`
+     `bun scripts/unit-route.mjs <unit>` (node fallback if bun is not installed);
+     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).

package/skills/unit-lane/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: unit-lane
 user-invocable: true
-version: 2.4.1
+version: 2.4.3
 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
@@ -23,8 +23,9 @@ done:
 ```
 ✓ Required user inputs were answered concretely (not defaulted). Nothing here
   is inferred: a gap re-enters provenance → research, and a gap surviving both
-  runs `node scripts/needs-input.mjs <unit-dir>` and stops with the
-  `open-questions@1` block routed back to the owning stage.
+  runs `bun scripts/needs-input.mjs <unit-dir>` (node fallback if bun is not
+  installed) and stops with the `open-questions@1` block routed back to the
+  owning stage.
 ✓ Every claim the SPEC or the plan asserts (objective, why, ACs, tasks) cites
   its source — `path:line`, a doc, or an owner answer in the unit folder's
   `sources.md`. A claim with none is a question, never a default.
@@ -37,8 +38,9 @@ done:
   if new, with all mandatory sections filled or n/a)
 ✓ Guard ran (bun scripts/diff-guard.mjs --base <ref>) after each implement step;
   on BREACH: re-triage or record exception, never shrink the diff
-✓ Unit doc's Evidence rows updated (command → exit/digest → output → verified-by)
-  and Progress log updated (dated entry) before every commit
+✓ The unit's evidence carrier updated (Evidence rows, or `## Log` `E` lines for a
+  re-cut unit — command → exit/digest → output → verified-by) and its progress
+  recorded (dated Progress entry, or a `## Log` `P` line) before every commit
 ✓ Memory boundaries ran — probe verdict once, saves at unit start / each phase
   transition / close under `unit/<NN-slug>/doc`, degradation recorded as pending
 ✓ → Next: block printed as the absolute last output

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

@@ -6,7 +6,7 @@ A blank or vague scope or acceptance-criteria input is a gap, not a licence to
 infer. The order is fixed: search the repository's own docs first and append an
 `open-question` row to the unit folder's `decisions.md` recording where; research
 an external gap into 2–3 concrete options. A gap surviving both runs
-`node scripts/needs-input.mjs <unit-dir>`, pastes the `open-questions@1` block
+`bun scripts/needs-input.mjs <unit-dir>` (node fallback if bun is not installed), pastes the `open-questions@1` block
 and stops — route `design` for scope/architecture questions. "Decide for me" is
 a legitimate answer: the lane chooses and records the choice with its reason.
 Cheap-to-change defaults are recorded as assumptions, never silent.

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

@@ -7,12 +7,16 @@ output (≤2 lines), verified-by. A reviewer re-runs it.
 
 ## Inputs
 
-- The unit's Acceptance criteria
-- The Evidence section (where evidence rows are appended)
+- The unit's Acceptance criteria (`## Acceptance criteria`, or `## Specs` for a
+  re-cut unit — `scripts/unit-route.mjs` resolves the shape)
+- The unit's evidence carrier: the `## Evidence` section (legacy shape) or the
+  `## Log` section (re-cut shape, where each run is one `E` line)
 
 ## Fixed output contract
 
-Append to the unit doc's **Evidence** table. One row per AC:
+Append one row per AC to the unit doc's **Evidence** table (legacy shape). A
+re-cut unit (#308) has no Evidence section: append one `## Log` `E` line per AC in
+the same order, carrying the same five facts.
 
 | AC | What was run | Exit / digest | Output (≤2 lines) | Verified-by |
 |---|---|---|---|---|

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

@@ -166,7 +166,17 @@ name those files instead.
 - [ ] Each task names its validator (a backticked command plus its expected outcome)
 - [ ] Final task is verification (proves the whole unit works)
 - [ ] No task reaches into a future-phase concern (docs, release, migrations)
-- [ ] Phases labeled P1, P2, … (never S1, Step 1)
+- [ ] Phases labeled P1, P2, … — `#308`: `S#` is the requirement id (a spec),
+      `P#` is the phase label (a task); the two vocabularies never swap roles
+- [ ] Each requirement is cut from the request verbatim: numbered `S#` in
+      `## Specs`, one per distinct ask, with the requester's own words as its
+      quote and no requirement the request did not make
+- [ ] A later correction is appended under its own id (`S1a`) and leaves the
+      requirement it corrects untouched
+- [ ] Every task bullet names the `S#` it delivers on its `(Implements: …)` line
+- [ ] The `## Log` is opened with `L1` = the request verbatim, and later entries
+      append (never rewrite) in the `log-kind@1` vocabulary
+- [ ] `## Findings` is present and carries only OPEN rows (empty at plan time)
 - [ ] Both planning ledgers are cut (planning evidence + obligations), in the
       sizing rule's home, with stable ids
 

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

@@ -7,9 +7,9 @@ them, not the user. A blank or missing objective/scope is therefore a **document
 defect**: stop and repair the SPEC (`/unit-lane <unit>` — its §1 writes the
 objective/why/user-outcome) or re-triage. Never infer unit scope, and never
 turn a doc defect into a question the user cannot answer. A gap that survives
-the repair runs `node scripts/needs-input.mjs <unit-dir>`, pastes the
-`open-questions@1` block and stops, routed to `design` or `unit-lane` by the
-owning stage.
+the repair runs `bun scripts/needs-input.mjs <unit-dir>` (node fallback if bun is
+not installed), pastes the `open-questions@1` block and stops, routed to `design`
+or `unit-lane` by the owning stage.
 
 ## Purpose
 

package/skills/verification-contract/SKILL.md

@@ -1,15 +1,16 @@
 ---
 name: verification-contract
 user-invocable: false
-version: 1.4.3
+version: 1.5.0
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT
 description: >
   Internal contract: the acceptance artifact per delivery unit — legacy (pre-
   feature 61) units may carry a frozen `ACCEPTANCE.md` (binding if present);
   post-feature 61 units use the unit doc's `## Acceptance criteria` section as
-  the canonical acceptance source; the unit doc's `## Evidence` table serves as
-  the execution receipt. Consumed by planners, execute-phase, and review-change.
+  the canonical acceptance source; the unit doc's evidence carrier — `## Evidence`
+  table, or `## Log` `E` lines for a re-cut unit (#308) — serves as the execution
+  receipt. Consumed by planners, execute-phase, and review-change.
 ---
 
 # Verification Contract (internal)
@@ -63,9 +64,10 @@ v1` is needed: property/fuzz rides the existing `commands` class.
 
 ## Freeze and receipt
 
-The unit doc's `## Evidence` table is the execution receipt: each Evidence row
-records a validator command, its exit code or blob digest, output excerpt, and
-who verified it. A frozen criterion's receipt is the Evidence row for that
+The unit doc's own evidence carrier is the execution receipt: the `## Evidence`
+table for a legacy-shape unit, the `## Log` `E` lines for a re-cut one (#308). Each
+row or line records a validator command, its exit code or blob digest, output
+excerpt, and who verified it. A frozen criterion's receipt is the Evidence row for that
 criterion — exact match continues; missing/mismatched evidence stops before
 edits:
 
@@ -122,4 +124,4 @@ semantics are verified against authoritative documentation **before a test encod
 
 ## Done when
 
-Execution receipt (unit doc `## Evidence` table for post-feature 61 units; legacy `ACCEPTANCE.md` manifest binding-if-present) + named validators + literal quality floor; executor and reviewer evaluate identical evidence.
+Execution receipt (unit doc `## Log` `E` lines for a re-cut unit, `## Evidence` table for a post-feature 61 one; legacy `ACCEPTANCE.md` manifest binding-if-present) + named validators + literal quality floor; executor and reviewer evaluate identical evidence.

package/skills/workflow-status/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: workflow-status
 user-invocable: true
-version: 3.9.2
+version: 3.9.4
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT
 argument-hint: "[--json-only] [--last-envelope <json|path>] [--compact]"
@@ -69,7 +69,9 @@ bytes on a mature repo); the exact keep/drop set is in
 Per the agent guide's **Workflow conventions** + **documentation map**. The
 script reads what THIS skill needs (`docs/features/ROADMAP.md`, the fix index
 `docs/fix/README.md`, every in-flight feature folder's `TASKS.md` +
-`progress.md` + `review-findings.md`, and `docs/workflow/REPOSITORY_STATE.md`);
+`progress.md` and its findings carrier — `SPEC.md` `## Findings` + `## Log` for a
+migrated unit (issue #308), `review-findings.md` for a legacy one — and
+`docs/workflow/REPOSITORY_STATE.md`);
 read them yourself only to interpret a field the script emitted.
 
 ## Progressive loading — fixed sensor route

package/skills/workflow-status/references/ENVELOPE_FIELDS.md

@@ -104,7 +104,9 @@ Exactly two fields change:
   `in-progress` stays in both modes, so `detail.startable_now` and
   `detail.blocked_units` keep naming every unit either way.
 - `findings.fix_now[].route`: the reviewer's multi-paragraph evidence memo becomes
-  `...(N char evidence, see the unit review-findings.md)`, keeping the original
+  `...(N char evidence, see the unit review-findings.md)` for a legacy carrier and
+  `...(N char evidence, see the unit SPEC.md ## Findings)` for a migrated one (#308),
+  keeping the original
   length visible. `id`, `file`, `axis`, `severity`, `class` and `suggested_tier`
   are untouched, and the memo is on disk in the unit's `review-findings.md`, which
   is where the fold reads it.