mandrel 2.24.0 → 2.26.0

package/.agents/workflows/deliver.md

@@ -8,73 +8,67 @@ description:
 # /deliver
 
 > **Lean spine.** Happy path + gate list. Sequencing, dispatch mechanics,
-> intent phrases, ceremony, and the epilogue live in the on-demand
-> [`helpers/deliver-reference.md`](helpers/deliver-reference.md); the unplanned
-> path in [`helpers/deliver-light.md`](helpers/deliver-light.md). What every
-> delivery always needs is one read:
-> [`helpers/deliver-digest.md`](helpers/deliver-digest.md).
+> intent phrases, ceremony and the epilogue live in on-demand
+> [`helpers/deliver-reference.md`](helpers/deliver-reference.md) ("reference"
+> below); the unplanned path in
+> [`helpers/deliver-light.md`](helpers/deliver-light.md). Every delivery reads
+> [`helpers/deliver-digest.md`](helpers/deliver-digest.md) once.
 
 ## Role
 
-One delivery door. `/deliver` owns input resolution and sequencing only — every
-Story lands through [`helpers/deliver-story.md`](helpers/deliver-story.md).
+One delivery door. `/deliver` owns input resolution, sequencing and the
+close-and-land tail; Stories are implemented via
+[`helpers/deliver-story.md`](helpers/deliver-story.md).
 
-Nothing about the route is declared at the invocation; it is **derived, then
-announced, then acted on**. The dependency graph is **discovered, not
-declared** — `resolve-stories.js` reads it from live state (body edges ∪ native
-`blocked_by` edges, each blocker resolved against its real issue state), so
-there is no graph to hand it and no batch label, which is what lets you deliver
-Stories **across plan runs and over time**.
-`plan-run::<id>` is filter metadata, never a resolution input; `route::lite` is
-a body-derived hint only. Ahead of all of it, a **single-Story run runs the
-engine inline** whatever the shape — sub-agent isolation only earns its cost
-against a concurrent sibling.
+The dependency graph is **discovered, not declared** — `resolve-stories.js`
+reads it from live state, so you can deliver Stories **across plan runs and
+over time**. `plan-run::<id>` is filter metadata, never a resolution input;
+`route::lite` a body-derived hint only.
 
 ## Inputs
 
-Classify what the operator typed **before** doing anything else, and say which
-shape you read it as:
+Classify what the operator typed **before** anything else, and say which shape
+you read:
 
 | Invocation | Shape | Behavior |
 | --- | --- | --- |
 | `/deliver` | bare | List the open `agent::ready` Stories and ask which to deliver. Deliver nothing until answered. |
 | `/deliver 4712` | ids | One Story via `helpers/deliver-story.md`, **inline in this session** — no `story-worker` spawn. |
-| `/deliver 4712 4713 …` | ids | Resolve the set, then sequence by the discovered graph via `stories-wave-tick.js`, dispatching role-scoped sub-agents. |
+| `/deliver 4712 4713 …` | ids | Resolve the set, sequence by the discovered graph via `stories-wave-tick.js`, dispatch sub-agents. |
+| `/deliver 4712 - 4716` | ids | A **range** — every id in the inclusive span. |
 | `/deliver add a --json flag to doctor` | prompt | Unplanned work: gate, author a receipt Story, land it — [`helpers/deliver-light.md`](helpers/deliver-light.md). |
 
-**The discriminator is lexical and total.** Every positional argument matching
-`^#?\d+$` means ids; anything else means a prompt. A **mixed** invocation (ids
-*and* prose) is a **hard error** — refuse it and ask which was meant, the way
-resolution refuses a whole set rather than under-delivering. A named ticket
-that is not `type::story`, or carries an `Epic: #N` footer, is a hard error too.
+**The discriminator is lexical and total.** An argument matching `^#?\d+$` is an
+id, and `^#?\d+\s*[-–—]\s*#?\d+$` an inclusive **range** — pass one on as a
+single unspaced token, never hand-expanded (reference § Ranges). Either shape
+means ids; anything else means a prompt. A **mixed** invocation (ids *and*
+prose) is a **hard error** — refuse it and ask which was meant. A ticket not
+`type::story`, or carrying an `Epic: #N` footer, is a hard error too.
 
 ## Saying what you want
 
