mandrel 2.57.0 → 2.59.0

package/.agents/scripts/lib/templates/decomposer-prompts.js

@@ -24,14 +24,19 @@ import { BODY_FORMAT_LINTS } from '../story-body/body-format-lints.js';
  *     no verify-tier suffix — every one of those either scored a shape the
  *     authoring model already judges or prescribed a proxy that became the
  *     goal.
- *   - **The N>1 rules** ({@link renderStorySplitRules}) — the schedule and
- *     partition rules that only mean anything once a draft has siblings:
- *     every Story must earn its slot in the wave schedule, and every
- *     acceptance criterion belongs to exactly one Story.
+ *   - **The N>1 rules** ({@link renderStorySplitRules}) — the schedule rules
+ *     that only mean anything once a draft has siblings: every Story must
+ *     earn its slot in the wave schedule, and no same-wave pair may collide
+ *     on a declared path (Story #5332 replaced the acceptance partition with
+ *     the dispatcher's own collision predicate, armed as a refusal).
+ *   - **The tickets-mode rules** ({@link ticketsModePromptField}, Story
+ *     #5323) — what to re-derive rather than carry when the seed is an
+ *     existing ticket whose body is already in Story shape.
  *
- * The envelope carries the core as `systemPrompts.story` and the split rules
- * as `systemPrompts.storySplitRules`; a planner reads the second only when
- * the default-single split policy clears.
+ * The envelope carries the core as `systemPrompts.story`, the split rules as
+ * `systemPrompts.storySplitRules` and the tickets rules as
+ * `systemPrompts.storyTicketsRules`; a planner reads the second only when the
+ * default-single split policy clears, and the third only in tickets mode.
  */
 
 /**
@@ -131,9 +136,9 @@ The **persisted** \`body\` renders these markdown sections (in order) — you au
 
 - **goal** (in body string): One sentence stating WHY this Story exists.
 - **spec** (optional, in body string as \`## Spec\`): The technical approach at the altitude the SPEC PROSE CONTRACT below fixes — contract and invariants, never implementation narration. Write as much as the work needs and no more; persist keeps Specs inline at any length and never writes them under \`docs/\`.
-- **slicing** (optional): Ordered intra-session checkpoints for one Story, one line each. Not a fan-out table and not a duplicate of Acceptance.
-- **changes** (in body string): Each entry is an object \`{ path, assumption }\` where \`assumption\` is one of \`creates | refactors-existing | deletes\`. Acceptable path shapes include explicit files (\`src/components/Foo.tsx\`), glob patterns (\`tests/e2e/*.spec.ts\`, \`**/*.astro\`), and module identifiers that resolve to files. Use \`refactors-existing\` for in-place edits to a file already on \`main\`; \`creates\` for net-new files; \`deletes\` for removals. Persist probes every path against the base branch and repairs a plain-string bullet or a trailing parenthetical into the object form for you; a \`creates\` on an existing path or a \`refactors-existing\` on an absent one is a dry-run warning, and only a \`deletes\` naming an absent path is refused.
-- **acceptance** (top-level array on the ticket object): Each item is an **outcome a PR reviewer can confirm from the diff and the verify output** — what is true of the codebase once the Story lands, stated at the altitude of the capability (a command that now exits 0 against a named input, a behavior a named test now asserts, a config that now fails validation on a retired key, a document that now records a decision). Aim for **three to six** items: fewer than three usually means the outcome is under-specified; more than six usually means acceptance is re-listing the footprint or the mechanical checks that belong in \`verify[]\`. Push grep-shaped probes, file-exists checks and exit-code tests down into \`verify[]\`; never pin an internal helper name or a private file path into an acceptance item the advisory \`changes[]\` is free to reshape. UNACCEPTABLE: "verify by reading the diff", "looks good", "matches the spec".
+- **slicing** (optional): Ordered intra-session checkpoints for one Story, one line each. A checkpoint is a **stage of the work** — a commit boundary the deliverer passes through inside one session, stated as the step it performs. An acceptance item is a **state of the codebase** a PR reviewer confirms once the Story has landed. The same Story therefore carries both: the checkpoints say in what order it is built, \`acceptance[]\` says what must then be true. Never a fan-out table, never a second acceptance list, and never sibling tickets — a broad sweep with many stages is still one Story, sliced here.
+- **changes** (in body string): Each entry is an object \`{ path, assumption }\` where \`assumption\` is one of \`creates | refactors-existing | deletes\`. **Name the files the deliverer authors, and omit generated artifacts** — quality baselines, generated test indexes, migration journals, lockfiles and the like are regenerated by the work itself, the refresh is a close-gate concern, and declaring one needlessly reserves a footprint that serializes sibling Stories at dispatch. Acceptable path shapes include explicit files (\`src/components/Foo.tsx\`), glob patterns (\`tests/e2e/*.spec.ts\`, \`**/*.astro\`), and module identifiers that resolve to files. Use \`refactors-existing\` for in-place edits to a file already on \`main\`; \`creates\` for net-new files; \`deletes\` for removals. Persist probes every path against the base branch and repairs a plain-string bullet or a trailing parenthetical into the object form for you; a \`creates\` on an existing path or a \`refactors-existing\` on an absent one is a dry-run warning, and only a \`deletes\` naming an absent path is refused.
+- **acceptance** (top-level array on the ticket object): Each item is an **outcome a PR reviewer can confirm from the diff and the verify output** — what is true of the codebase once the Story lands, stated at the altitude of the capability (a command that now exits 0 against a named input, a behavior a named test now asserts, a config that now fails validation on a retired key, a document that now records a decision). State as many outcomes as the capability has and no more — the list has no target, floor or ceiling, and a long one is never a reason to split the Story. Push grep-shaped probes, file-exists checks and exit-code tests down into \`verify[]\`; never pin an internal helper name or a private file path into an acceptance item the advisory \`changes[]\` is free to reshape. UNACCEPTABLE: "verify by reading the diff", "looks good", "matches the spec".
 - **verify** (top-level array on the ticket object): The **mechanical checks** — exact commands or test paths the deliverer runs and the acceptance critic consumes as evidence: \`node --test tests/x.test.js\`, \`npm run lint\`, \`npm run validate\`, a scoped grep. Every acceptance item should be confirmable from at least one verify entry's output plus the diff. Stories with zero verify entries fail validation.
 - **Bodies record decisions, never questions to the operator.** Never persist an open question ("Flag if…", "TBD", "confirm with the operator") into a Story body — the executing sub-agent is non-interactive and cannot answer it, and the dry-run warns on every one it finds. Triage each unknown by who can resolve it: an AFK-shaped unknown (a fact in docs, a third-party API surface, observable repo behavior) MUST be resolved by your own research before authoring — never restated as an assumption; only a HITL-shaped unknown (a genuine product or architecture call the operator owns) may be restated as a declarative Key Assumption the agent can act on, stating the default chosen (a decision-made-by-default).
 - **non_goals** (OPTIONAL, in body string as the \`## Non-Goals\` section): A short list of capabilities or changes this Story explicitly does NOT deliver — an advisory negative-scope bound that fences the executing agent away from adjacent work. It is **advisory and NON-GATING**: the validator does not require, count, or reject on it, and an absent or empty section renders nothing. Use the EXACT single-word hyphenated heading spelling \`## Non-Goals\` (a space-separated heading like \`## Out of Scope\` is NOT recognized by the parser and will be dropped). Reach for it when a Story's negative boundary is non-obvious from its \`acceptance[]\` alone; omit it otherwise.
@@ -167,13 +172,13 @@ ${advisoryCaveat}
 
 **Decompose at deliverable granularity, not module/task level.** ${granularityDefinition}
 
-The only sizing question is **cohesion**: *is this one coherent change with one reason to exist?* There is no ceiling on a Story's footprint, Spec length or acceptance count — a broad contract cutover is one Story when every changed site changes for the same reason. Frontier models one-shot capability-sized work in a single pass; do not fragment a coherent capability into dependent slices to stay "small", and do not pad a Story with adjacent work to look "complete".
+The only sizing question is **cohesion**: *is this one coherent change with one reason to exist?* There is no target, floor or ceiling on a Story's footprint, Spec length or acceptance count, and a long acceptance list is a description of a broad capability, never a reason to split. A broad contract cutover is one Story when every changed site changes for the same reason. Frontier models one-shot capability-sized work in a single pass; do not fragment a coherent capability into dependent slices to stay "small", and do not pad a Story with adjacent work to look "complete".
 
 ${envelopeFloor}
 
-- **One Story = one coherent change with one reason to exist.** If you cannot state that reason in a sentence, the Story is probably two Stories — or two Stories that should be one.
+- **One Story = one coherent change with one reason to exist.**
+- **A remediation sweep over one subsystem is one Story.** A batch of findings in the same subsystem shares one reason to exist — the subsystem is wrong — so it arrives as one Story whose \`## Slicing\` checkpoints carry the stages, not as one Story per finding.
 - ${singleConsumerRule}
-- **Split independent, parallelizable work** into sibling Stories — but only when the pieces genuinely have separate reasons to exist.
 
 #### UI / TESTID INVARIANCE (per CLAUDE.md safety rule):
 
@@ -197,7 +202,7 @@ IMPORTANT DEPENDENCY RULE: Story-to-Story dependencies are expressed via \`depen
 /**
  * The rules that only apply once a draft has more than one Story: the
  * delivery-schedule simulation that makes each Story earn its slot, and the
- * acceptance partition persist enforces at N>1.
+ * same-wave collision refusal persist enforces at N>1.
  *
  * @returns {string}
  */
@@ -209,16 +214,44 @@ You are splitting past the default-single policy, so simulate the delivery sched
 1. **Build the wave schedule.** A Story runs only after every \`depends_on\` completes, and two Stories that name the same file in \`changes[]\` cannot run in the same wave (the scheduler serializes file-overlapping Stories even when no \`depends_on\` edge links them).
 2. **Every Story must earn its slot** by at least one of:
    - **(a) parallelism** — it actually runs concurrently with a sibling in the schedule you just built ("logically independent" does not count; *schedule*-independent does);
-   - **(b) risk isolation** — it isolates a consumer-facing behavior change or high-risk cutover into its own reviewable, revertable unit;
-   - **(c) cohesion break** — merged into its neighbor it would no longer be one coherent change with one reason to exist.
-3. **A dependent link with none of those justifications merges into its consumer.** This generalizes the single-consumer merge rule from pairs to chains: N Stories that deliver no faster than one Story pay N delivery sessions (branch, PR, review, CI) for nothing.
+   - **(b) cohesion break** — merged into its neighbor it would no longer be one coherent change with one reason to exist.
+3. **A dependent link with neither of those justifications merges into its consumer.** This generalizes the single-consumer merge rule from pairs to chains: N Stories that deliver no faster than one Story pay N delivery sessions (branch, PR, review, CI) for nothing.
 4. **When one file appears in the \`changes[]\` of most of your Stories, the slicing axis cuts across a shared seam** — merge the Stories that co-edit it, or re-slice along the seam so each Story owns its files.
 
-#### ACCEPTANCE PARTITION (persist-enforced at N>1):
+#### THE COLLISION REFUSAL (persist-enforced at N>1):
 
-- Every acceptance criterion of the plan belongs to **exactly one** Story — no criterion is shared, and none is dropped. Persist refuses a draft whose criteria overlap or leave a plan-level criterion unclaimed.
-- Each Story carries its **own** \`## Spec\`; a shared \`techspec.md\` cannot be folded into N>1 Stories.
-- Express ordering with \`depends_on\` (a sibling slug, or \`#<id>\` for an open Story from an earlier plan). A Story whose \`verify[]\` runs against a file a sibling creates MUST \`depends_on\` that sibling, so the file exists when verification runs.`;
+Persist runs the **dispatcher's own** collision predicate pairwise over your draft, before it creates a single issue, and **refuses** the plan when any two same-wave Stories collide — both declaring a path in \`changes[]\`, or one declaring a glob that covers the other's path. Such a pair cannot be co-dispatched, so the split buys no parallelism and costs a delivery session. Two remedies, both yours to choose at authoring time:
+
+- **Merge the pair** into the one Story they already are, with \`## Slicing\` checkpoints for the stages; or
+- **Order them** with \`depends_on\` so they sit in different waves, when they genuinely have separate reasons to exist.
+
+Each Story carries its **own** \`## Spec\`; a shared \`techspec.md\` cannot be folded into N>1 Stories. Express ordering with \`depends_on\` (a sibling slug, or \`#<id>\` for an open Story from an earlier plan). A Story whose \`verify[]\` runs against a file a sibling creates MUST \`depends_on\` that sibling, so the file exists when verification runs.`;
+}
+
+/**
+ * The rules that only apply when the seed is an existing ticket (Story
+ * #5323).
+ *
+ * A `--tickets` seed arrives already in Story shape — rendered `AC-<n>:`
+ * checkboxes, a `## Verify` list, a `## Changes` footprint — and an author
+ * reading it as a template carries that shape forward instead of re-deriving
+ * it. The observed failure (swarm-os #2707 / #2708, planned from #2542 under
+ * mandrel 2.57.0) was a Story whose acceptance list was the source's, handles
+ * and all, and whose verify entries carried a tier suffix retired two
+ * releases earlier. The source ticket is **evidence**, not a draft.
+ *
+ * @returns {string}
+ */
+function renderStoryTicketsRules() {
+  return `#### TICKETS-MODE DRAFT — the source ticket is evidence, not a template:
+
+You are planning from one or more existing tickets. Read them for **what the work is** — the problem, the constraints, the commands that verify it — and re-derive everything else. Specifically:
+
+1. **Re-derive \`acceptance[]\` from the goal.** Do not copy the source's \`## Acceptance\` list, and never carry its \`AC-<n>:\` handles — the body renderer numbers the checkboxes itself, so a copied handle renders doubled. A source ticket carrying fifteen criteria is telling you its acceptance was over-specified, not that yours must be: state the outcomes a PR reviewer can confirm, and let the mechanical checks fall to \`verify[]\`.
+2. **A mechanical check is a \`verify[]\` command, not an acceptance item.** "Baselines refreshed", "lint exits 0", "the generated index is regenerated", "the quality gate passes" are commands the deliverer runs and the critic reads as evidence. Carrying them as acceptance items inflates the binding contract with work every close already gates.
+3. **Read the source's \`verify[]\` for the commands it names, not for its shape.** Take the test paths and scripts; drop any trailing tier suffix (\`(unit)\`, \`(contract)\`, \`(e2e)\`, \`(validate)\`) and any \`manual:<reason>\` escape — a verify entry is a bare command.
+4. **Re-derive the footprint against the tree as it is now.** The source ticket's \`## Changes\` predicted a repository that has since moved; probe the paths you cite and omit the generated artifacts it listed.
+5. **Do not carry the source's prose wholesale.** Its current-state narration and per-file walkthroughs are exactly what the SPEC PROSE CONTRACT above forbids. Restate the contract and the invariants; the deliverer reads the code for the rest.`;
 }
 
 /**
@@ -233,3 +266,22 @@ export function renderStoryAuthorPrompt({ storyCount = 1 } = {}) {
   const core = renderStoryAuthorCore();
   return storyCount > 1 ? `${core}\n\n${renderStorySplitRules()}` : core;
 }
+
+/**
+ * The mode-conditional slice of `systemPrompts`.
+ *
+ * `storyTicketsRules` only means anything when the seed is an existing
+ * ticket, and an envelope carrying it in every mode teaches the author to
+ * look for a source ticket a `--seed` run does not have. Returning a
+ * spreadable object rather than a nullable string keeps the decision here,
+ * beside the prompt it selects, instead of as a branch in the envelope
+ * builder.
+ *
+ * @param {string|undefined} mode The plan-context mode.
+ * @returns {{ storyTicketsRules?: string }}
+ */
+export function ticketsModePromptField(mode) {
+  return mode === 'tickets'
+    ? { storyTicketsRules: renderStoryTicketsRules() }
+    : {};
+}

package/.agents/scripts/lib/test-run-credit.js

@@ -1,15 +1,23 @@
 /**
- * lib/test-run-credit.js — let a green bare `npm test` earn the credit close
- * reads (Story #5313).
+ * lib/test-run-credit.js — let a green `npm test` **that routes through
+ * mandrel's own runner** earn the credit close reads (Story #5313, scoped by
+ * Story #5324).
  *
- * Until this module the only suite run that deposited credit was the one
- * shaped exactly like the close gate — `coverage-capture.js --cwd <worktree>`
- * or `evidence-gate.js --standalone … -- npm test` — and the digest, the
- * worker boot context and the reference all carried prose explaining which
- * invocation to type. A worker that ran the project's own test runner paid
- * for the suite and then close paid for it again. The runner is the natural
- * depositor: it knows the tree it ran against, whether the run was green,
- * and whether it ran the whole suite.
+ * This is a **bonus, not the contract.** The deposit every project can rely
+ * on is `evidence-gate.js --standalone --scope-id <id> --gate test --worktree
+ * <workCwd> -- npm test`: it spawns whatever `npm test` resolves to and
+ * stamps what it just ran, so it is honest on any runner. What this module
+ * adds is that a repo whose `test` script *is* `run-tests.js` need not type
+ * that wrapper — the runner already knows the tree it ran against, whether
+ * the run was green, and whether it ran the whole suite, so it deposits on
+ * the way out.
+ *
+ * The reach is therefore exactly one call site: `run-tests.js`. A consumer
+ * whose `npm test` is `vitest run` or `jest` never loads this module, so it
+ * deposits nothing **and prints nothing** — silence is not a signal, and no
+ * delivery surface may tell an agent to confirm credit by reading for the
+ * line below. `mandrel doctor`'s `test-credit-path` check reports which of
+ * the two shapes a project is and names the wrapper as the remedy.
  *
  * On a green **full-tier** run inside a `story-<id>` checkout the runner
  * records the `test` gate's evidence in the same keyspace
@@ -143,8 +151,11 @@ export function depositTestRunCredit({
 }
 
 /**
- * Deposit and say so on stderr — the runner's one-line hook. The line is
- * the only surface a worker sees, so it names the outcome by reason.
+ * Deposit and say so on stderr — the runner's one-line hook, printed only
+ * when this runner is the one running. It names the outcome by reason, so a
+ * green run that deposited nothing (wrong branch, partial tier) says so
+ * rather than passing silently; a project on another runner prints no line
+ * at all, which is why absence of this line is never evidence either way.
  *
  * @param {Parameters<typeof depositTestRunCredit>[0] & { log?: (line: string) => void }} args
  * @returns {ReturnType<typeof depositTestRunCredit>}

package/.agents/scripts/plan-persist.js

@@ -29,7 +29,6 @@
  *   --plan-context <file>     Optional explicit path to the `plan-context.js`
  *                             envelope. Its `sourceTickets[]` is what makes
  *                             `--tickets` superseding work without a flag
- *   --plan-acceptance <file>  Optional JSON string[] for partition coverage
  *   --source-tickets <ids>    Explicit OVERRIDE of the envelope-derived source
  *                             ids, for hand-driven runs. Each id must be
  *                             claimed by exactly one Story's `supersedes[]`;
@@ -106,7 +105,6 @@ const CLI_OPTIONS = {
   'tech-spec': { type: 'string' },
   'plan-dir': { type: 'string' },
   'plan-context': { type: 'string' },
-  'plan-acceptance': { type: 'string' },
   'source-tickets': { type: 'string' },
   'close-superseded': { type: 'boolean', default: true },
   'no-close-superseded': { type: 'boolean', default: false },
@@ -121,7 +119,6 @@ const CLI_OPTIONS = {
 const USAGE =
   'Usage: plan-persist.js --stories <file> ' +
   '[--tech-spec <file>] [--plan-dir <dir>] [--plan-context <file>] ' +
-  '[--plan-acceptance <file>] ' +
   '[--source-tickets <ids>] [--no-close-superseded] ' +
   '[--dry-run] [--chain-on-clean] [--force-review] ' +
   '[--epic-title <text> --epic-goal <text> | --epic <id>]';
@@ -159,9 +156,6 @@ export function resolveInputPaths(values) {
     techSpecPath: values['tech-spec']
       ? path.resolve(values['tech-spec'])
       : null,
-    planAcceptancePath: values['plan-acceptance']
-      ? path.resolve(values['plan-acceptance'])
-      : null,
     planDir,
     planContextPath: resolvePlanContextPath(values['plan-context'], planDir),
   };
@@ -172,9 +166,6 @@ async function loadArtifacts(paths) {
   const techSpecContent = paths.techSpecPath
     ? await readOptional(paths.techSpecPath, { required: true })
     : null;
-  const planAcceptance = paths.planAcceptancePath
-    ? await readJsonFile(paths.planAcceptancePath, 'plan-acceptance')
-    : null;
   const planContextEnvelope = await loadPlanContextEnvelope(
     paths.planContextPath,
   );
@@ -182,7 +173,6 @@ async function loadArtifacts(paths) {
   return {
     stories,
     techSpecContent,
-    planAcceptance,
     planContextEnvelope,
   };
 }
@@ -501,7 +491,6 @@ runAsCli(import.meta.url, main, {
         '--plan-context <file>',
         'The plan-context envelope this draft was authored against.',
       ],
-      ['--plan-acceptance <file>', 'Acceptance artifact to attach.'],
       ['--source-tickets <ids>', 'Ticket ids this plan supersedes.'],
       ['--dry-run', 'Validate and report; create nothing.'],
       ['--chain-on-clean', 'Persist immediately when the dry run is clean.'],

package/.agents/skills/skills.index.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-09-06T12:59:23.069Z",
+  "generatedAt": "2026-09-14T11:57:26.498Z",
   "generator": "generate-skills-index.js@1",
   "skills": [
     {
@@ -52,16 +52,6 @@
       "allowedTools": null,
       "vendor": null
     },
-    {
-      "name": "scope-triage",
-      "tier": "core",
-      "category": "core",
-      "path": ".agents/skills/core/scope-triage/SKILL.md",
-      "description": "Optional split-advisory for `/mandrel-plan`. Under v2 there is no epic|story routing verdict — `/mandrel-plan` always authors Stories. Use this skill only when judging whether a draft should stay one Story or legitimately split (near-zero overlap or an architectural seam).",
-      "policyCapsuleBullets": 5,
-      "allowedTools": null,
-      "vendor": null
-    },
     {
       "name": "security-and-hardening",
       "tier": "core",

package/.agents/workflows/audit-to-stories.md

@@ -152,15 +152,17 @@ node .agents/scripts/audit-to-stories.js --emit-plan-seed \
 
 The seed renders the canonical one-pager sections — Problem Statement,
 Recommended Direction, Key Assumptions (with links to every source
-report), MVP Scope (the M proposed Stories), Key Files (so `/mandrel-plan`'s
-authoring step has concrete anchors), Grouping, Not Doing.
-
-**Grouping is the container-Epic directive.** Above 2 proposed Stories the
-seed instructs `/mandrel-plan` to group them under one Epic — a sweep is the
-clearest case for a container, since every Story shares a provenance and an
-operator usually delivers them together. It is a directive in the text, not an
-automatic write: Phase 4 above is where an operator declines it. Below the
-threshold the section says so and asks for nothing.
+report), MVP Scope (**the findings, flat**), Key Files (so `/mandrel-plan`'s
+authoring step has concrete anchors), Not Doing.
+
+**The seed states findings, not a partition.** MVP Scope used
+to render one numbered bullet per group beneath a `## Grouping` container
+directive — a plan the seed had already decided, at the grouping grain, before
+`/mandrel-plan` read a word of it. N now reaches the planner **undecided**: it
+applies its own cohesion judgment, and container grouping is `/mandrel-plan`'s
+Gate #3 call at persist, where N is known. The grouping still drives the
+**standalone-Stories** path (Phase 5b), which needs one issue payload per
+group.
 
 Chain into the existing planning entrypoint:
 
@@ -172,9 +174,10 @@ Chain into the existing planning entrypoint:
 then runs its author → persist path, as documented in its workflow.
 
 **Dedup provenance is carried mechanically — do not hand-copy it.** The seed's
-MVP Scope bullets carry each group's `audit-fingerprints` and
+MVP Scope section carries each group's `audit-fingerprints` and
 `audit-semantic-keys` footers as HTML comments (invisible in the rendered
-one-pager). `plan-persist` harvests them out of the seed on the
+one-pager, and per-group even though the visible list is flat — they are the
+identity the next sweep matches on). `plan-persist` harvests them out of the seed on the
 `plan-context.json` envelope and appends them to **every** Story body it
 persists, via `carryProvenanceFooters`
 ([`lib/findings/route-finding.js`](../scripts/lib/findings/route-finding.js)).

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

@@ -94,26 +94,33 @@ whose `criteria[]` length differs **before** scoring, consuming no round;
 not close**: post a `friction` comment and flip `agent::blocked`.
 Per-round mechanics: [`acceptance-self-eval.md`](acceptance-self-eval.md).
 
-## 5. The one full-suite run
+## 5. The one credited suite run
 
-After the self-eval loop's last fix commit, run the project test runner
-**once** in the worktree:
+After the self-eval loop's last fix commit, run the suite **once** in the
+worktree through the depositor — it spawns the project's own `npm test`,
+whatever that resolves to, and stamps the result, so any runner earns the
+credit:
 
 ```bash
-npm test   # in <workCwd>
+node <main-repo>/.agents/scripts/evidence-gate.js --standalone \
+  --scope-id <storyId> --gate test --worktree <workCwd> -- npm test
 ```
 
-A green full run on `story-<id>` deposits the `test` evidence close reads,
-keyed on the tree, so close reports the gate as **credited** at unchanged
-HEAD — a later commit voids it. The CRAP gate still captures coverage itself
-when it needs an artifact. If the suite outruns the host's sync Bash
-ceiling, dispatch it in the **background** — its completion re-invokes you;
-never spawn a task to poll or `sleep`-loop against it
-([`parallel-tooling.md`](parallel-tooling.md) Rule 2). Read the **output**,
-not the exit code: the runner prints whether it deposited credit, and a run
-off the Story branch or of a partial tier deposits nothing and says so.
-Redraft rounds run the scoped projects for the roots you changed plus
-`verify[]`, not the whole suite; only this run needs credit.
+Green deposits the `test` evidence close reads, keyed on the tree, so close
+reports the gate as **credited** at unchanged HEAD — a later commit voids it.
+Read its **output**, not the exit code: `✓ test passed` is the signal. The
+CRAP gate still captures coverage itself when it needs an artifact.
+
+A bare `npm test` earns the same credit **only** where the project's test
+script routes through mandrel's own runner, which prints the outcome. On any
+other runner it deposits nothing and prints nothing, so silence is never
+evidence of credit; `mandrel doctor`'s `test-credit-path` check names which
+shape this project is. If the suite outruns the host's sync Bash ceiling,
+dispatch it in the **background** — its completion re-invokes you; never spawn
+a task to poll or `sleep`-loop against it
+([`parallel-tooling.md`](parallel-tooling.md) Rule 2). Redraft rounds run the
+scoped projects for the roots you changed plus `verify[]`, not the whole
+suite; only this run needs credit.
 
 `verify[]` is scoped entries **plus** this one run: an entry that is itself a
 full-suite command is reported credited against the same record, never

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

@@ -237,17 +237,37 @@ 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, so close can credit it.** The run belongs **after** the
-self-eval loop's last fix commit; redraft rounds run scoped tests. A green
-`npm test` in the worktree on `story-<id>` deposits the `test` evidence
-record close reads (Story #5313 — `lib/test-run-credit.js`), 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 a bare `npm test` does not produce.
+**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

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

@@ -93,12 +93,13 @@ 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.
 
-### Step 2.5 — The one full-suite run, the push, then hand off
+### Step 2.5 — The one credited suite run, the push, then hand off
 
-After the self-eval loop's last fix commit, run `npm test` **once** in the
-worktree (**digest § 5**): a green full run deposits the `test` credit close
-reads, keyed on the tree, so only a *later* commit invalidates it. Red →
-fix, commit, re-run.
+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.
 
 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

@@ -47,10 +47,20 @@ The spine's two escape hatches from N=1 are narrow on purpose:
   sitting unverifiable behind the other.
 
 Everything else is one Story with `## Slicing` checkpoints. When N>1 does
-apply, **every acceptance criterion belongs to exactly one Story** —
-`assertAcceptancePartition` refuses a split whose criteria repeat across
-siblings, because a verbatim-shared criterion is the signature of coupled work
-cut in half rather than genuinely separable work.
+apply, the split has to survive the **same-wave collision refusal**: persist
+runs the dispatcher's own `detectCollision` pairwise over the draft, ahead of
+the first `createIssue`, and refuses any pair of same-wave siblings that both
+declare a path (or one of which declares a covering glob) — naming the pair,
+the paths and the two remedies (merge them, or order them with `depends_on`).
+Such a pair cannot be co-dispatched, so the split buys no parallelism and
+costs a delivery session per Story. It replaced the acceptance partition,
+which refused only byte-identical acceptance text across siblings — a shape
+model output does not produce — so it never fired on the fragmentation it was
+meant to catch. **N=1 can never trip the refusal.**
+
+A draft of more than one Story also stops at **Gate #2** for operator
+approval, `--force-review` or not: a split always earns eyes. `--yes`
+auto-proceeds, as at every other gate.
 
 ## Unknown triage — AFK vs HITL
 
@@ -154,6 +164,11 @@ and ceremony is derived from the landed diff at close.
 - **`verify[]` entries are commands.** There is no tier suffix and no
   `manual:<reason>` escape (Story #5312): write the exact command or test
   path the deliverer runs and the acceptance critic reads as evidence.
+- **`changes[]` names what the deliverer authors.** Generated artifacts —
+  quality baselines, generated test indexes, migration journals, lockfiles —
+  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
@@ -175,8 +190,14 @@ kept — passes the persist ticket validators with no round-trip.
 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[]` (`… (unit|contract|e2e|validate)`), and
-`depends_on[]` (a sibling slug, or `#<id>` for an existing open Story).
+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
+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
@@ -238,8 +259,9 @@ The conflict passes run **twice**: once over the raw `stories.json` payload
 The second pass is not belt-and-braces. The canonical authoring shape carries
 `acceptance[]` / `verify[]` at the ticket's top level and assembly folds them
 into the body, so the passes that scan `body.acceptance` / `body.verify`
-(`implicit-cross-story-dep`, `missing-bdd-scaffold`) saw two empty arrays on
-the real payload and emitted nothing. Both passes complete before the first
+saw two empty arrays on the real payload and emitted nothing; the two
+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,
@@ -256,6 +278,21 @@ and a path reference matched by substring can read as a dependency a prose
 mention never meant. A finding names the Stories and the fix (a `depends_on`
 edge, or folding the shared edit into one Story) for the operator to weigh.
 
+## Tickets mode — the source ticket is evidence
+
+A `--tickets` envelope carries a third author prompt beside
+`systemPrompts.story` and `systemPrompts.storySplitRules`:
+**`systemPrompts.storyTicketsRules`**. It exists because a
+source ticket arrives already in Story shape — rendered `AC-<n>:` checkboxes,
+a `## Verify` list, a `## Changes` footprint — and an author reading it as a
+template carries that shape forward instead of re-deriving it. The addendum
+binds the author to re-derive `acceptance[]` from the goal, to express
+mechanical checks (a refreshed baseline, a lint exiting 0, a regenerated
+index) as `verify[]` commands rather than acceptance items, and to take the
+source's verify entries for the commands they name rather than their shape.
+Read it whenever the mode is `tickets`; the other three modes do not carry
+the field.
+
 ## Tickets mode — authoring `supersedes[]`
 
 In `--tickets` mode each Story carries a top-level `supersedes` array claiming
@@ -282,7 +319,7 @@ template-only prose.
 ### Supersede-map partition
 
 `plan-persist` refuses a partial supersede map **before** it creates any
-Story (mirroring `assertAcceptancePartition`): every id passed to
+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
@@ -347,10 +384,13 @@ at base.
 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, and an `open-question` in a body (`Flag if…`, `TBD`, a trailing
-`?`). The list also names every `changes[]` **repair** the run applied — a
-plain-string bullet or a trailing parenthetical rewritten into
-`{ path, assumption }` by probing base. The same list rides the result
+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.