mandrel 2.59.0 → 2.60.0

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

@@ -112,7 +112,7 @@ not a substitute for prefixing paths correctly.
 
 ---
 
-## Engine invariants and the lite route
+## Engine invariants and ceremony
 
 **Prerequisites before Step 0.** A `type::story` issue, a clean
 `gh auth status`, and `project.baseBranch` present both locally and on
@@ -128,27 +128,26 @@ The v2 engine's trait table:
 | Branch        | `story-<id>` seeded from `project.baseBranch` (`main`)                   |
 | Merge target  | `main` via PR (squash + required checks)                                 |
 | 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.** A
-lite-routed Story collapses only the _advisory_ plan/mandrel-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`,
-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.
-
-**Ceremony comes from the landed diff; the dispatch mode comes from the
-run.** Persist stamps no route label (Story #5312 retired the plan-side lite
-claim with its `route::lite` hint). Ceremony is resolved from the **derived
-change level** (`deriveChangeLevel` over the computed change set — digest § 3),
-not from a body-shape read: a footprint intersecting a sensitive-path class
-derives `high`, so the Story keeps its fresh acceptance critic. The light path
-is the one caller that reads the authored body's shape, through
-`deriveStoryShape` (`lib/orchestration/complexity-gate.js`).
-
-That derived level sets ceremony. It does **not** set the dispatch mode,
+| Ceremony      | Per-Story, resolved from the ceremony profile alone via `ceremony-routing.js` (digest § 3) |
+
+**A cheap shape never buys a cheaper landing.** A small Story collapses only
+the _advisory_ ceremony — the fresh-critic / Tech-Spec authoring a
+one-artifact scope does not earn. The close-validation gates (lint / test /
+format / coverage / CRAP / maintainability), the PR to `main`, and the
+`rules/security-baseline.md` MUSTs run exactly as for any other Story. There
+is no gate bypass to opt into, and nothing in the ticket can declare one:
+Story #5312 retired the plan-side lite claim, its `route::lite` hint and the
+machine-readable field that used to enumerate the non-negotiables.
+
+**The ceremony rule has one home: digest § 3.** The profile alone names the
+verdict owner; the derived change level (`deriveChangeLevel` over the computed
+change set) sets **review depth**, so a footprint intersecting a sensitive-path
+class buys a deep review rather than a fresh acceptance critic. Persist stamps
+no route label. The light path is the one caller that reads the authored body's
+shape, through `deriveStoryShape`
+(`lib/orchestration/complexity-gate.js`).
+
+The derived level does **not** set the dispatch mode either,
 because `inline` names one indivisible resource — the router's own session —
 and only run topology can say whether it is free: a **single-Story run**
 executes inline, and every Story of a multi-Story run dispatches as a
@@ -235,46 +234,9 @@ before it spawns the worker — see [`/mandrel-deliver`](../mandrel-deliver.md).
 drift-guard and schema tests living outside the Story's scoped greps — are
 the failure class that actually bounces deliveries: close-validation
 discovers them only after the whole close pipeline has run, at several times
-the cost of one full-suite run in the worktree.
-
-**Run it once, last, through the depositor.** The run belongs **after** the
-self-eval loop's last fix commit; redraft rounds run scoped tests. Run it in
-the worktree on `story-<id>` as
-
-```bash
-node <main-repo>/.agents/scripts/evidence-gate.js \
-  --standalone --scope-id <storyId> --gate test \
-  --worktree <workCwd> -- npm test
-```
-
-The wrapper spawns the project's own `npm test` — whatever that resolves to —
-and records the pass into the Story evidence keyspace, so the credit is
-runner-agnostic by construction: it stamps only what it just ran. The record
-is keyed on HEAD and the tree fingerprint and hashed on the exact command
-close spawns, so close reports the gate as credited at unchanged HEAD instead
-of re-running the suite. The credit expires the moment it stops describing the
-tree: any later commit invalidates it and close re-runs the suite for real, so
-this never trades away the gate. The CRAP gate still runs
-`coverage-capture.js` itself when it needs a fresh artifact — the capture
-stamp is a claim about `coverage/coverage-final.json`, which `npm test` alone
-does not produce.
-
-**A bare `npm test` is a bonus, not the contract.** It deposits the same
-record only where the project's `test` script routes through mandrel's own
-runner (`run-tests.js` → `lib/test-run-credit.js`, Story #5313), which prints
-the outcome. A project whose `npm test` is `vitest run`, `jest` or any other
-runner never reaches that code, so it prints nothing and deposits nothing —
-silence is not a signal, and nothing here asks you to confirm the credit by
-reading for a line that cannot appear. `mandrel doctor`'s `test-credit-path`
-check reports which shape a project is and names the command above as its
-remedy.
-
-**`verify[]` reuses the same credit.** A `verify[]` entry that is itself a
-full-suite command is reported **credited** against that record rather than
-respawned (`resolveVerifyCredit` in
-[`verify-credit.js`](../../scripts/lib/orchestration/verify-credit.js)), and the
-self-eval gate warns when it sees one: the intended shape is scoped `verify[]`
-entries **plus** the single credited run.
+the cost of one full-suite run in the worktree. The run itself — when, how
+and what it credits — is stated once, in
+[`deliver-digest.md`](deliver-digest.md) § 5.
 
 **Conflict with `main` mid-implementation** → resolve as you would any branch
 rebase. There is no `epic/<id>` intermediate, so the rebase base is `main`
@@ -282,53 +244,33 @@ directly.
 
 ### Step 1a — self-eval mechanics
 
-**One verdict-owner per cluster.** The ceremony routing's
-resolved decision names each cluster's single verdict owner
+**One verdict owner per Story.** The ceremony decision names it
 (`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, with the