-No flags to remember: state intent — *"…but I'll merge it myself"*, *"…take the
-lease"*, *"…one at a time"* — and announce what you read before acting.
-Phrasings and the flag each fills in:
-[`helpers/deliver-reference.md` § Intent phrases](helpers/deliver-reference.md).
+No flags to remember: state intent — *"…but I'll merge it myself"*, *"…one at
+a time"* — and announce what you read. Phrasings and the flags they fill in:
+reference § Intent phrases.
 
-`--yes` is **runner-set, never operator-typed**: cron, `/loop`, and headless
-dispatch set it to mean *nobody is at the keyboard*, which is what makes the
-unplanned path's over-scope stop fail closed to a terminal envelope instead of
-a question. Never offer it to an operator or add it to an attended run.
+`--yes` is **runner-set, never operator-typed**: cron, `/loop` and headless
+dispatch set it to mean *nobody is at the keyboard*, which fails the unplanned
+path's over-scope stop closed to an envelope instead of a question. Never offer
+it to an operator or add it to an attended run.
 
 ## Procedure
 
 0. **Classify and announce.** Read the invocation per § Inputs and state the
-   shape you derived. A prompt leaves for
-   [`helpers/deliver-light.md`](helpers/deliver-light.md); bare asks; ids
-   continue below.
-
-1. **Resolve the set.** One command, for one Story or many:
-   `node .agents/scripts/resolve-stories.js --ids <id,id,...>`. It validates
-   the set and shows what will run: read `stories[]`, `dag[]`, and `done[]` to
-   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 against
-   an unlanded blocker.
+   shape. A prompt leaves for
+   [`helpers/deliver-light.md`](helpers/deliver-light.md); bare asks; ids go on.
+
+1. **Resolve the set.** One command, one Story or many:
+   `node .agents/scripts/resolve-stories.js --ids <id,id,...>`. It validates the
+   set and shows what will run: read `stories[]`, `dag[]` and `done[]` to
+   present the order in step 2, but do **not** thread them into step 3 — the
+   tick re-resolves the graph every beat. It hard-errors (exit 1) on an id that
+   is not a Story, carries an `Epic: #N` footer, or whose edges cannot be
+   read — a missing gate would co-dispatch against an unlanded blocker.
 
 2. **Confirm (N>1).** Present the order; wait unless `--yes`.
 
