@gtrabanco/pi-agentic-workflow 0.13.3 → 0.14.0

package/skills/init-workspace/references/PORTABILITY.md

@@ -7,7 +7,7 @@ enables:
 - **No slash-command menu** — where this skill says `/<skill>`, open that
   skill's `SKILL.md` (wherever your agent installed the skills) and follow it
   literally, in a fresh conversation: hand-offs assume a clean context.
-- **No per-skill `model:`/`effort:`** — on the `#claude` branch the frontmatter pins these tiers; here, pick tiers yourself:
+- **No per-skill `model:`/`effort:`** — no skill pins a tier; pick tiers yourself:
   the interview and adaptation are judgment work — run them on your
   **strongest** model.
 - **No Claude Code hooks** — choose the Cursor, Copilot, or OpenCode adapter

package/skills/init-workspace/references/UPGRADE.md

@@ -33,13 +33,23 @@ lacks**. Eight ordered steps:
    dated migration note so the proposal explains *why* the block exists and
    *what* it migrates. If `MIGRATION.md` is absent, proceed on the template
    diff alone and say so in the report — never block on a missing note.
-4. **Propose only the missing blocks — one short, batched interview round.**
-   Each item is the block, a discovery-based default (the same detection
-   bootstrap mode already runs — e.g. `astro.config.*` + Starlight ⇒ `Docs
-   site` default, Biome ⇒ the complexity-lint slot, the remote URL ⇒ forge),
-   and the `MIGRATION.md` rationale when available. The user accepts, edits,
-   or skips each block. **Never re-ask what the project already answered** —
-   a block that's already filled is skipped, not re-interviewed.
+4. **Propose the adaptive lane conventions (feature 61 P11).** For pre-lane
+   installs (before the fixed pipeline was retired), propose these missing
+   blocks additively — **never clobber existing content**:
+   - The **unit document conventions** section in AGENTS.md (the 13-section
+     SPEC.md, triage-driven step selection, diff-size guard, evidence rows,
+     dated progress log, closed commit format `type(scope): description`).
+   - The **unit doc template** under `docs/features/_TEMPLATE/SPEC.md` if
+     absent — the same 13-section template used by new units.
+   - The **lane workflow doc** under `docs/workflow/` if absent: `FEATURE_WORKFLOW.md`
+     (unit doc → triage → catalog steps → evidence → review → release),
+     `ISSUE_WORKFLOW.md` (issues route through triage to the lane).
+   - A **documentation-map row** for `docs/features/_TEMPLATE/SPEC.md` and the
+     lane workflow docs if missing from the existing map.
+   Each item is accepted, edited, or skipped by the user. **Never re-ask what
+   the project already answered** — a block that's already filled is skipped,
+   not re-interviewed. The lane conventions are additive only: existing content
+   is never rewritten, only new blocks are inserted where missing.
 5. **Write additively.** Insert accepted blocks, including a missing
    `docs/workflow/REPOSITORY_STATE.md`; fill raw, still-placeholder
    blocks with the confirmed values. **Never rewrite a block the project has

package/skills/log-session/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: log-session
 user-invocable: true
-version: 2.2.0
+version: 2.2.1
 argument-hint: "[note to prepend to the entry]"
 author: "Gabriel Trabanco <1969593+gtrabanco@users.noreply.github.com>"
 license: MIT
@@ -9,8 +9,9 @@ description: >
   Append a structured entry to the project's session log (`docs/LOGS.md`):
   what was done this session, files touched, decisions taken, and the next
   step — so the next session (or another person) can pick up the thread
-  without re-reading git history. Run it before `/clear`, before closing
-  Claude Code, or at any natural stopping point. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using.
+  without re-reading git history. Run it before `/clear`, before closing your
+  agent session, or at any natural stopping point. Model-agnostic: the skill
+  inherits whatever model and effort your agent session is already using.
   Triggers: "log this
   session", "log-session", "write a session log", "journal what we did",
   "record this session before I clear", "save the session summary".

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

@@ -41,7 +41,7 @@ preserving the fixed block shape.
 turn-contract-receipt@1
 ok-line:    TURN-CONTRACT ok
 fail-line:  TURN-CONTRACT fail box<N>: <code>