-cluster count owned by the dispatching caller and never by routing.
-
-**One round = N cluster critics → ONE merged verdict → ONE gate call** (fresh
-critics; an inline-owned verdict is one file scored in one call). The
-clusters are how a round is _authored_; they are not how it is _scored_.
-Concatenate every cluster's records into a single `criteria[]` ordered by
-`index` — exactly one per `acceptance[]` item, under one `storyId`,
-`schemaVersion`, `round` and `commitSha` — and hand that merged file to the
-gate once:
+`resolveCeremonyForRisk`), and it follows the **ceremony profile alone**
+(digest § 3): the contract-identical inline self-eval under `minimal` /
+`standard` (the default), the fresh maker-blind critic under `strict`.
+Exactly one pass authors the verdict — never both, and never a preliminary
+self-assessment before dispatching a 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.
+
+**One round = ONE verdict file → ONE gate call.** The verdict covers every
+`acceptance[]` item exactly once, ordered by `index`, under one `storyId`,
+`schemaVersion`, `round` and `commitSha`:
 
 ```bash
 node <main-repo>/.agents/scripts/acceptance-eval.js \
-  --story <storyId> --verdict <merged-verdict-path>
+  --story <storyId> --verdict <verdict-path>
 ```
 
 The gate reads the Story's `acceptance[]` count itself (Story #5313), so a
-single cluster's verdict handed over unmerged is rejected before scoring and
-consumes no round; `--expected-criteria` is accepted but redundant. Calling
-the gate once per cluster instead spends a round
-_per cluster_ — a Story past the cluster ceiling would burn its whole redraft
-budget on cluster arithmetic — and N concurrent calls race the Story-scoped
-round ledger. Full per-round mechanics, including the parallel dispatch and the
-merge shape: [`acceptance-self-eval.md`](acceptance-self-eval.md).
-
-**Critic evidence-share.** 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
-close short-circuits the gate at unchanged HEAD. Run it in the **Story
-worktree** (`workCwd` from Step 0):
-
-```bash
-node <main-repo>/.agents/scripts/evidence-gate.js \
-  --standalone --scope-id <storyId> --gate lint \
-  --worktree <workCwd> -- npm run lint
-```
+partial verdict is rejected before scoring and consumes no round;
+`--expected-criteria` is accepted but redundant. A second gate call inside one
+round spends a round for nothing, and concurrent calls race the Story-scoped
+round ledger. Full per-round mechanics:
+[`acceptance-self-eval.md`](acceptance-self-eval.md).
 
 **On `decision: "block"`** — post a `friction` comment naming the unmet
 criteria, then transition the Story to `agent::blocked`:
@@ -357,26 +299,17 @@ Its `level` comes from
 the one computed change-set list: a diff touching a sensitive path registered
 in `.agents/schemas/audit-rules.json` derives `high`, one touching none
 derives `low`, and an unenumerable diff (`files: null`) derives `null`.