@@ -87,74 +81,75 @@ a question. Never offer it to an operator or add it to an attended run.
    ```
 
    **Do not add `--concurrency` unless the operator explicitly asked for a
-   per-run cap** — an explicit value wins over config, so a filled-in literal
-   silently defeats a `.agentrc.local.json` override.
+   per-run cap** — an explicit value wins over config, so a literal defeats a
+   `.agentrc.local.json` override.
 
    Each beat re-probes live state to derive done / in-flight itself; you never
    compute them. `--dispatched` is the one thing you must supply — the
-   append-only list of every id you spawned this run — and cross-run
-   de-confliction via the assignee lease is automatic
-   ([`helpers/deliver-reference.md`](helpers/deliver-reference.md) §§ Sequencing
-   edge cases, Dispatch mechanics).
-
-   Branch on the exit code:
-   - **0** — dispatch each `ready` id (already capped and overlap-free). Empty
-     `ready` with work in flight means "waiting"; keep looping.
-     `epilogueDue: true` means every Story is done — go to step 4.
-   - **2** — `cycleError`: the graph is self-referential. Fix the `depends_on`
-     declarations; do not retry.
-   - **3** — `wedged`: nothing dispatchable, nothing in flight, undone Stories
-     waiting on unmet blockers — both named in the envelope. Land the blocker
-     or include it in `--ids`; do not retry unchanged.
-   - **4** — `blocked`: a Story carries `agent::blocked`, named in `blocked[]`
-     with `blockedReason` — the protocol's HITL pause
-     ([`instructions.md` § 1.J](../instructions.md)). **Stop the loop and
-     surface it; do not poll.** Read the friction comment
-     (`gh issue view <id> --comments`) and resume only once the operator
-     unblocks it (`update-ticket-state.js --ticket <id> --state agent::ready`).
-     Blocked outranks a wedge but not a cycle (fix the graph first).
-
-4. **Per-run epilogue (N>1).** Once step 3 reports `epilogueDue: true`, run
-   `node .agents/scripts/plan-run-epilogue.js --stories 101,102` — audit
-   roster, follow-up roll-up, sibling coherence. A single-Story run skips it
+   append-only list of every id you spawned this run. Cross-run de-confliction
+   via the assignee lease is automatic (reference §§ Sequencing edge cases,
+   Dispatch mechanics). Branch on the exit code:
+   - **0** — dispatch each `ready` id (already capped and overlap-free); an
+     empty `ready` with work in flight means "waiting", so keep looping;
+     `epilogueDue: true` means every Story is done — step 4.
+   - **2** — `cycleError`: the graph is self-referential; fix `depends_on`, do
+     not retry. **3** — `wedged`: nothing dispatchable, nothing in flight, the
+     undone Stories and their unmet blockers named; land a blocker or add it to
+     `--ids`. **4** — `blocked`: a Story carries `agent::blocked` with
+     `blockedReason`, the protocol's HITL pause
+     ([`instructions.md` § 1.J](../instructions.md)) — **stop the loop and
+     surface it; do not poll**, resuming once the operator unblocks it. Blocked
+     outranks a wedge, not a cycle.
+
+4. **Close each hand-off** (§ Closing what the workers hand back), then, with
+   every Story landed, run the **per-run epilogue (N>1)**:
+   `node .agents/scripts/plan-run-epilogue.js --stories 101,102`. N=1 skips it
    ([reference § Per-run epilogue](helpers/deliver-reference.md)).
 
-## Branch model (authoritative)
+5. **Correct what the change invalidated.** If a memory you recalled this
+   session is now wrong — a trap this landed, a budget it moved — fix that
+   entry now, while both the old belief and the new fact are in context, and
+   say so when you report. No memory substrate → skip silently. Sweeping the
+   whole pool is [`/memory-consolidate`](memory-consolidate.md), not this step.
+
+## Closing what the workers hand back {#tail}
 
-`story-<id>` → PR → `main` (squash + required checks), per digest § 2.
-Dependent Stories land sequentially so each builds on the previous merge.
-Ceremony depth (profiles + derived level via `ceremony-routing.js`, review
-depth reading the same level):
-[`helpers/deliver-reference.md` § Ceremony](helpers/deliver-reference.md).
+**The tail is the orchestrator's, not the worker's.** A dispatched
+`story-worker` stops at a pushed branch and returns a hand-off; **you** run
+[`helpers/deliver-story.md`](helpers/deliver-story.md) Step 3
+(`single-story-close.js`) for it, foreground, and relay the envelope.
 
-## Reading a Story's outcome
+**Serialize the tail.** Implementation runs in parallel; closing does not. Close
+one Story at a time — closes contend on the base branch, the merge queue and
+the checkout. A worker handing back mid-close waits its turn.
 
-Each Story 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.
+**A worker returning no terminal envelope is the expected shape**, not a failure
+to answer with a re-dispatch: only close mints one. Close the pushed branch, or
+probe read-only with `node .agents/scripts/deliver-recover.js --story <storyId>`
+and resume the worker or close it names.
 
-`pending` is **not** a failure: the bounded wait expired with the PR healthy
-(or a human owns the merge), nothing was mutated, and `nextCommand` resumes it
-— run that rather than re-dispatching.
+**Reading the outcome.** Each close ends the Story in one schema-validated
+envelope — `landed` | `pending` | `blocked` | `failed`; statuses, exits and
+fields are digest § 5. `pending` is **not** a failure — `nextCommand` resumes
+it; run that, do not re-dispatch.
 
-For a Story in an unclear state — including the merged-but-label-stale one a
-re-run refuses outright — probe it read-only with
-`node .agents/scripts/deliver-recover.js --story <storyId>`.
+**Branch model (authoritative).** `story-<id>` → PR → `main` (squash +
+required checks), per digest § 2; dependent Stories land sequentially. Ceremony
+depth (profiles + derived level via `ceremony-routing.js`, review depth reading
+it): reference § Ceremony.
 
 ## Constraints
 
-- **Land or block — never a silent local build** (digest § 2). Attended
-  delivers default to close-and-land (`delivery.routing.closeAndLand: true`);
-  rest at `agent::closing` only when a human owns the merge.
+- **Land or block — never a silent local build** (digest § 2). Attended delivers
+  default to close-and-land (`delivery.routing.closeAndLand: true`); rest at
+  `agent::closing` only when a human owns it.
 - **`/deliver` never plans.** Planned tickets come from [`/plan`](plan.md), and
   an over-scope prompt **escalates and ends** — never invoke `/plan` in this
   session to rescue it ([`helpers/deliver-light.md`](helpers/deliver-light.md)
-  § Escalation is terminal). The router performs no git/label mutations;
-  `deliver-story` owns every script.
+  § Escalation is terminal).
 
 ## See also
 
-- [`/plan`](plan.md) — unified planning entry point.
-- [`helpers/deliver-story.md`](helpers/deliver-story.md) — the one engine.
-- [`helpers/deliver-light.md`](helpers/deliver-light.md) — the unplanned
-  prompt path, shared with `/plan` Gate #1.
+[`/plan`](plan.md), [`helpers/deliver-story.md`](helpers/deliver-story.md) (the
+engine), [`helpers/deliver-light.md`](helpers/deliver-light.md) (the unplanned
+prompt path, shared with `/plan` Gate #1).

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

@@ -40,8 +40,8 @@ mid-delivery, and evaluates the actual work product.
    `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