-codes:      branch-default | not-a-repo | no-commits | acceptance-missing |
+codes:      branch-default | not-a-repo | no-commits | unit-doc-missing |
             phase-lint-failed | pr-not-open | pr-head-mismatch |
             pr-unreachable | dirty-tree | ahead-of-remote
 exit:       0 ok | 1 contract fail | 2 usage error

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

@@ -6,9 +6,9 @@ Plan snapshot binds them, and `execute-phase` may not invent a substitute.
 
 | Ledger | Home | Written by | Read by |
 |---|---|---|---|
-| Planning evidence | `planning-evidence.md` (M/L) · `### Planning evidence` inside the SPEC (XS/S) | the authoring planner | `review-plan`, then the phase slice for `execute-phase` |
-| Obligations | `planning-obligations.md` (M/L) · `### Obligations` inside the SPEC (XS/S) | the authoring planner, then the phase owner for `status` | `review-plan`, `execute-phase`, `fold-findings`, `audit-pr` |
-| Findings | `planning-findings.md` (one per unit, both stages) | reviewers append; only the stage's author resolves | the author skill, `review-plan` on re-review, `audit-pr` |
+| 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` |
 
 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
@@ -19,10 +19,9 @@ M/L freeze the separate files and bind them with their own rows. Never both.
 
 Row shape — the base row, the closed `authority-kind` / `freshness` vocabularies,
 the prefixed stable `id`, and the `affected-decision-or-obligation` Plan-stage
-extension with its full column order — is owned by the `evidence-grounding`
-reference `ROWS.md` (§ "Plan-stage table — one declared extension"): one
-definition, no second copy. This ledger owns only the lifecycle rules and uses
-markdown headings, nothing else. Ids are stable (`PE-001`, `PE-002`, …): an
+extension with its full column order — is owned by the unit-lane's planning
+reference: one definition, no second copy. This ledger owns only the lifecycle
+rules and uses markdown headings, nothing else. Ids are stable (`PE-001`, `PE-002`, …): an
 obligation or finding cites a row by id, so renumbering the table is a replan,
 not a formatting edit.
 
@@ -36,8 +35,8 @@ Rules specific to this ledger:
 - An assumption about a model's or service's behaviour that was never sampled is
   `unknown` with an owner — `ASSUMPTION-UNVERIFIED` is what the row *means*, and
   the row must stay visible in the artifact rather than becoming a citation.
-- `review-plan` reads the whole table; `execute-phase` reads only the rows whose
-  `affected-decision-or-obligation` names its frozen phase.
+- `execute-phase` reads only the rows whose `affected-decision-or-obligation`
+names its frozen phase; the unit-lane plans the table before `execute-phase` runs.
 
 ### 2. Obligations
 
@@ -101,9 +100,9 @@ status | resolution-evidence | resolving-artifact-revision
 - `status` is `open | resolved | dismissed`. `dismissed` requires
   counter-evidence that falsifies the finding ([POLICY.md](POLICY.md) §2); the
   evidence goes in `resolution-evidence`, not in chat.
-- The author resolves a row through its own route: `design-feature` for
-  `class: product`, `plan-feature` / `plan-fix` for `class: plan`, and the
-  candidate loop (`review-change` → `fold-findings`) only for
+- The author resolves a row through its own route: `unit-lane` for
+  `class: product` and `class: plan`, and the candidate loop
+  (`review-change` → `fold-findings`) only for
   `class: source | environment | runtime`.
 - `resolving-artifact-revision` is the `artifactRevisionId` of the write that
   closed the row — the link that lets a re-review prove the snapshot actually
@@ -125,41 +124,41 @@ its `· fold <sha>` (or `· ticked <sha>` on a row that scores 1) plus the
 annotation — never a `yes` of its own.
 
 `scripts/ledger-ownership.test.mjs` reads the block below as the single source of
-truth for the seven AC16 truth classes and the projections in
-`docs/features/_TEMPLATE/LEDGERS.md` and `docs/fix/_TEMPLATE/LEDGERS.md` as its
-copies. It fails closed on a missing or malformed block, an owner-less row, drift
-in either direction, a token the annotator cannot produce, and any non-test script
-under `scripts/` or `packages/<name>/scripts/` whose write or append target names a
-durable ledger its row does not name it for. Cells carry bare values: ` · ` joins
-ledgers, ` + ` joins owners, an owner is `<skill>:<column-set>` (the literal
-`human-owner` marks the person, the only authority for an amendment), and a `#`
-line is a directive. A script that writes only generated artifacts names no ledger
-and is out of scope; a copy or shell rewrite stays the reviewer's job. Validator
-commands follow the repository's runtime convention: **bun first** (`bun test …`),
-with the same command under `node --test …` when bun is absent — both runtimes
-must pass; the CI node-compat job enforces the fallback.
+truth for the seven AC16 truth classes and the projection in
+`docs/fix/_TEMPLATE/LEDGERS.md` as its copy (the features-template projection
+was retired at P8b). It fails closed on a missing or malformed block, an owner-less
+row, drift in either direction, a token the annotator cannot produce, and any
+non-test script under `scripts/` or `packages/<name>/scripts/` whose write or append
+target names a durable ledger its row does not name it for. Cells carry bare values:
+` · ` joins ledgers, ` + ` joins owners, an owner is `<skill>:<column-set>` (the
+literal `human-owner` marks the person, the only authority for an amendment), and a
+`#` line is a directive. A script that writes only generated artifacts names no
+ledger and is out of scope; a copy or shell rewrite stays the reviewer's job.
+Validator commands follow the repository's runtime convention: **bun first**
+(`bun test …`), with the same command under `node --test …` when bun is absent —
+both runtimes must pass; the CI node-compat job enforces the fallback.
 
 ```text
 ledger-ownership@1
 truth-class | ledger | owner | annotator | annotator-token | validator
 review-findings | docs/features/<NN>-<slug>/review-findings.md · docs/fix/<issue>-<topic>/review-findings.md | review-change:finding-rows + review-change:finding-mark + review-change:review-mark + review-change:review-gate-ran-marks + audit-pr:audit-rows + triage-issue:triage-rows + execute-phase:gate-ran-marks + fold-findings:folded-flag | scripts/ledger-provenance.mjs | · fold <sha> + · ticked <sha> + · REOPENED | bun test scripts/ledger-provenance.test.mjs
-planning-findings | docs/features/<NN>-<slug>/planning-findings.md · docs/fix/<issue>-<topic>/planning-findings.md | review-spec:spec-stage-rows + review-plan:plan-stage-rows + design-feature:product-class-resolutions + plan-feature:plan-class-resolutions + plan-fix:fix-plan-class-resolutions + fold-findings:source-class-resolutions | none | none | bun test scripts/pre-execution-quality.test.mjs
-progress | docs/features/<NN>-<slug>/progress.md · docs/fix/<issue>-<topic>/progress.md | plan-feature-scaffold:create + execute-phase:phase-entries + execute-phase:gate-rejection-traces + review-spec:product-receipt + review-plan:plan-receipt | none | none | bun test scripts/pre-execution-sensor.test.mjs
-known-issues | docs/features/<NN>-<slug>/known-issues.md · docs/fix/<issue>-<topic>/known-issues.md | plan-feature-scaffold:create + execute-phase:blocker-entries-and-status | none | none | bun test scripts/ledger-ownership.test.mjs
-decisions | docs/features/<NN>-<slug>/decisions.md · docs/fix/<issue>-<topic>/decisions.md | plan-feature-scaffold:create + design-feature:product-decisions + plan-feature:engineering-decisions + execute-phase:phase-decisions + human-owner:ratified-verdicts | none | none | bun test scripts/ledger-ownership.test.mjs
-roadmap | docs/features/ROADMAP.md · docs/fix/README.md | design-feature:idea-or-defined-row + plan-feature-scaffold:planned-row + plan-fix:fix-index-row + execute-phase:status-and-pr-link + ship-roadmap:founding-and-flip + audit-docs:low-risk-row-repair | none | none | bun test scripts/bounded-delivery-loops.test.mjs
-acceptance-manifest | docs/features/<NN>-<slug>/ACCEPTANCE.md · docs/fix/<issue>-<topic>/ACCEPTANCE.md | plan-feature-scaffold:feature-freeze + plan-fix:fix-freeze + human-owner:approved-amendment | none | none | git hash-object docs/features/<NN>-<slug>/ACCEPTANCE.md
+planning-findings | docs/features/<NN>-<slug>/planning-findings.md · docs/fix/<issue>-<topic>/planning-findings.md | unit-lane:planning-findings + fold-findings:source-class-resolutions | none | none | bun test scripts/pre-execution-quality.test.mjs
+progress | docs/features/<NN>-<slug>/SPEC.md · docs/fix/<issue>-<topic>/SPEC.md | unit-lane:progress-entries + execute-phase:phase-entries + execute-phase:gate-rejection-traces | none | none | bun test scripts/pre-execution-sensor.test.mjs
+known-issues | docs/features/<NN>-<slug>/known-issues.md · docs/fix/<issue>-<topic>/known-issues.md | unit-lane:known-entries + execute-phase:blocker-entries-and-status | none | none | bun test scripts/ledger-ownership.test.mjs
+decisions | docs/features/<NN>-<slug>/decisions.md · docs/fix/<issue>-<topic>/decisions.md | unit-lane:decisions + execute-phase:phase-decisions + human-owner:ratified-verdicts | none | none | bun test scripts/ledger-ownership.test.mjs
+roadmap | docs/features/ROADMAP.md · docs/fix/README.md | unit-lane:row-registration + execute-phase:status-and-pr-link + audit-docs:low-risk-row-repair | none | none | bun test scripts/bounded-delivery-loops.test.mjs
+acceptance-manifest | docs/features/<NN>-<slug>/ACCEPTANCE.md · docs/fix/<issue>-<topic>/ACCEPTANCE.md | unit-lane:acceptance-freeze + human-owner:approved-amendment | none | none | git hash-object docs/features/<NN>-<slug>/ACCEPTANCE.md
 # no-script-writer: SPEC.md · PLAN.md · TASKS.md · CHECKLIST.md · testing.md · architecture-notes.md · planning-evidence.md · planning-obligations.md · delegated-evidence.md
 ```
 
 `SPEC.md`, `PLAN.md`, `TASKS.md`, `testing.md` and `architecture-notes.md` are
 durable unit records, but not ledgers with a row lifecycle of their own: their