-Hand the **same** `files` list to every acceptance critic you spawn (Step 1a)
-— a critic that re-ran its own `git diff` could score against a different
-set than the one that routed it.
-
-Its `mode` / `verdictOwner` come from
-[`resolveCeremonyForRisk`](../../scripts/lib/orchestration/ceremony-routing.js)
-(`minimal` → always inline; `strict` → always fresh; `standard` →
-`high`/`null` → `fresh`, `low` → `inline`). Review depth reads the same
-derived level via `review-depth.js` inside close, so the two decisions cannot
-disagree.
-
-**Inline-dispatch override.** When the Story dispatches
-`inline` (`resolveStoryDispatchMode` → `inline`, which is exactly a
-single-Story run — the function reads the resolved set size and nothing
-else), 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
-`verify[]` output as evidence) is unchanged; only the sub-agent boot is
-removed. Hard gates are untouched.
+Hand the **same** `files` list to the verdict owner (Step 1a) — an evaluator
+that re-ran its own `git diff` could score against a different set than the
+one that routed it.
+
+The derived level drives **review depth** and nothing else: `review-depth.js`
+reads it inside close and still resolves `deep` for any sensitive class.
+`mode` / `verdictOwner` come from
+[`resolveCeremonyForRisk`](../../scripts/lib/orchestration/ceremony-routing.js),
+which since Story #5366 accepts the profile and nothing else. The rule — and
+what an `inline` dispatch does and does not change about it — is stated once
+in **digest § 3**; do not restate it here.
 
 ---
 
@@ -716,9 +649,10 @@ resolves — that is the mechanism by which you wait. You MUST keep your turn al
 across the wait: watch → (fix + push + re-watch on red) → confirm the merge
 (Step 5) → flip `agent::done` → run the post-merge steps → and only then
 return the terminal JSON status contract. The CI wait NEVER terminates your
-turn; **only** a confirmed-`MERGED` PR (→ `status: "done"`), an
+turn; **only** a confirmed-`MERGED` PR (→ `status: "landed"`), an
 `agent::blocked` transition (→ `status: "blocked"`), or an unrecoverable
-failure (→ `status: "failed"`) does. Ending your turn with prose and an
+failure (→ `status: "failed"`) does — the statuses the shipped
+[terminal schema](../../schemas/story-deliver-terminal.schema.json) accepts. Ending your turn with prose and an
 unconfirmed merge is a contract violation — it is the very bug this workflow
 exists to prevent.
 

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

@@ -1,7 +1,7 @@
 ---
 description:
   Execute one Story end-to-end: story-<id> from main, implemented in a worktree
