mandrel 2.10.0 → 2.12.0

package/.agents/workflows/deliver.md

@@ -10,7 +10,9 @@ description:
 > **Lean spine.** Happy path + gate list. Sequencing edge cases, dispatch
 > mechanics, lite-route inline execution, checklist threading, ceremony, and
 > the per-run epilogue live in the on-demand
-> [`helpers/deliver-reference.md`](helpers/deliver-reference.md).
+> [`helpers/deliver-reference.md`](helpers/deliver-reference.md). What every
+> delivery always needs is bundled into one read:
+> [`helpers/deliver-digest.md`](helpers/deliver-digest.md) (Story #4736).
 
 ## Role
 
@@ -20,18 +22,22 @@ owns input resolution and sequencing only — every Story runs through
 `epic/<id>` integration branch, no `--no-ff` wave merges.
 
 The dependency graph is **discovered, not declared**: `resolve-stories.js`
-reads it from live state (body edges ∪ native GitHub `blocked_by` edges, every
-blocker resolved against its real issue state). You never hand it a graph, and
+reads it from live state (body edges ∪ native GitHub `blocked_by` edges, each
+blocker resolved against its real issue state). You never hand it a graph and
 there is no batch label — which is what lets you deliver Stories **across plan
-runs and over time**. The `plan-run::<id>` grouping label is filter metadata
-only — never a resolution input (there is no `--run` or `--dep` axis).
+runs and over time**. `plan-run::<id>` is filter metadata, never a resolution
+input.
+Per-Story routes are **body-derived** too (#4722); `route::lite` is a hint
+only. Ahead of that: a **single-Story run runs the engine inline** whatever the
+shape (#4736) — sub-agent isolation only earns its cost against a concurrent
+sibling.
 
 ## Inputs
 
 | Invocation | Behavior |
 | --- | --- |
-| `/deliver <storyId>` | Deliver one Story via `helpers/deliver-story.md`. |
-| `/deliver <storyId> <storyId> ...` | Resolve the set with `resolve-stories.js`, then sequence by the discovered graph via `stories-wave-tick.js`. Default concurrency is **3**. |
+| `/deliver <storyId>` | Deliver one Story via `helpers/deliver-story.md`, executed **inline in this session** — no `story-worker` spawn. |
+| `/deliver <storyId> <storyId> ...` | Resolve the set with `resolve-stories.js`, then sequence by the discovered graph via `stories-wave-tick.js`, dispatching role-scoped sub-agents. Default concurrency is **3**. |
 
 Any named ticket that is not `type::story`, or still carrying an `Epic: #N`
 footer, is a **hard error** naming the id and the fix (close or re-plan as a v2
@@ -41,18 +47,16 @@ Story). Resolution refuses the whole set rather than silently under-delivering.
 
 | Flag | Meaning |
 | --- | --- |
-| `--concurrency <n>` | **Optional** per-run override of the fan-out cap. Omit it to honor `delivery.deliverRunner.concurrencyCap` (config default **3**, including any `.agentrc.local.json` override); pass it **only** for a one-run cap. `1` = sequential. |
+| `--concurrency <n>` | **Optional** per-run override of the fan-out cap. Omit it to honor `delivery.deliverRunner.concurrencyCap` (config default **3**, incl. any `.agentrc.local.json` override); pass **only** for a one-run cap. `1` = sequential. |
 | `--yes` | Suppress the multi-Story confirmation gate. |
 | `--steal` | Forwarded to `single-story-init.js` / lease steal. |
 | `--wait-merge` | Force close-and-land (the default; `delivery.routing.closeAndLand`). |
 | `--no-wait-merge` | Opt out; stop at `agent::closing` for a human land. |
 
 **Operator-merge implies no-wait.** `--no-auto-merge` and
-`delivery.ci.autoMerge: "strict"` leave the PR un-armed: the Story rests at
-`agent::closing` for the human merge and is **not** flipped to `agent::blocked`
-(`--wait-merge` does not override this). A genuine *arm failure* differs — it
-still waits and still blocks, because that is a fault to report, not an operator
-decision to respect.
+`delivery.ci.autoMerge: "strict"` rest the Story at `agent::closing`, not
+`agent::blocked` — a genuine *arm failure* still waits and still blocks
+([`helpers/deliver-reference.md` § Operator-merge](helpers/deliver-reference.md)).
 
 ## Procedure
 
@@ -62,8 +66,8 @@ decision to respect.
    present the order in step 2. You do **not** thread them into step 3 — the
    tick re-resolves the graph itself every beat. Resolution hard-errors
    (exit 1) on a named id that is not a Story, carries an `Epic: #N` footer, or
-   whose native edges cannot be read — a missing gate would co-dispatch a Story
-   against an unlanded blocker.
+   whose native edges cannot be read — a missing gate would co-dispatch against
+   an unlanded blocker.
 
 2. **Confirm (N>1).** Present the order; wait unless `--yes`.
 
@@ -76,10 +80,8 @@ decision to respect.
    ```
 
    **Do not add `--concurrency` unless the operator explicitly asked for a
-   per-run cap.** Omitting it lets the tick resolve the cap from
-   `delivery.deliverRunner.concurrencyCap` — including a `.agentrc.local.json`
-   override. An explicit `--concurrency <n>` wins over config for that run, so a
-   filled-in literal (e.g. `3`) silently defeats the operator's override.
+   per-run cap** — an explicit value wins over config, so a filled-in literal
+   silently defeats a `.agentrc.local.json` override (see Flags).
 
    Each beat re-probes live state to derive done / in-flight itself; you never
    compute them (Story #4594). `--dispatched` is the one thing you must supply —
@@ -127,10 +129,10 @@ review depth reading the same level) and the mechanism table:
 
 ## Reading a Story's outcome
 
-Each Story's delivery ends in exactly one schema-validated terminal envelope
-([`story-deliver-terminal.schema.json`](../schemas/story-deliver-terminal.schema.json),
-Story #4543) — `landed` | `pending` | `blocked` | `failed`, the SSOT for the
-shape; this workflow does not restate its fields.
+Each Story's delivery ends in exactly one schema-validated terminal envelope —
+`landed` | `pending` | `blocked` | `failed`. Statuses, exits, and fields:
+[`helpers/deliver-digest.md`](helpers/deliver-digest.md) § 5, over the shipped
+[schema](../schemas/story-deliver-terminal.schema.json) (Story #4543).
 
 `pending` is **not** a failure: the bounded merge wait expired with the PR
 healthy (or a human owns the merge), nothing was mutated, and the
@@ -144,11 +146,9 @@ For a Story in an unclear state — including the merged-but-label-stale one a
 
 ## Constraints
 
-- **Land or block — never a silent local build.** Worktrees, `story-<id>`
-  branches, close-validation, and PR-to-`main` are the only sanctioned delivery
-  mechanism. Attended delivers default to close-and-land
-  (`delivery.routing.closeAndLand: true`); use `--no-wait-merge` only when a
-  human lands the PR.
+- **Land or block — never a silent local build** (digest § 2). Attended
+  delivers default to close-and-land (`delivery.routing.closeAndLand: true`);
+  use `--no-wait-merge` only when a human lands the PR.
 - `/deliver` never plans — tickets come from [`/plan`](plan.md). The router
   performs no git/label mutations; `deliver-story` owns every script.
 

package/.agents/workflows/helpers/acceptance-self-eval.md

@@ -30,10 +30,19 @@ mid-delivery, and evaluates the actual work product.
 
 ## Per round
 
-1. **Eval pass (fresh context, independent of the author).** Run a **separate
-   critic pass** — a fresh-context sub-agent (`Agent` tool), *not* a
-   continuation of your implementing turn — so the evaluator does not grade its
-   own homework.
+1. **Eval pass — one verdict-owner per cluster (Story #4723).** Exactly
+   **one** pass authors each cluster's verdict: the **fresh-context critic**
+   when the ceremony routing below resolves `fresh` (a sub-agent via the
+   `Agent` tool, *not* a continuation of your implementing turn — the
+   evaluator does not grade its own homework), or the **inline self-eval**
+   when it resolves `inline`. The resolved decision names the owner
+   explicitly (`verdictOwner: 'fresh-critic' | 'inline-self-eval'` from
+   `resolveCeremonyForRisk`). **Never run both**, and never run a
+   preliminary self-assessment pass before dispatching the fresh critic —
+   the redundant pre-pass buys no measurable quality and roughly triples
+   the acceptance-block cost. Step 2's gate is the deterministic **scorer**
+   of the one authored verdict, not a second (or third) pass over the
+   criteria.
 
    > **Sub-agent type + derived-level ceremony (Epic #4478, M7-B).** When
    > `delivery.routing.roleScopedAgents` is enabled (the **default**), dispatch
@@ -129,7 +138,9 @@ mid-delivery, and evaluates the actual work product.
      one `{ index, criterion, verdict: met|partial|unmet, evidence,
      verifyEvidence[] }` record per acceptance item.
 2. **Decide.** Run the gate against the verdict (the caller's Step 1a names the
-   exact invocation — omit `--epic`):
+   exact invocation — omit `--epic`). The gate **scores the single verdict
+   the round's owner authored** — schema validation, round cap, decision —
+   and never re-scores the criteria itself (Story #4723):
 
    ```bash
    node <main-repo>/.agents/scripts/acceptance-eval.js \

package/.agents/workflows/helpers/deliver-digest.md

@@ -0,0 +1,126 @@
+---
+description: >-
+  The deliver path's one bundled framework read (Story #4736). Carries what
+  every Story delivery always needs — dispatch decision, engine invariants,
+  the change-set/ceremony incantation, the acceptance-eval gate, and the
+  terminal envelope contract — so the engine reads one file instead of
+  re-reading the helper/schema set each session.
+---
+
+# Deliver digest (read once per session)
+
+> **Bundle, not a procedure.** [`deliver-story.md`](deliver-story.md) is still
+> the steps. This file is the material those steps referenced across five
+> separate files and a JSON schema — bundled so one read covers the whole happy
+> path. Situational material (lease preflight, recovery routers, merge-wait
+> budgets, CI remediation) stays on demand in
+> [`deliver-story-reference.md`](deliver-story-reference.md) and
+> [`deliver-reference.md`](deliver-reference.md); read those **only** when an
+> envelope or a failure routes you there.
+
+## 1. Dispatch — where the engine runs
+
+Read `stories[].dispatchMode` from the `resolve-stories.js` envelope. Two
+rules produce it, in order:
+
+1. **Run topology (#4736).** A run resolving **one** Story is `inline`
+   whatever its shape — sub-agent isolation is load-bearing only against a
+   *concurrent* sibling racing the same checkout, and a one-Story run has none.
+2. **Body shape (#4722).** In a multi-Story run, a lite-shaped body is
+   `inline`; a full-shaped body, an unparseable one, or a footprint touching a
+   sensitive-path class is `subagent`. The `route::lite` label is a
+   human-visible hint, never the control signal.
+
+`inline` removes model-side fan-out only — no `story-worker` boot, no fresh
+acceptance-critic spawn. **`subagent` and `inline` run the same engine**: same
+gates, same PR to `main`, same terminal envelope, byte for byte.
+
+## 2. Engine invariants
+
+| Trait | Contract |
+| --- | --- |
+| Ticket type | `type::story` only; an `Epic: #N` footer means **stop and re-plan** |
+| Branch | `story-<id>`, seeded from `project.baseBranch` (`main`) |
+| Merge target | `main` via PR (squash + required checks) — never a direct push |
+| Integration branch | **None** — no `epic/<id>`, no `--no-ff` wave merge |
+| Gates | Every close gate runs regardless of route; no route bypasses one |
+| State | Only via `update-ticket-state.js --ticket <id> --state <state>` |
+| Paths | Prefix every path-based tool with the absolute `workCwd` — `cd` does not scope them |
+
+**Land or block.** Worktree → `story-<id>` → close-validation → PR to `main` is
+the only sanctioned landing. A silent local build is not a delivery.
+
+## 3. Change set — computed once, handed to everyone
+
+One enumeration per Story (#4593). A critic that re-runs its own `git diff`
+can score a different set than the one that routed it:
+
+```bash
+node --input-type=module -e '
+  import { computeChangeSet } from "<main-repo>/.agents/scripts/lib/orchestration/change-set.js";
+  const { files } = computeChangeSet({ baseRef: "main", headRef: "story-<storyId>" });
+  console.log(JSON.stringify(files));
+'
+```
+
+Derive the level with `deriveChangeLevel`
+([`review-depth.js`](../../scripts/lib/orchestration/review-depth.js)) over
+that one list: a sensitive path registered in `audit-rules.json` → `high`, none
+→ `low`, an unenumerable diff (`files === null`) → `null`. Resolve
+fresh-vs-inline critics with `resolveCeremonyForRisk`
+([`ceremony-routing.js`](../../scripts/lib/orchestration/ceremony-routing.js)):
+`minimal` → always inline, `strict` → always fresh, `standard` → `high`/`null`
+→ fresh and `low` → inline unless the `freshCriticSampleRate` floor forces
+fresh. An `inline` dispatch mode overrides all of it to inline critics. Close's
+`review-depth.js` reads the same derived level, so the two cannot disagree.
+
+## 4. Acceptance self-eval (Step 1a, required)
+
+**One verdict-owner per cluster** (#4723) — the fresh critic *or* the inline
+self-eval, named by `verdictOwner`, never both and never a warm-up pass. It
+scores each `acceptance[]` item against the change set above, with `verify[]`
+output as evidence. Bounded by `delivery.acceptanceEval.maxRounds` (default 2).
+Then score the authored verdict:
+
+```bash
+node <main-repo>/.agents/scripts/acceptance-eval.js \
+  --story <storyId> --verdict <verdict-path>
+```
+
+`proceed` → close. `redraft` → one more round inside the cap. `block` → **do
+not close**: post a `friction` comment and flip `agent::blocked`.
+Per-round mechanics: [`acceptance-self-eval.md`](acceptance-self-eval.md).
+
+## 5. Terminal envelope — the return contract
+
+`single-story-close.js` emits exactly one envelope on stdout between
+`--- STORY DELIVER TERMINAL ---` markers, schema-validated against
+[`story-deliver-terminal.schema.json`](../../schemas/story-deliver-terminal.schema.json)
+(#4543 — the SSOT; read the JSON only when you need a field this table omits).
+Relay it verbatim; never hand-compose one, never substitute prose.
+
+| `status` | Exit | Meaning | You do |
+| --- | --- | --- | --- |
+| `landed` | 0 | PR merged, `agent::done`, tail ran (`tail.*: false` degrades the report, not the land) | Relay it. Done. |
+| `pending` | 3 | **Resumable, not a failure** — the bounded wait expired healthy, or a human owns the merge. Nothing was mutated. | Run `nextCommand`. |
+| `blocked` | 1 | Hard block; `blocked.blockClass` names it | `checks-failed` → fix + resume; else relay |
+| `failed` | 1 | A phase crashed; `phase` names which | Diagnose, fix, re-run close |
+
+Required fields: `kind` (`story-deliver-terminal`), `storyId`, `status`,
+`phase`, `elapsedSeconds`, `nextCommand`. `phase` is one of `init`,
+`wrong-tree-guard`, `close-validation`, `base-sync`, `push`, `pull-request`,
+`code-review`, `auto-merge`, `confirm-merge`, `post-land`, `done`. `gates`
+reports every gate as `passed` / `failed` / `skipped` — a skipped gate is
+reported, never omitted, so a missing gate is never read as a passing one.
+
+**Gate output is captured, not streamed (#4736).** Close writes gate lines to
+`temp/orchestration/close-gates-<storyId>.log` and reports a one-line digest on
+success; a failed gate replays its tail inline. `AGENT_LOG_LEVEL=verbose`
+restores live streaming.
+
+## 6. When to leave this file
+
+- Unclear state / a re-run refusal → `deliver-recover.js --story <id>` (read-only).
+- Lease, sweep, worktree-scope detail → [`deliver-story-reference.md`](deliver-story-reference.md).
+- CI red after the PR opens → [`rules/ci-remediation.md`](../../rules/ci-remediation.md).
+- Sequencing, epilogue, checklist threading → [`deliver-reference.md`](deliver-reference.md).

package/.agents/workflows/helpers/deliver-reference.md

@@ -51,19 +51,33 @@ probe logs a warning and leans on init's lease refusal alone.
 
 ## Dispatch mechanics (role-scoped by default)
 
-**Lite-routed Stories execute inline (Story #4707).** Before spawning anything,
+**A single-Story run executes inline (Story #4736).** Sub-agent isolation is
+load-bearing only for **concurrent** dispatch — two workers sharing a checkout
+would race on worktrees and branch refs — so a run resolving exactly one Story
+has no sibling to isolate from and pays the spawn premium for nothing (a boot is
+a cache write at full rate; an inline continuation is a cache read at ~10%).
+`resolve-stories.js` already reports it: a one-id run comes back with
+`dispatchMode: "inline"` whatever the Story's shape. Role-scoped spawning is
+retained in full for multi-Story waves, and the rule changes **where** the
+engine runs, never what runs — gates, PR, and terminal envelope are identical.
+
+**Lite-shaped Stories execute inline (Story #4722).** Before spawning anything,
 read the Story's `dispatchMode` from the resolver envelope
 (`stories[].dispatchMode`, derived by `resolveStoryDispatchMode` in
-`lib/orchestration/complexity-gate.js` from the persisted `route::lite`
-marker): a Story with `dispatchMode: "inline"` executes
+`lib/orchestration/complexity-gate.js` **from the fetched Story body's own
+shape** — `changes[]` count, acceptance count, creates-vs-refactors mix, and
+sensitive-path classes; the `route::lite` label is a human-visible hint only,
+never the control signal, so a lost or never-written label cannot misroute
+delivery): a Story with `dispatchMode: "inline"` executes
 [`deliver-story.md`](deliver-story.md) **inline in this session** — no
 `story-worker` sub-agent boot and no fresh acceptance-critic sub-agents
 (sub-agent boots are the dominant deliver-phase token cost at trivial scope) —
 threading the same `docsDigestPath` / `checklistPath` / change-set discipline
 as a spawned worker. Inline removes model-side fan-out only: every
 `single-story-close.js` gate, the PR to `main`, and the terminal envelope are
-identical. A Story without the marker (or with unreadable labels) takes the
-standard sub-agent path.
+identical. Everything else — a full-shaped body, a missing/unparseable body,
+or a footprint intersecting a sensitive-path class (sensitivity wins and
+keeps the fresh acceptance critic) — takes the standard sub-agent path.
 
 **Dispatch each `ready` Story (role-scoped by default).** When
 `delivery.routing.roleScopedAgents` is enabled (the **default**) and the host
@@ -110,6 +124,17 @@ execute it directly, in this turn, threading the same `docsDigestPath` /
 content, execute directly without a re-read turn. The engine, gates, and
 terminal envelope are identical either way — only the isolation differs.
 
+## Operator-merge implies no-wait
+
+`--no-auto-merge` and `delivery.ci.autoMerge: "strict"` leave the PR
+deliberately un-armed: there is nothing for close to land, so the Story rests
+at `agent::closing` for the human merge and is **not** flipped to
+`agent::blocked` — `--wait-merge` does not override this, because the operator
+owning the merge is a decision to respect, not a fault to report. A genuine
+*arm failure* is the opposite case: nobody chose it, so close still waits and
+still blocks. That asymmetry is what keeps the must-land contract intact
+without misfiling deliberate human merges as blocks.
+
 ## Per-run epilogue (N>1)
 
 Once the sequence reports `epilogueDue: true` (every Story done), keyed on the

package/.agents/workflows/helpers/deliver-story-reference.md

@@ -125,8 +125,7 @@ The v2 engine's trait table:
 | Spec / slices | Folded `## Spec` + optional `## Slicing` checkpoints in-session |
 | Ceremony | Per-Story, routed off the derived change level via `ceremony-routing.js` |
 
-**Ceremony-lite Stories still land through this engine unchanged (Story #4683).** A Story that `/plan` routed onto the ceremony-lite path (its
-`complexityRoute.route === "lite"`) collapses only the *advisory* plan/deliver
+**Ceremony-lite Stories still land through this engine unchanged (Story #4683).** A lite-routed Story collapses only the *advisory* plan/deliver
 ceremony — the fresh-critic / Tech-Spec authoring a one-artifact scope does
 not earn. It does **not** get a cheaper landing: the close-validation gates
 (lint / test / format / coverage / CRAP / maintainability), the PR to `main`,
@@ -134,15 +133,22 @@ and the `rules/security-baseline.md` MUSTs all run exactly as for a
 full-ceremony Story. The lite route's `preserves` field is the machine-readable
 record of those non-negotiables; there is no lite-specific gate bypass.
 
-**The lite route persists to delivery as the `route::lite` label (Story #4707).** Persist stamps every Story of a lite-routed plan with that marker
-(and ledgers the route — including any audited planner-downgrade reason — on
-its `story-plan-state` checkpoint); a full-routed Story carries no marker.
-`/deliver` reads the label via `resolveStoryDispatchMode`
-(`lib/orchestration/complexity-gate.js`) and executes a lite Story
-**inline in the deliver session** — no `story-worker` sub-agent boot, and
-the Step 1a acceptance self-eval runs its critics **inline** (no
+**Deliver derives the route from the Story body's shape (Story #4722).**
+Persist stamps a lite cohort's Stories with the `route::lite` label as a
+*human-visible hint only* (and ledgers the authored verdict — recorded
+reason plus per-Story shape evidence — on the `story-plan-state`
+checkpoint); the label is never the control signal. `/deliver` computes the
+route from the fetched Story body via `resolveStoryDispatchMode`
+(`lib/orchestration/complexity-gate.js`) — the same shape taxonomy
+`deriveChangeLevel` applies to the landed diff at close: `changes[]` count,
+acceptance count, creates-vs-refactors mix, sensitive-path classes. A
+lite-shaped Story executes **inline in the deliver session** — even when the
+label is absent or its write failed — with no `story-worker` sub-agent boot,
+and the Step 1a acceptance self-eval runs its critics **inline** (no
 fresh-context acceptance-critic sub-agent dispatch; sub-agent boots are the
-dominant deliver-phase token cost at trivial scope). Inline execution
+dominant deliver-phase token cost at trivial scope). A footprint
+intersecting a sensitive-path class derives `full` — sensitivity wins, and
+the Story keeps its fresh acceptance critic. Inline execution
 changes the isolation only: the engine, every script gate, and the
 terminal envelope are byte-identical either way.
 
@@ -175,6 +181,20 @@ directly.
 
 ### Step 1a — self-eval mechanics
 
+**One verdict-owner per cluster (Story #4723).** The ceremony routing's
+resolved decision names each cluster's single verdict owner
+(`verdictOwner: 'fresh-critic' | 'inline-self-eval'` from
+`resolveCeremonyForRisk`): the fresh maker-blind critic when sensitivity
+routes the cluster `fresh`, the contract-identical inline self-eval when it
+routes `inline`. Exactly one pass authors the verdict — never both, and
+never a preliminary self-assessment pass before dispatching the fresh
+critic (the redundant pre-pass buys no measurable quality and roughly
+triples the acceptance-block cost). `acceptance-eval.js` is the
+deterministic **scorer** of that one authored verdict — schema validation,
+round cap, proceed / redraft / block — not an independent additional pass
+over the criteria. The M4-B floor holds: one verdict per cluster, the
+cluster count owned by `acceptance-clusters.js` alone.
+
 **Critic evidence-share (Story #4250).** When the critic runs a `verify[]`
 command that is byte-identical to a close gate (`lint` / `typecheck`), it
 records the pass into the Story evidence keyspace via `--standalone` so
@@ -227,8 +247,8 @@ Resolve fresh-vs-inline acceptance critics per AC-cluster with
 floor forces `fresh`). Review depth reads the same derived level via
 `review-depth.js` inside close, so the two decisions cannot disagree.
 
-**Lite-route override (Story #4707).** When the Story carries the
-`route::lite` marker (`resolveStoryDispatchMode` → `inline`), run every
+**Lite-route override (Story #4722).** When the Story's body derives the
+lite shape (`resolveStoryDispatchMode` → `inline`), run every
 acceptance critic **inline** — do not spawn fresh-context critic sub-agents
 regardless of what the profile would otherwise resolve. The self-eval rigor
 (scoring each `acceptance[]` item against the one computed change set, with
@@ -321,6 +341,12 @@ The `single-story-close.js` script, in order:
 
 1. Runs the close-validation gates against `baseBranch` as the baseline.
    On any gate failure it throws — the operator fixes and re-runs close.
+   **Gate output is captured, not streamed (Story #4736).** Every gate line
+   goes to `temp/orchestration/close-gates-<storyId>.log`; a clean run reports
+   one digest line naming that artifact, and a **failed** gate replays its
+   captured tail inline so the evidence is in front of you without opening a
+   file. Read the artifact when you need the full text — or re-run under
+   `AGENT_LOG_LEVEL=verbose` for live streaming.
 1a. **Syncs the Story branch from `origin/<baseBranch>`** before push
    (Story #2580). Runs `git fetch origin <baseBranch>` followed by
    `git merge --no-edit origin/<baseBranch>` inside the worktree. This

package/.agents/workflows/helpers/deliver-story.md

@@ -11,11 +11,19 @@ description:
 > reference detail lives in
 > [`deliver-story-reference.md`](deliver-story-reference.md) ("reference"
 > below); consult on demand. Invoked by [`/deliver`](../deliver.md).
+>
+> **Read [`deliver-digest.md`](deliver-digest.md) once, first.** It is the
+> one bundled read of what every delivery needs — dispatch decision, engine
+> invariants, the change-set/ceremony incantation, the acceptance-eval gate,
+> and the terminal-envelope contract — replacing the per-session re-reads of
+> the helper set and `story-deliver-terminal.schema.json` (Story #4736). The
+> steps below cite it as "digest § N" rather than restating it.
 
 ## Overview
 
-The **one** delivery engine in v2 — every Story (`route::lite` runs
-inline with inline critics; engine, gates, envelope byte-identical):
+The **one** delivery engine in v2 — every Story (a lite-**shaped** Story
+runs inline with inline critics, #4722; engine, gates, envelope
+byte-identical):
 
 ```text
 single-story-init.js → implement + commits → derived-level ceremony
@@ -73,15 +81,10 @@ One branch, one PR to `main`, commits against the inline `acceptance[]` /
 
 ### Step 1a — Bounded acceptance self-eval loop (**required**)
 
-Follow the single-homed include
-[`acceptance-self-eval.md`](acceptance-self-eval.md) (fresh-context critic,
-`verify[]`-as-evidence, proceed / redraft / block). Gate invocation (omit
-`--epic`):
-
-```bash
-node <main-repo>/.agents/scripts/acceptance-eval.js \
-  --story <storyId> --verdict <verdict-path>
-```
+Run the loop and score it with `acceptance-eval.js` — **digest § 4** carries
+the invocation and the proceed / redraft / block contract; per-round critic
+mechanics live in the single-homed include
+[`acceptance-self-eval.md`](acceptance-self-eval.md).
 
 **`proceed`** → Step 2 then Step 3. **`block`** → **do not close**: post a
 `friction` comment and flip `agent::blocked` — commands and the
@@ -91,16 +94,12 @@ node <main-repo>/.agents/scripts/acceptance-eval.js \
 ## Step 2 — Ceremony (profile + derived level)
 
 Ceremony is `delivery.routing.ceremonyProfile` × the **derived change
-level** — never a planner-authored verdict (Story #4542).
-**Compute the change set once** (Story #4593) with the shared enumerator
-[`computeChangeSet`](../../scripts/lib/orchestration/change-set.js) — the
-same module close uses — and hand that one list to every critic. Derive the
-level with `deriveChangeLevel`, resolve fresh-vs-inline critics with
-`resolveCeremonyForRisk` (`ceremony-routing.js`); a lite Story runs inline
-regardless (exact incantation and routing rules: reference § Step 2).
-Hard gates (lint / test / format / coverage / CRAP / maintainability)
-always run in Step 3 — the derived level never disables them; do **not**
-pre-run the full close chain here.
+level** — never a planner-authored verdict (Story #4542). **Digest § 3** is
+the incantation: compute the change set once (Story #4593), derive the level,
+resolve fresh-vs-inline critics with `ceremony-routing.js`; a lite Story runs
+inline regardless (routing edge cases: reference § Step 2). Hard gates always
+run in Step 3 — the derived level never disables them; do **not** pre-run the
+close chain here.
 
 ## Step 3 — Close and land (`single-story-close.js`)
 
@@ -109,15 +108,12 @@ node <main-repo>/.agents/scripts/single-story-close.js --story <storyId> --cwd <
 ```
 
 **The whole delivery tail** — gates, PR, merge wait, `agent::done` flip,
-post-land tail in one process. Run it and **branch on the terminal
-envelope's `status`** (Story #4543):
-
-| `status` | Exit | Meaning | You do |
-| --- | --- | --- | --- |
-| `landed` | 0 | PR merged, `agent::done`, tail ran (`tail.*: false` degrades the report, not the land). | Relay the envelope (Step 7). |
-| `pending` | 3 | **Resumable, not a failure** — wait expired healthy, or a human owns the merge. | Run `nextCommand` until resolved. |
-| `blocked` | 1 | Hard block; `blocked.blockClass` names it. | `checks-failed` → Step 4; else relay. |
-| `failed` | 1 | A phase crashed; `phase` names which. | Diagnose, fix, re-run close. |
+post-land tail in one process. Run it and **branch on the terminal envelope's
+`status`** per the table in **digest § 5** (`landed` → Step 7; `pending` → run
+`nextCommand`; `blocked`/`checks-failed` → Step 4; `failed` → diagnose and
+re-run). Gate output is captured to
+`temp/orchestration/close-gates-<storyId>.log` — a clean run prints a digest
+line, a red gate replays its tail inline (Story #4736).
 
 Internals (gate order, base-sync, auto-merge arming), the merge-wait
 budgets, the slow-CI **async** confirm mode (Story #4698 — launch the
@@ -142,13 +138,13 @@ recovery path **only** when the envelope routes you there:
 
 ## Step 7 — Return contract (**required as a sub-agent**) {#return-contract}
 
-The contract is the shipped schema
-[`story-deliver-terminal.schema.json`](../../schemas/story-deliver-terminal.schema.json)
-— the SSOT for every field (Story #4543). End your turn by relaying the
-validated envelope close emits between its `--- STORY DELIVER TERMINAL ---`
-markers — never free-form prose, never a hand-composed object. `pending` is
-the only sanctioned no-merge ending, returned only when your own budget is
-exhausted (Story #1553). Reference § Step 7.
+End your turn by relaying the validated envelope close emits between its
+`--- STORY DELIVER TERMINAL ---` markers — never free-form prose, never a
+hand-composed object. Statuses, exits, and required fields: **digest § 5**
+(whose SSOT is the shipped
+[schema](../../schemas/story-deliver-terminal.schema.json), Story #4543).
+`pending` is the only sanctioned no-merge ending, returned only when your own
+budget is exhausted (Story #1553). Reference § Step 7.
 
 ## Recovering a stranded Story {#recover}
 
@@ -174,6 +170,7 @@ reuses an open PR).
 
 ## See also
 
+- [`deliver-digest.md`](deliver-digest.md) — the one bundled framework read.
 - [`/deliver`](../deliver.md) — unified entry point.
 - [`deliver-story-reference.md`](deliver-story-reference.md) — all on-demand
   detail.