-writers are the phases that already order them (`plan-feature-scaffold` creates
-them, `execute-phase` ticks and appends), so the directive line keeps any script
-away from them instead of forking the table above. Same for the two frozen
-planning ledgers at the top of this file, and for `delegated-evidence.md`: a
-versioned artifact of a delegated reading pass, whose writer and zones are stated
-by `evidence-grounding`'s `references/DELEGATION.md`, not by this map.
+writers are the phases that already order them (`unit-lane` creates them, `execute-phase`
+ticks and appends), so the directive line keeps any script away from them instead
+of forking the table above. Same for the two frozen planning ledgers at the top
+of this file, and for `delegated-evidence.md`: a versioned artifact of a delegated
+reading pass, whose writer and zones are stated by the triage/research step's
+documentation, not by this map.
 
 ### The durable review mark
 
@@ -236,7 +235,8 @@ GATE-RAN | HEAD <40-hex sha> | <cmds> | exit <code> | [reserved trailing slot: `
   declares `execute-phase:gate-ran-marks` (executor phase gates) and
   `review-change:review-gate-ran-marks` (reviewer gate runs), distinct column-set
   names per the one-writer-per-column-set rule.
-- **Owner extension**: the identical owner cell is mirrored into both template
-  projections (`docs/features/_TEMPLATE/LEDGERS.md` and `docs/fix/_TEMPLATE/LEDGERS.md`).
+- **Owner extension**: the identical owner cell is mirrored into the fix-template
+  projection (`docs/fix/_TEMPLATE/LEDGERS.md`); the features-template projection
+  was retired at P8b because the unit doc carries its evidence sections.
 - **No new truth-class row**: the grammar admits no new row — the existing
   `review-findings.md` ledger pattern is reused with extended owner cells.

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

@@ -218,6 +218,7 @@ reports; a printed verdict whose mark is still "for next turn" is not finished.
   phase-lint | PREFLIGHT.md
   path-protection | PREFLIGHT.md
   stale-or-missing-receipt | PRE_EXECUTION_GATE.md
+  stale-unit-doc | PRE_EXECUTION_GATE.md
   ```
 
   `execute-phase` appends that trace to the unit's `progress.md`, under

package/skills/review-change/SKILL.md

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

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

@@ -13,7 +13,7 @@ enables:
   tiers as `--adversarial N` (subagents / headless / fresh conversations); an
   agent with none of them runs the documented inline fallback: sequential
   in-turn passes, each reduced to its findings table before the next starts.
-- **No per-skill `model:`/`effort:`** — on the `#claude` branch the frontmatter pins these tiers; here, pick tiers yourself:
+- **No per-skill `model:`/`effort:`** — no skill pins a tier; pick tiers yourself:
   this review needs your **strongest** model. Never review a change with a
   model weaker than the one that wrote it — and prefer a different model family
   than the writer's: same-family instances share training blind spots,

package/skills/unit-lane/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: unit-lane
+user-invocable: true
+version: 1.0.0
+argument-hint: <NN-slug | "<idea>"> [--retriage]
+description: >
+  One-shot lane conductor for a delivery unit: triage, implement, evidence, and
+  close in a single document. Triggers: "unit-lane", "run the lane",
+  "work on this feature/fix", "build this unit".
+---
+
+# Unit Lane — Adaptive Conductor
+
+One document, adaptive steps. The lane reads a closed catalog, triages which
+steps a unit needs, executes them in order, and commits at each gate. Replaces:
+design-feature, plan-feature, review-spec, review-plan.
+
+## Turn contract
+
+Tick every box before ending the turn; an unchecked box means the turn is not
+done:
+
+```
+✓ Triage ran (bun scripts/unit-route.mjs --triage <slug>) and its block pasted
+  verbatim into the unit doc's Evidence section as the authoritative step list
+✓ Unit doc exists at docs/features/<NN>-<slug>/SPEC.md (created from template
+  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
+✓ → Next: block printed as the absolute last output
+```
+
+## When to use
+
+- A known unit slug: `unit-lane <NN-slug>`
+- A raw idea (no slug yet): `unit-lane "<idea description>"`
+- Force re-triage: `unit-lane <NN-slug> --retriage`
+
+## Step 0 — Discover the project
+
+Per the agent guide's **Workflow conventions** + **documentation map**, then read
+`docs/features/_TEMPLATE/SPEC.md` (the unit doc template). If the unit folder
+exists, read its current `SPEC.md` to avoid overwriting.
+
+## Process
+
+### 1. Resolve or create the unit doc
+
+If the idea has no slug, assign the next number from `docs/features/ROADMAP.md`
+and create `docs/features/<NN>-<slug>/SPEC.md` from the template. Fill
+objective, why, user outcome, and non-goals from the invocation. Acceptance
+criteria are induced from user scenarios — **ask-don't-infer**; if the request
+is too vague, STOP and ask the user with concrete options. See
+[the unit doc template](references/STEPS.md) for section order.
+
+### 2. Triage — read the catalog, never re-derive
+
+Run `bun scripts/unit-route.mjs --triage <slug>` (or `<NN>` for numeric). PASTE
+its stdout block **verbatim** into the unit doc's Evidence section header under
+a `## Triaged steps` heading. This block is authoritative. The model never
+re-derives, reorders, or invents steps — it executes only what the catalog says.
+
+### 3. Execute triaged steps in order
+
+For each step the triage returned, follow its reference file. Execute **one step
+per turn-commit**:
+
+1. Read the step's reference — for example:
+   [research](references/RESEARCH.md), [design](references/DESIGN.md),
+   [plan](references/PLAN.md), [implement](references/IMPLEMENT.md),
+   [tests](references/TESTS.md), [evidence](references/EVIDENCE.md),
+   [review](references/REVIEW.md), [docs](references/DOCS.md),
+   [release](references/RELEASE.md) — only the ones the triage demands).
+2. Perform the step's checklist items.
+3. Write/update evidence in the unit doc.
+4. Update the Progress log with a dated entry.
+5. Commit with a conventional commit message.
+6. For implement steps, run the diff guard (step 4 below).
+
+### 4. Diff-size guard (after each implement step)
+
+Run `bun scripts/diff-guard.mjs --base <last-reviewed-ref> --unit <NN>`. Paste
+the output verbatim. On **BREACH**: stop, re-triage the unit, or record an
+exception. **Anti-gaming: NEVER shrink a diff by deleting comments, blank lines,
+docs or tests.** If the unit cannot fit the budget, record the exception and stop.
+
+### 5. Update evidence and progress
+
+Before every commit:
+
+- **Evidence rows**: One row per AC satisfied — `| AC | command | exit/digest |
+  output (≤2 lines) | verified-by |`
+- **Progress log**: `YYYY-MM-DD HH:MM — <what was done> → <commit sha> — next:
+  <what is next>`
+
+### 6. Close the unit
+
+When all triaged steps are done, run the review pack axis summary, update the
+unit doc's status, and print the closing block.
+
+## Guardrails
+
+**Allowed:**
+- Only the triaged steps listed by the catalog
+- Changes scoped to the acceptance criteria
+- Documentation updates in docs/ and template/
+- Conventional commit messages per the project's Workflow conventions
+
+**Forbidden:**
+- Never expand scope beyond what Non-goals define — findings discovered during
+  implementation never widen the unit
+- Never invent an acceptance criterion — ask the user with concrete options
+- Never skip a triaged step silently — every step the catalog demands must run
+- 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
+
+## Relationship to other skills
+
+`unit-lane` absorbs the 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.
+
+## Portability (agents other than Claude Code)
+
+- **No slash menu** — open this `SKILL.md` and follow it literally in a fresh
+  conversation. Where it says `run`, execute the shell command directly.
+- **No model tiers** — triage and review use the strongest model; execution
+  steps may use cheaper. Never review with a weaker model than the author.
+- **No `/loop`/subagents** — re-invoke manually and follow the closing `→ Next:`
+  block at each step boundary.
+
+## Done when
+
+- Every triaged step is executed and committed.
+- The unit doc's Evidence rows, Progress log, and References section are current.
+- The diff guard passed for all implement steps.
+- The review step is complete (or skipped per catalog).
+- **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)
+  · re-triage needed → /unit-lane <NN-slug> --retriage
+  · finished and merge-ready → /audit-pr (merge gate)
+```

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

@@ -0,0 +1,35 @@
+# Design step
+
+## Purpose
+
+Induce acceptance criteria from user scenarios and close entity, role, and
+expectation boundaries — distilled from the full design skill's closure.
+
+## Inputs
+
+- The unit's objective, why, and user outcome from the SPEC
+- Research findings from the research step
+
+## Fixed output contract
+
+Fill the unit doc's **Acceptance criteria** section. Each AC must be:
+- Induced from a concrete user scenario ("I do X and observe Y")
+- Command-verified where possible (not "feel correct")
+- Numbered (AC1, AC2, …)
+
+## Checklist (pass only if)
+
+- [ ] Every AC is induced from a user scenario, not inferred from vague intent
+- [ ] Acceptance criteria are command-verified where possible
+- [ ] Entity closure: every entity mentioned has its role in the unit stated
+- [ ] Role closure: every actor/role that interacts with the unit is listed
+- [ ] Expectation sweep: user's accepted and rejected inputs are bounded
+- [ ] Vague items → ask the user with concrete options, never invent
+
+## Forbidden
+
+- Do not build a separate DESIGN.md — one SPEC, all in the unit doc
+- Do not invent product scope the user did not confirm
+- Do not pre-fill engineering content (phases, tests, architecture)
+- Do not stamp "designed" with an incomplete closure row
+- An incomplete row silently un-does the skill's purpose

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

@@ -0,0 +1,36 @@
+# Docs step
+
+## Purpose
+
+Docs-only units (changelog, template, migration) and the docs step for code
+units. Updates documentation surfaces per project conventions.
+
+## Inputs
+
+- The unit's objective and tasks
+- The project's documentation conventions from the agent guide
+- Template/ directory layout
+
+## Fixed output contract
+
+Update the unit doc's **Progress log** and any project docs:
+
+- Changelog updated per project conventions
+- Template files updated if the unit changes a template
+- Documentation map updated if new artifacts were created
+- Each doc change committed with a conventional commit message
+
+## Checklist (pass only if)
+
+- [ ] All docs the unit demands are updated
+- [ ] Changelog/templates follow the project's declared conventions
+- [ ] Documentation map references resolve (no broken links)
+- [ ] Changes committed on the correct branch with no unpushed changes
+- [ ] Progress log entry records the commit sha and what was documented
+
+## Forbidden
+
+- Do not change code in the docs step — only doc surfaces
+- Do not add docs the unit's scope does not demand
+- Do not skip the docs step for a code unit when the catalog demands it
+- Do not change the unit doc's Evidence or Progress sections here

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

@@ -0,0 +1,34 @@
+# Evidence step
+
+## Purpose
+
+One row per acceptance criterion: what was run, exit status/digest, observed
+output (≤2 lines), verified-by. A reviewer re-runs it.
+
+## Inputs
+
+- The unit's Acceptance criteria
+- The Evidence section (where evidence rows are appended)
+
+## Fixed output contract
+
+Append to the unit doc's **Evidence** table. One row per AC:
+
+| AC | What was run | Exit / digest | Output (≤2 lines) | Verified-by |
+|---|---|---|---|---|
+| ACn | <command or sha> | <exit / sha> | <≤2 lines> | <model or reviewer> |
+
+## Checklist (pass only if)
+
+- [ ] Every AC has exactly one evidence row
+- [ ] Each row contains: command/run, exit status/digest, output ≤2 lines
+- [ ] Verified-by names the model that ran it or a human reviewer
+- [ ] No invented evidence — every row corresponds to an actual run
+- [ ] The evidence reproduces — a reviewer can run the same command
+
+## Forbidden
+
+- Invented evidence is the cardinal sin — never record a row without running it
+- Never alter acceptance criteria to match evidence
+- Never claim a command passed when it did not
+- Never omit the exit status or digest

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

@@ -0,0 +1,45 @@
+# Implement step
+
+## Purpose
+
+Execute the plan's tasks against the code. One phase per commit. Layer order
+respected. Guard enforced.
+
+## 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
+
+## Fixed output contract
+
+After each phase commit, update the unit doc's **Evidence** section and
+**Progress log**:
+
+| AC | What was run | Exit / digest | Output (≤2 lines) | Verified-by |
+|---|---|---|---|---|
+| P1 | <git commit sha> | 0 · <sha> | <result ≤2 lines> | <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
+
+## Allowed
+
+- Changes scoped to the phase's acceptance criteria only
+- Bug fixes in affected paths that the phase touches
+- Documentation updates in the same commit as the code change
+
+## Forbidden
+
+- No unrelated refactors in the same commit
+- No new abstractions or dependencies beyond what the unit doc demands
+- Never commit red (test failure)
+- Never shrink a diff by deleting comments, blank lines, docs, or tests
+- Do not expand scope beyond the unit's non-goals

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

@@ -0,0 +1,38 @@
+# Plan step
+
+## Purpose
+
+Cut tasks from acceptance criteria. Each task names its validator. Smallest
+first. No future-phase work.
+
+## Inputs
+
+- The unit's Acceptance criteria (filled by the design step)
+- The unit's non-goals
+
+## Fixed output contract
+
+Fill the unit doc's **Tasks** section:
+
+```
+P1 — <task description> (validator: <what proves it works>)
+P2 — <task description> (validator: <what proves it works>)
+…
+Pn — last task is verification when the unit has behavior
+```
+
+## Checklist (pass only if)
+
+- [ ] Every AC maps to at least one task
+- [ ] Tasks are ordered smallest first
+- [ ] Each task names its validator (command, output, or observation)
+- [ ] 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)
+
+## Forbidden
+
+- Do not bundle across phase boundaries — one phase = one commit
+- Do not plan work beyond the unit's acceptance criteria
+- Do not include docs/release tasks here — those are separate catalog steps
+- Do not invent tasks that the ACs do not demand

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

@@ -0,0 +1,45 @@
+# Release step
+
+## Purpose
+
+Close the unit: branch hygiene, PR creation, and forge reconciliation.
+
+## Inputs
+
+- The unit's completed SPEC.md (all sections current)
+- The unit's Evidence section
+- The project's Workflow conventions (branch/PR)
+
+## Fixed output contract
+
+Write into the unit doc's **References** section:
+
+```
+## References
+- Closes #<N>
+- PR: <url>
+- Branch: <branch-name>
+- Commit: <sha>
+```
+
+## Checklist (pass only if)
+
+- [ ] PR created on `main` with `Closes #N` from the References section
+- [ ] Branch follows the project's Workflow conventions
+- [ ] Commit messages follow conventional format (`type(scope): description`)
+- [ ] PR body includes the Evidence section as verification record
+- [ ] Roadmap row updated to `done` (or `merged` per conventions)
+- [ ] `git status --porcelain` is empty
+
+## Allowed
+
+- PR body references the unit's Evidence rows
+- PR closes absorbed issues via `Closes #N`
+- Roadmap annotation (folded → <NN>, superseded, re-scoped)
+
+## Forbidden
+
+- Never stack PRs — one PR per unit of work, always against `main`
+- Never work on `main` directly
+- Never close the unit without an opened PR
+- Never alter the unit doc's Evidence or Progress after this step