-  (optional ## Slicing checkpoints), derived-level ceremony, PR against main.
+  (optional ## Slicing checkpoints), profile-resolved ceremony, PR against main.
 mandatoryReads: [deliver-digest.md]
 ---
 
@@ -18,13 +18,12 @@ mandatoryReads: [deliver-digest.md]
 The **one** delivery engine in v2:
 
 ```text
-single-story-init.js → implement + commits → derived-level ceremony → push
+single-story-init.js → implement + commits → ceremony → push
   ──hand-off──▶ single-story-close.js (gates, PR → main, agent::closing)
   → CI watch + merge → single-story-confirm-merge.js (agent::done)
 ```
 
-An `Epic: #N` reference marks a v1 ticket — **stop** and re-plan. Engine
-traits and prerequisites: reference § Engine invariants.
+Engine traits and prerequisites: reference § Engine invariants.
 
 ## Who owns which step
 
@@ -33,8 +32,9 @@ that dispatched the work**, never to a spawned worker.
 
 - **Inline dispatch** (a one-Story run — digest § 1): one session is both
   roles and walks Steps 0→7, no hand-off.
-- **Sub-agent dispatch**: the `story-worker` stops at Step 2.5 with the branch
-  pushed and returns a hand-off; the dispatching `/mandrel-deliver` session runs Step 3
+- **Sub-agent dispatch**: the `story-worker` boots on the `promptPath`
+  `deliver-run.js` wrote for it, stops at Step 2.5 with the branch pushed and
+  returns a hand-off; the dispatching `/mandrel-deliver` session runs Step 3
   **in its own turn** and **serializes the tail — one close at a time across
   the run**, even though implementation ran in parallel (reference § Step 3).
 
@@ -84,22 +84,21 @@ live in [`acceptance-self-eval.md`](acceptance-self-eval.md). **`proceed`** →
 Step 2. **`block`** → **do not close**: post a `friction` comment and flip
 `agent::blocked` (reference § Step 1a).
 
-## Step 2 — Ceremony (profile + derived level)
+## Step 2 — Ceremony (the profile alone)
 
-Ceremony is `delivery.routing.ceremonyProfile` × the **derived change level**,
-never a planner-authored verdict. **Digest § 3** is the incantation (change set
-once, derive the level, resolve critics with `ceremony-routing.js`); edge cases
-are reference § Step 2. Hard gates always run in Step 3 — the derived level
-never disables them; do **not** pre-run the chain here — Step 2.5's credited
-suite run is the sole exception.
+The acceptance verdict owner comes from `delivery.routing.ceremonyProfile` and
+nothing else — not the diff, not the dispatch mode, never a planner-authored
+verdict. **Digest § 3** is the incantation (change set once, derive the level
+for review depth, resolve the owner with `ceremony-routing.js`) and the one
+home of the rule; edge cases are reference § Step 2. Hard gates always run in
+Step 3 — nothing here disables them; do **not** pre-run the chain here —
+Step 2.5's credited suite run is the sole exception.
 
 ### Step 2.5 — The one credited suite run, the push, then hand off
 
-After the self-eval loop's last fix commit, run the suite **once** in the
-worktree through the depositor — `evidence-gate.js … --gate test -- npm test`,
-spelled out in **digest § 5**. It runs whatever `npm test` resolves to and
-stamps that, so the `test` credit is earned on any runner and only a *later*
-commit invalidates it. Red → fix, commit, re-run.
+After the self-eval loop's last fix commit, run the one credited suite run
+in the worktree — **digest § 5** is its only home and carries the
+invocation. Red → fix, commit, re-run.
 
 Push `story-<storyId>` to `origin`, confirming the remote ref moved. Then
 (sub-agent dispatch only) return the hand-off — Story id, `workCwd`,

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

@@ -153,7 +153,8 @@ template's pre-resolved `changes[]` and the `/prototype` offer, nothing else.
 Story #5312 deleted the plan-side lite claim that used to read them
 (`--route-downgrade-reason`, the persist shape backstop, the `route::lite`
 hint): every Story lands through the same engine and the same close gates,
-and ceremony is derived from the landed diff at close.
+and the acceptance verdict owner follows the operator's ceremony profile —
+never anything a plan authored.
 
 ## Correct-by-construction authoring template
 
@@ -169,15 +170,15 @@ and ceremony is derived from the landed diff at close.
   are omitted: the work regenerates them, the refresh is a close-gate concern,
   and a declared shared artifact path reserves a footprint that needlessly
   serializes sibling Stories at dispatch.
-- **`changes[]` arrive pre-resolved to creates-vs-refactors.** Every path
-  the seed predicted is probed against the repo: an existing path is
-  emitted with `assumption: "refactors-existing"`, a missing one with
-  `assumption: "creates"`. The persist gates stay authoritative — they probe
-  the base branch ref, not the working tree — but a `creates` on a path that
-  exists at base, or a `refactors-existing` on one that does not, is a
-  dry-run **warning**, not a rejection; only a `deletes` naming an absent
-  path is refused. A plain-string bullet or a trailing parenthetical is
-  repaired into the object form by probing base, and the repair is reported.
+- **`changes[]` entries are bare paths.** The skeleton emits each seed-predicted
+  path as a bare string and persist derives its assumption by probing the base
+  branch ref — present is a `refactors-existing`, absent a `creates` — and
+  reports each derivation on the dry-run's repair list. Pin
+  `{path, assumption}` only when the probe would get it wrong; a `creates` on
+  a path that exists at base, or a `refactors-existing` on one that does not,
+  is then a dry-run **warning**, not a rejection. `deletes` stays explicit —
+  a bare path can never express a removal — and a `deletes` naming a path
+  absent at base is the one `changes[]` shape still refused.
 - **Keep `## Spec` at contract-level prose** — interfaces, invariants,
   load-bearing constraints; no per-file behavior narration — and as long as
   the work needs. There is no word or token budget.
@@ -188,11 +189,12 @@ kept — passes the persist ticket validators with no round-trip.
 ### Authored entry shape
 
 Each `stories.json` entry: `slug` (`^[a-z0-9][a-z0-9-]*$`), `type: "story"`,
-`title`, `body` (`goal`, optional `spec`, `changes[{path, assumption}]` —
-`creates|refactors-existing|deletes`, `non_goals`, `reason_to_exist`),
-top-level `acceptance[]`, `verify[]` (each a **bare command** — there is no
-tier suffix), and `depends_on[]` (a sibling slug, or `#<id>` for an existing
-open Story).
+`title`, `body` (`goal`, optional `spec`, `changes[]` — a **bare path string**
+by default, or `{path, assumption}` with
+`creates|refactors-existing|deletes` to pin one, `non_goals`,
+`reason_to_exist`), top-level `acceptance[]`, `verify[]` (each a **bare
+command** — there is no tier suffix), and `depends_on[]` (a sibling slug, or
+`#<id>` for an existing open Story).
 
 Author `acceptance[]` **without** the `AC-<n>:` handle: the body renderer
 numbers each checkbox from its array position, so a carried handle renders
@@ -200,11 +202,11 @@ doubled. Persist normalises one off rather than refusing, and names the strip
 on the dry-run's repair list.
 
 Nothing in that shape inventories the repo for the author. `changes[]` arrives
-pre-resolved against the working tree, and Phase 8's
-`validateStoryFileAssumptions` re-probes every `{path, assumption}` at persist
-as a hard error — so the grounding contract is the author's own targeted reads
-plus that gate. There is no pre-computed codebase snapshot to fall back on,
-and no manifest-derived replacement to build.
+filled in from the working-tree probe, and Phase 8's
+`validateStoryFileAssumptions` re-probes every resolved `{path, assumption}`
+at persist — so the grounding contract is the author's own targeted reads plus
+that gate. There is no pre-computed codebase snapshot to fall back on, and no
+manifest-derived replacement to build.
 
 ### Per-Story audit provenance (`provenance`)
 
@@ -264,8 +266,8 @@ substring-match advisories that depended on it are retired, leaving
 `shared-editor` as the one conflict kind. Both passes complete before the first
 `createIssue`, so a refusal still costs no writes.
 
-`shared-editor` findings are rendered into the posted `plan-summary` comment,
-directly beneath the wave table: the table promises which Stories can run
+`shared-editor` findings are rendered into the plan-summary section of every
+Story's posted `story-plan-state` comment, directly beneath the wave table: the table promises which Stories can run
 together, and a path two same-wave Stories both write is exactly where that
 promise breaks. Promise and caveat belong on one durable surface — previously
 the caveat was a stderr warning nobody kept.
@@ -318,13 +320,15 @@ template-only prose.
 
 ### Supersede-map partition
 
-`plan-persist` refuses a partial supersede map **before** it creates any
-Story, the same fail-closed shape as the collision refusal: every id passed to
-`--tickets` must be claimed by **exactly one** Story, and no Story may
-claim an id that was not a source ticket. With N>1 the mapping is not
-total by default — an authored map is the only thing that can say
-`#11-#14 → #20` while `#15 → #21`, which a blanket "superseded by
-this plan-run" reference could not.
+`plan-persist` completes the supersede map **before** it creates any Story,
+splitting it by who can be right. **Refused, fail-closed:** a Story claiming
+an id that was never a source ticket, and two Stories claiming the same id —
+the first would close an issue nobody asked about, the second cannot say which
+Story replaced it. **Assigned with a warning:** a source id no Story claimed
+goes to the primary Story, because this plan is replacing it either way and
+only the bookkeeping was open. With N>1 an authored map is still the only
+thing that can say `#11-#14 → #20` while `#15 → #21`, so author one whenever
+the default is not what you mean.
 
 ## The pre-mortem critic — operator-invoked
 
@@ -369,33 +373,41 @@ a re-author round.
 
 ## What `--dry-run` actually gates
 
-`plan-persist.js --dry-run` is the same command with GitHub writes suppressed,
-and every gate runs before the first `createIssue` would fire. Since
-Story #5312 the gates split two ways, and the dry-run is where the second
-half is read:
+A bare `plan-persist.js` runs the whole gate list write-free and then, on a
+clean list, persists in the same invocation (Story #5342); `--dry-run` is that
+same first half with the second suppressed. Either way every gate runs before
+the first `createIssue` would fire. Since Story #5312 the gates split two
+ways, and the dry-run output is where the second half is read:
 
 **Hard — the run refuses:** a body that does not parse, a ticket that is not
-a Story, an empty `acceptance[]` or `verify[]`, an unknown or cyclic
-`depends_on`, the acceptance partition at N>1, the supersede partition, a
-forbidden commit-subject prefix, and a `deletes` entry naming a path absent
-at base.
+a Story, an empty `acceptance[]`, an unknown or cyclic `depends_on`, the
+same-wave collision refusal at N>1, a supersede claim on a non-source id or
+one claimed twice, and a `deletes` entry naming a path absent at base.
+Story #5342 retired two: the commit-subject-prefix scan is gone entirely —
+the `commit-msg` hook and `normalize-pr-title.js` enforce subjects — and an
+empty `verify[]` is now a warning.
 
 **Warnings — listed, then the persist proceeds:** a `creates` on a path that
 exists at base or a `refactors-existing` on one that does not (including a
 path the base branch deleted or renamed, named with the removing commit), a
-goal or acceptance path absent at base, a `verify[]` command naming an absent
-test file, an `open-question` in a body (`Flag if…`, `TBD`, a trailing `?`),
-and a `pinned-identifier` in an acceptance item — a backticked bare symbol
+goal or acceptance path absent at base, an empty `verify[]`, a source id
+assigned to the primary Story by default, a `verify[]` command naming an
+absent test file, an `open-question` in a body (`Flag if…`, `TBD`, a trailing
+`?`), and a `pinned-identifier` in an acceptance item — a backticked bare symbol
 that is not a path, a label, a kebab token, a flag or a command, which the
 advisory `changes[]` is free to reshape out from under the criterion. The
 list also names every **repair** the run applied — a plain-string bullet or a
 trailing parenthetical rewritten into `{ path, assumption }` by probing base,
-and an `AC-<n>:` handle normalised off an acceptance item. The same list rides the result
-envelope as `warnings[]` and `repairs[]`, so a `--chain-on-clean` run loses
-nothing.
+and an `AC-<n>:` handle normalised off an acceptance item. The same list rides
+the result envelope as `warnings[]` and `repairs[]` — and because the repairs
+are applied in the write-free pass, the chained run carries that pass's
+`repairs[]` and `warnings[]` onto the envelope it returns, so the evidence
+survives the hand-off rather than being re-derived from an already-repaired
+draft.
 
 A dry run that comes back clean has paid for every deterministic refusal, so
-the real persist has nothing left to discover except network failure.
+the real persist has nothing left to discover except network failure — which
+is why the clean case no longer waits for a second operator invocation.
 
 ## The container Epic (Gate #3)
 
@@ -458,10 +470,8 @@ body lint), a `## Spec`, an `acceptance[]` / `verify[]`, or any path, finding
 or rationale a child does not already hold. It is a container; unique content
 here is content no delivering agent reads.
 
-What the **Stories** never gain is an `Epic: #N` footer. Linkage is
-parent→child only, which is exactly why every existing refusal of that footer
-still stands and each Story stays independently deliverable (ADR
-`20260905-5139`).
+Linkage runs parent→child only, which is why each Story stays independently
+deliverable (ADR `20260905-5139`).
 
 Degradation is deliberate: an unensurable `type::epic` label skips the Epic
 entirely (an unlabelled container is not a container), while a failed
@@ -508,13 +518,14 @@ state.
 ## Ready means fully persisted
 
 `agent::ready` is the **terminal** step, not part of the creating POST.
-The order is: create unlabelled → upsert `story-plan-state` on
-every Story → upsert `plan-summary` on the primary → flip every Story to
-`agent::ready`.
+The order is: create unlabelled → upsert `story-plan-state` on every Story —
+since Story #5343 one comment, carrying the plan summary (story set, delivery
+order, deliver command) and nothing else, since Story #5367 deleted the machine
+checkpoint no reader consumed — → flip every Story to `agent::ready`.
 
 This is what lets `/mandrel-deliver` trust the label: a Story carrying
-`agent::ready` always has its persist receipt on the ticket, so nothing can
-pick it up mid-write and read a half-persisted plan.
+`agent::ready` always has the operator's delivery instructions on the ticket,
+so nothing can pick it up mid-write and act on a half-persisted plan.
 
 ## Resuming a failed persist
 
@@ -546,7 +557,7 @@ them **envelope-first**:
 
 | Channel | When it wins |
 | --- | --- |
-| Envelope `sourceTickets[]` | **The normal path.** Written by step 1's `--out`, then read from `--plan-context <file>` or auto-discovered at `<plan-dir>/plan-context.json`. No ids to re-type. |
+| Envelope `sourceTickets[]` | **The normal path.** Written by step 1 to `<tempRoot>/plan-<slug>/` (or wherever `--out` points), then read from `--plan-context <file>` or auto-discovered at `<plan-dir>/plan-context.json`. No ids to re-type. |
 | `--source-tickets <ids>` | Explicit **override** for hand-driven runs (no captured envelope, or deliberately narrowing the set). Wins over the envelope; a disagreement is warned about, not silently reconciled. |
 
 The result envelope's `supersede.sourceTicketOrigin` reports which channel was