+   the acceptance-block cost. Step 3's gate is the deterministic **scorer**
+   of the one merged verdict, not a second (or third) pass over the
    criteria.
 
    > **Sub-agent type + derived-level ceremony.** When
@@ -134,20 +134,56 @@ mid-delivery, and evaluates the actual work product.
      fresh — a false-fresh coverage record without `coverage-final.json`
      silently weakens the floor. Limit the evidence-share to `lint` and
      `typecheck`.
-   - Emits a verdict file under `temp/` conforming to
+   - Emits a **cluster** verdict file under `temp/` conforming to
      [`acceptance-eval-verdict.schema.json`](../../schemas/acceptance-eval-verdict.schema.json):
      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`). The gate **scores the single verdict
-   the round's owner authored** — schema validation, round cap, decision —
-   and never re-scores the criteria itself:
+     verifyEvidence[] }` record per acceptance item **in that cluster**, each
+     `index` being the item's position in the Story's full `acceptance[]`
+     array. A fresh critic **returns that path to you** rather than calling the
+     gate itself.
+2. **Dispatch the round's clusters in parallel, then merge into one verdict.**
+   The clusters of a round are independent, so dispatch **all** of the round's
+   fresh critics as N `Agent` calls **in a single assistant turn** —
+   [`parallel-tooling.md`](parallel-tooling.md) **Rule 3** — never serially,
+   and never one round per cluster. Clusters routed `inline` are authored in
+   the same round alongside them.
+
+   Then **merge** the cluster verdicts into **one** verdict file under `temp/`:
+   concatenate every cluster's `criteria[]` records and order the merged array
+   by `index`, so it holds exactly one record per `acceptance[]` item in
+   **acceptance-array order**, under a single top-level `storyId`,
+   `schemaVersion`, `round` and `commitSha`. The verdict schema deliberately
+   carries **no `clusterId`** — the round's artifact is the merged verdict, and
+   which critic scored which record is not part of the contract.
+
+   > **Why one gate call and not N.** The round counter is **Story-scoped** —
+   > derived by counting `acceptance-eval` signals in the Story's
+   > `signals.ndjson` — and each cluster verdict has a distinct fingerprint, so
+   > the replay guard never collapses them. A gate call per cluster would spend
+   > one of the (default 2) rounds *per cluster*, so a Story with more than 8
+   > acceptance criteria would exhaust its redraft budget on cluster arithmetic
+   > alone; N concurrent calls would also race that same ledger. Cluster-scoped
+   > round counting exists in
+   > [`acceptance-eval-decision.js`](../../scripts/lib/orchestration/acceptance-eval-decision.js)
+   > but requires an integer `epicId`, which v2 pins `null` — it is not a way
+   > around the merge.
+3. **Decide — exactly one gate call per round.** Run the gate against the
+   **merged** verdict (the caller's Step 1a names the exact invocation — omit
+   `--epic`). The gate **scores the single verdict the round produced** —
+   schema validation, round cap, decision — and never re-scores the criteria
+   itself:
 
    ```bash
    node <main-repo>/.agents/scripts/acceptance-eval.js \
-     --story <storyId> --verdict <verdict-path>
+     --story <storyId> --verdict <merged-verdict-path> \
+     --expected-criteria <number of acceptance[] items>
    ```
 
+   Pass `--expected-criteria` from the `acceptance[]` count you already read
+   off the Story body: a verdict whose `criteria[]` length differs — a single
+   cluster's verdict handed over unmerged — is rejected **before scoring**,
+   with an error naming the merge contract and consuming **no round**.
+
    The gate validates the verdict against the schema, applies the round cap,
    emits the per-criterion `acceptance-eval` signal into the retro / feedback
    substrate, prints a JSON envelope, and exits with one of three decisions:
@@ -161,4 +197,5 @@ mid-delivery, and evaluates the actual work product.
      (transition to `agent::blocked`) and post a `friction` comment naming the
      unmet criteria and their evidence. Never silently proceed to close.
 
-Write the verdict files under `temp/` only — they are scratch artifacts.
+Write both the per-cluster verdicts and the merged verdict under `temp/` only —
+they are scratch artifacts.

package/.agents/workflows/helpers/audit-lens-core.md

@@ -76,7 +76,7 @@ the primary file the finding lives in:]
 ### `path/to/primary-file.ext` — [Short title of the issue]
 
 - **Dimension:** [the lens-specific dimension — see the lens's own list]
-- **Severity:** [Critical | High | Medium | Low]
+- **Severity:** [Critical | High | Medium | Low | Info]
 - **Location:** `path/to/primary-file.ext:line`
 - **Current State:** [the specific file/line/module and why it is problematic]
 - **Recommendation & Rationale:** [how to remediate and why it matters]
@@ -89,11 +89,18 @@ the primary file the finding lives in:]
 
 ## Severity scale {#severity-scale}
 
-Every finding grades its severity (labelled `Severity` or `Impact`) on this
-ordered scale. `parse-audit-md.js` recognizes every level, and a surviving
-**Critical** finding halts the delivery gate
+Every finding grades its severity (labelled `Severity` or `Impact`) on the
+ordered scale below. **The code owns this vocabulary**: it is defined in
+[`lib/findings/severity.js`](../../scripts/lib/findings/severity.js)
+(`SEVERITIES`), and every level here — including its accepted spellings — comes
+from that module. A surviving **Critical** finding halts the delivery gate
 (`lib/audit-suite/findings.js#hasSurvivingCritical`).
 
+Grade on **exactly** these five levels. A level of your own invention does not
+parse: it resolves to no severity, tallies as `unknown`, and the finding is
+dropped by every severity-filtered run — including the most permissive one. A
+dropped finding is indistinguishable from a finding you never wrote.
+
 - **Critical** — an active, exploitable, or data-losing defect that must be
   fixed before the change can ship (e.g. a leaked secret, an auth bypass, a
   guaranteed production outage or data-loss path).
@@ -102,6 +109,11 @@ ordered scale. `parse-audit-md.js` recognizes every level, and a surviving
 - **Medium** — a real problem worth scheduling; contained blast radius, or a
   reasonable workaround exists.
 - **Low** — minor or cosmetic; fix opportunistically.
+- **Info** — the canonical floor: a real, grounded observation worth recording
+  that asks for no scheduled work (a documented deviation worth noting, a
+  measurement that is fine today and worth watching). Accepts `Informational`.
+  Use it instead of inventing a below-`Low` word of your own; a finding that
+  cannot clear the evidence bar below is **dropped**, not filed as `Info`.
 
 ## Self-cross-check (mandatory — filter false positives before you finalize) {#self-cross-check}
 
@@ -149,6 +161,15 @@ that rests on one of them:
 - **Style-only nits already enforced by a formatter/linter** — do not
   re-litigate what the committed tooling already governs.
 
+> **Boundary with the dead-wiring mandate.** The architecture and quality lenses
+> are required to report shipped seams with no live production caller (their own
+> bodies carry the mandate). The exclusions above **bound** that mandate rather
+> than cancelling it: a test seam, a CLI entry point, a declared `exports`
+> surface, or a dynamically-reached symbol is still never a finding. What the
+> mandate targets is the case none of those cover — an **internal** seam that a
+> delivery shipped and nothing in production ever calls. When a candidate is
+> genuinely one of the exclusions, cite the exclusion and drop it.
+
 ### Final re-open-and-drop pass (mandatory)
 
 1. Walk your Detailed Findings once more, applying the bar and the exclusion

package/.agents/workflows/helpers/code-quality-guardrails.md

@@ -35,8 +35,15 @@ thresholds, sourced from
 | CC range | Action |
 | --- | --- |
 | ≤ 8 | Pass — no annotation required. |
-| > 8 (default `cyclomaticFlag`) | **Flag** in review: explain why, or split. The function is allowed to land but the audit report names it. |
-| > 12 (default `cyclomaticMustFix`) | **Must-fix**: refactor before the Story commits. `quality:preview` reports it as a violation; the close-validation chain refuses the merge. |
+| > 8 (default `cyclomaticFlag`) | **Flag** — `quality:preview` counts the function in its `new-method count over c=<flag>` column. The function is allowed to land but the report names it. |
+| > 12 (default `cyclomaticMustFix`) | **Must-fix**: `check-cyclomatic.js` fails when a file gains a function above the ceiling, or when its worst function gets worse than the recorded baseline. |
+
+`check-cyclomatic.js` is a **ratchet**, not a cliff: `baselines/cyclomatic.json`
+records the over-ceiling functions a repository already carries, so adopting
+the gate never demands a mass refactor. Burning a recorded breach down is
+always allowed and re-records itself on the next `--update`; adding one is
+what fails. It runs in the same required-check slot as `check-arch-cycles.js`
+and `check-dead-exports.js`.
 
 A common refactor that pulls a 13-CC function under 8 is extracting the early-
 return guard chain into a named predicate, then collapsing the remaining

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

@@ -10,10 +10,9 @@ description: >-
 # 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
+> the steps; this file is the material they reference, bundled so one read
+> covers the 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.
@@ -28,10 +27,10 @@ rule produces it:
    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. **Every other run is `subagent`.** A multi-Story run dispatches every Story
-   as a sub-agent however trivial its shape: a lite body does not conjure a
-   second session for a sibling to run in, and the wave tick may hand you the
-   whole set on one beat. Shape still sets ceremony and is reported alongside;
-   the `route::lite` label is a human-visible hint, never the control signal.
+   as a sub-agent however trivial its shape — a lite body does not conjure a
+   second session for a sibling, and the wave tick may hand you the whole set
+   on one beat. Shape still sets ceremony; 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
@@ -54,21 +53,32 @@ the only sanctioned landing. A silent local build is not a delivery.
 ## 3. Change set — computed once, handed to everyone
 
 One enumeration per Story. A critic that re-runs its own `git diff`
-can score a different set than the one that routed it:
+can score a different set than the one that routed it. Both routing calls take
+a single options object and are **total — they never throw**, so a wrong-shaped
+argument is silently absorbed into the `null` fail-safe:
 
 ```bash
 node --input-type=module -e '
-  import { computeChangeSet } from "<main-repo>/.agents/scripts/lib/orchestration/change-set.js";
+  const lib = "<main-repo>/.agents/scripts/lib/orchestration";
+  const { computeChangeSet } = await import(`${lib}/change-set.js`);
+  const { deriveChangeLevel } = await import(`${lib}/review-depth.js`);
+  const { resolveCeremonyForRisk } = await import(`${lib}/ceremony-routing.js`);
   const { files } = computeChangeSet({ baseRef: "main", headRef: "story-<storyId>" });
-  console.log(JSON.stringify(files));
+  // deriveChangeLevel({ changedFiles, injectedRules?, selectSensitivePathClassesFn? })
+  //   -> { level, classes } — an OBJECT, never a bare level.
+  const { level, classes } = deriveChangeLevel({ changedFiles: files });
+  // resolveCeremonyForRisk({ derivedLevel, clusterIndex?, freshCriticSampleRate?,
+  //   ceremonyProfile? }) -> { mode, reason, sampled, profile, verdictOwner }.
+  // derivedLevel is that level STRING. Handing it the object above matches no
+  // tier, so it routes to the null fail-safe: a fresh critic, silently.
+  const ceremony = resolveCeremonyForRisk({ derivedLevel: level, clusterIndex: 0 });
+  console.log(JSON.stringify({ files, level, classes, ...ceremony }));
 '
 ```
 
-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`
+Level rules ([`review-depth.js`](../../scripts/lib/orchestration/review-depth.js)):
+a sensitive path registered in `audit-rules.json` → `high`, none → `low`, an
+unenumerable diff (`files === null`) → `null`. Ceremony rules
 ([`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
@@ -78,16 +88,26 @@ fresh. An `inline` dispatch mode overrides all of it to inline critics. Close's
 ## 4. Acceptance self-eval (Step 1a, required)
 
 **One verdict-owner per cluster** — 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:
+self-eval, named by `verdictOwner`, never both and never a warm-up pass. Each
+scores its cluster's `acceptance[]` items against the change set above, with
+`verify[]` output as evidence. Bounded by `delivery.acceptanceEval.maxRounds`
+(default 2).
+
+**One round = N cluster critics → ONE merged verdict → ONE gate call.** Merge
+every cluster's records into a single `criteria[]` in `acceptance[]` order, one
+per acceptance item, and score that once. A gate call per cluster spends a
+round *per cluster* and races the round ledger:
 
 ```bash
 node <main-repo>/.agents/scripts/acceptance-eval.js \
-  --story <storyId> --verdict <verdict-path>
+  --story <storyId> --verdict <merged-verdict-path> \
+  --expected-criteria <acceptance[] count>
 ```
 
+Pass `--expected-criteria` — **without it the coverage assertion is inert**, so
+an unmerged cluster verdict scores a fraction of the criteria and still reports
+`proceed`. A mismatch is rejected before scoring and costs no round.
+
 `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).