mandrel 2.58.0 → 2.59.0

package/.agents/scripts/lib/runtime-deps/parser-major.js

@@ -0,0 +1,110 @@
+/**
+ * runtime-deps/parser-major — which `@babel/parser` major the complexity
+ * kernel can actually parse with, and how to say so when it is wrong.
+ *
+ * Its own module because two very different callers need the same answer and
+ * neither should drag the other in: the kernel asserts it at load, and
+ * `mandrel doctor` reports it to a consumer. Importing the kernel into doctor
+ * to ask one version question would pull the whole metric core and install the
+ * AST compatibility patch as a side effect.
+ *
+ * `.agents/` materializes into the consumer's repository root, so
+ * `@babel/parser` resolves from *their* `node_modules`. A range in
+ * `runtime-deps.json` documents the requirement; it cannot enforce it. This is
+ * the enforcement.
+ *
+ * @module lib/runtime-deps/parser-major
+ */
+
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+
+/**
+ * The only `@babel/parser` major the kernel supports.
+ *
+ * Module-local, with `describeParserMajorError` as the single public door:
+ * every caller wants the verdict and the remedy, not the number.
+ *
+ * 8.x removed several plugin names from the kernel's fixed list (they became
+ * default syntax), so it does not merely warn — it throws on the plugin list
+ * itself. Adopting it is a deliberate change with a baseline recut attached,
+ * not something to absorb from a consumer's resolution.
+ */
+const SUPPORTED_PARSER_MAJOR = 7;
+
+/** Package whose resolved major gates the kernel. */
+const PARSER_PACKAGE = '@babel/parser';
+
+/** Memoised resolved parser version: `undefined` unread, `null` unresolvable. */
+let parserVersion;
+
+/**
+ * Read the resolved `@babel/parser` version from its own manifest.
+ *
+ * The package exports no version, so its `package.json` is the only source.
+ * This is the one non-static resolution in the file and it deliberately
+ * targets a manifest rather than code: `@babel/parser` itself is reached by a
+ * static import above, so it is declared and preflighted like every other
+ * dependency.
+ *
+ * @returns {string|null} The resolved version, or `null` when the manifest
+ *   cannot be read (a layout that hides `package.json` behind `exports`, say).
+ */
+function resolveParserVersion() {
+  if (parserVersion !== undefined) return parserVersion;
+  try {
+    const require = createRequire(import.meta.url);
+    const manifest = require.resolve(`${PARSER_PACKAGE}/package.json`);
+    const parsed = JSON.parse(fs.readFileSync(manifest, 'utf-8'));
+    parserVersion = typeof parsed?.version === 'string' ? parsed.version : null;
+  } catch {
+    parserVersion = null;
+  }
+  return parserVersion;
+}
+
+/**
+ * The resolved parser's major version.
+ *
+ * @returns {number|null} `null` when the version could not be resolved or
+ *   does not lead with an integer.
+ */
+function resolveParserMajor() {
+  const version = resolveParserVersion();
+  if (version === null) return null;
+  const major = Number.parseInt(version, 10);
+  return Number.isInteger(major) ? major : null;
+}
+
+/**
+ * Describe the resolved-parser problem, if there is one.
+ *
+ * Single-sourced so the load-time assertion below and the preflight guard
+ * (`runtime-deps/ensure-installed.js`) emit the *same* named, actionable
+ * message — the point of AC-5 is that a consumer never meets this as a
+ * plugin-list syntax error mid-scan.
+ *
+ * An unresolvable version is **not** a problem: a consumer layout that hides
+ * the manifest still resolves the parser itself, and refusing to score would
+ * be a worse answer than scoring with an unverified parser. Only a
+ * *known-wrong* major is reported.
+ *
+ * @param {{major?: number|null, version?: string|null}} [resolved] Overrides
+ *   the resolved parser, so the message a consumer on an unsupported major
+ *   would read is assertable without installing one.
+ * @returns {string|null} The message, or `null` when the resolved parser is
+ *   supported (or its version is unknowable).
+ */
+export function describeParserMajorError(resolved = {}) {
+  const { major = resolveParserMajor(), version = resolveParserVersion() } =
+    resolved;
+  if (major === null || major === SUPPORTED_PARSER_MAJOR) return null;
+  return (
+    `unsupported ${PARSER_PACKAGE} major: resolved ${version}, ` +
+    `the complexity kernel requires ${SUPPORTED_PARSER_MAJOR}.x. It parses ` +
+    `with a fixed plugin list that later majors reject, so CRAP and ` +
+    `maintainability scoring would fail mid-scan with an opaque plugin-list ` +
+    `error. Declare "${PARSER_PACKAGE}": "^${SUPPORTED_PARSER_MAJOR}" in ` +
+    `your package.json (see .agents/runtime-deps.json).`
+  );
+}

package/.agents/scripts/lib/runtime-deps/preflight.js

@@ -1,9 +1,11 @@
 /**
- * runtime-deps/preflight — pure helpers for the dependency-presence check.
+ * runtime-deps/preflight — pure helpers for the dependency-presence check's
+ * *messaging* half.
  *
- * These functions hold no side effects so they are unit-testable in
- * isolation: `checkRuntimeDeps` takes an injected `resolve` seam,
- * `detectPackageManager` takes an injected `exists` seam, and
+ * The check itself moved to `dep-resolution.js`, which owns resolving a
+ * declared dependency, judging its major, and explaining a mismatch. What is
+ * left here holds no side effects and stays unit-testable in isolation:
+ * `detectPackageManager` takes an injected `exists` seam and
  * `formatMissingDepsMessage` is a pure string builder. The side-effecting
  * guard that wires them to the real process lives in `ensure-installed.js`.
  *
@@ -14,27 +16,6 @@
 import fs from 'node:fs';
 import { detectPackageManager as detectPm } from '../detect-package-manager.js';
 
-/**
- * Resolve each required package via the injected `resolve` seam and collect
- * the ones that fail. `resolve` is typically `require.resolve` bound to the
- * framework module location; it throws `MODULE_NOT_FOUND` when a package is
- * absent from the resolvable `node_modules`.
- *
- * @param {{ required: string[], resolve: (specifier: string) => string }} opts
- * @returns {{ ok: boolean, missing: string[] }}
- */
-export function checkRuntimeDeps({ required, resolve }) {
-  const missing = [];
-  for (const dep of required) {
-    try {
-      resolve(dep);
-    } catch {
-      missing.push(dep);
-    }
-  }
-  return { ok: missing.length === 0, missing };
-}
-
 /**
  * Detect the consumer's package manager from lockfile presence so the
  * remediation message names the right install command. Defaults to `npm`.

package/.agents/scripts/lib/runtime-deps/scan-imports.js

@@ -71,6 +71,51 @@ const STATIC_FROM =
 const SIDE_EFFECT = /^\s*import\s*['"]([^'"]+)['"]/gm;
 // `require(...)` and dynamic `import(...)` may appear mid-expression.
 const CALL_FORM = /\b(?:require|import)\s*\(\s*['"]([^'"]+)['"]/g;
+// Names bound to a `createRequire(...)` result, e.g.
+// `const fromReader = createRequire(x)`. Such a binding is a require function
+// under a different name, so calls through it are real runtime imports that
+// `CALL_FORM` cannot see — it matches the literal callees `require`/`import`.
+// A module reached only that way would be an undeclared, unpreflighted
+// dependency that this scanner reported as absent.
+const REQUIRE_ALIAS =
+  /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*createRequire\s*\(/g;
+
+/**
+ * Build a matcher for calls through `createRequire`-bound identifiers.
+ *
+ * Returns `null` when the source binds none, so the common case adds no pass.
+ * Aliases named `require` need no entry — `CALL_FORM` already covers them.
+ *
+ * @param {string} cleaned Comment-stripped source.
+ * @returns {RegExp|null}
+ */
+function aliasedRequireMatcher(cleaned) {
+  REQUIRE_ALIAS.lastIndex = 0;
+  const names = new Set();
+  let m = REQUIRE_ALIAS.exec(cleaned);
+  while (m !== null) {
+    if (m[1] !== 'require') names.add(m[1]);
+    m = REQUIRE_ALIAS.exec(cleaned);
+  }
+  if (names.size === 0) return null;
+  const alternation = [...names]
+    .map((n) => n.replace(/[$]/g, '\\$$'))
+    .join('|');
+  return new RegExp(`\\b(?:${alternation})\\s*\\(\\s*['"]([^'"]+)['"]`, 'g');
+}
+
+/**
+ * The specifier patterns to run over one source: the three fixed forms, plus
+ * an alias matcher when the source binds a `createRequire` result.
+ *
+ * @param {string} cleaned Comment-stripped source.
+ * @returns {RegExp[]}
+ */
+function specifierMatchers(cleaned) {
+  const aliased = aliasedRequireMatcher(cleaned);
+  if (!aliased) return [STATIC_FROM, SIDE_EFFECT, CALL_FORM];
+  return [STATIC_FROM, SIDE_EFFECT, CALL_FORM, aliased];
+}
 
 /**
  * Extract the set of third-party top-level package names imported by a
@@ -82,7 +127,7 @@ const CALL_FORM = /\b(?:require|import)\s*\(\s*['"]([^'"]+)['"]/g;
 export function extractThirdPartyImports(source) {
   const found = new Set();
   const cleaned = stripJsComments(source);
-  for (const re of [STATIC_FROM, SIDE_EFFECT, CALL_FORM]) {
+  for (const re of specifierMatchers(cleaned)) {
     re.lastIndex = 0;
     let match = re.exec(cleaned);
     while (match !== null) {

package/.agents/scripts/lib/skills/walk-skill-files.js

@@ -41,7 +41,7 @@ export const LOCAL_SKILLS_SEGMENTS = Object.freeze([
 
 /**
  * A skill id is the tier-relative path naming a skill — e.g.
- * `core/scope-triage` or `stack/qa/playwright`. It is the value that
+ * `core/test-first` or `stack/qa/playwright`. It is the value that
  * appears in `skills.index.json` minus the root prefix, and the value a
  * `qa.environments.*.signInSeam.skill` seam carries.
  *

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

@@ -24,10 +24,11 @@ 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.
@@ -135,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.
+- **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). 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".
+- **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.
@@ -171,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):
 
@@ -201,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}
  */
@@ -213,16 +214,18 @@ 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.`;
 }
 
 /**
@@ -244,7 +247,7 @@ function renderStoryTicketsRules() {
 
 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 three to six outcomes a PR reviewer can confirm, and let the rest fall to \`verify[]\`.
+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.

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/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
 
@@ -249,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,
@@ -308,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

package/.agents/workflows/mandrel-plan.md

@@ -11,7 +11,7 @@ description:
 
 ## Inputs
 
-Single planning path — there is no Epic/Story router, no scope-triage
+Single planning path — there is no Epic/Story router, no split-triage
 `epic|story` verdict (Gate #3's container groups, never routes). **Derive the
 mode from what the operator typed, announce it, act**:
 
@@ -93,12 +93,11 @@ included. One rescue: a **never-tracked** one normalises to `creates`. Fields:
 [ref](helpers/plan-reference.md).
 
 Artifacts under `temp/plan-<slug>/`: `stories.json` (**length 1 by default**;
-a Spec is as long as the work needs, inline, never under `docs/`); optional
-`techspec.md` (**N===1 only**, folded into `## Spec`) and
-`acceptance-manifest.json` (N>1 — `--plan-acceptance`). Use the envelope
+a Spec is as long as the work needs, inline, never under `docs/`) and optional
+`techspec.md` (**N===1 only**, folded into `## Spec`). Use the envelope
 `systemPrompts.story`; split only under the policy above, and when you do,
-read `systemPrompts.storySplitRules` too — it carries the schedule and
-partition rules the core omits. In **tickets mode** also read
+read `systemPrompts.storySplitRules` too — it carries the schedule rules and
+the same-wave collision refusal the core omits. In **tickets mode** also read
 `systemPrompts.storyTicketsRules`: the source ticket is evidence, not a
 template — re-derive `acceptance[]` rather than carrying its list, handles
 and tier suffixes forward.
@@ -112,15 +111,20 @@ The maker-blind **pre-mortem** critic is not a step of this spine: run
 
 ### 3. Persist
 
-**Gate #2** — STOP for approval before persist **only** when the operator asked
-to review (`--force-review`). Under `--yes`, auto-proceed.
+**Gate #2** — STOP for approval before persist when the draft carries **more
+than one Story** (a split always earns operator eyes, `--force-review` or
+not), or when the operator asked to review (`--force-review`).
+Under `--yes`, auto-proceed.
 
 **Gate #3 — adopt, else create.** Offer the top `epicCandidates[]` Epic at
 **any N** (`--epic <id>`); else, at **N>2**, a new container (`--epic-title` /
 `--epic-goal`). Never unasked ([ref](helpers/plan-reference.md)).
 
 Run persist `--dry-run` **first** — same command, writes suppressed; every gate
-runs before the first `createIssue`, and the run **lists its warnings**
+runs before the first `createIssue` — including the **same-wave collision
+refusal**, which rejects an N>1 draft whose siblings declare a common path
+(merge them, or order them with `depends_on`) — and the run **lists its
+warnings**
 (a `creates` / `refactors-existing` the base branch disagrees with, a goal or
 acceptance path absent at base, an open question in a body) and the
 `changes[]` repairs it applied ([list](helpers/plan-reference.md)). Read
@@ -130,7 +134,6 @@ them; they never stop the persist:
 node .agents/scripts/plan-persist.js \
   --stories temp/plan-<slug>/stories.json \
   --plan-dir temp/plan-<slug> \
-  [--plan-acceptance temp/plan-<slug>/acceptance-manifest.json] \
   [--tech-spec temp/plan-<slug>/techspec.md] \
   [--source-tickets 123,456] \
   [--epic <id> | --epic-title "<name>" --epic-goal "<one paragraph>"]
@@ -158,6 +161,4 @@ also comments on and closes each source id ([ref](helpers/plan-reference.md)).
 ## See also
 
 [`/mandrel-deliver`](mandrel-deliver.md), [`/audit-to-stories`](audit-to-stories.md),
-[`helpers/plan-reference.md`](helpers/plan-reference.md) (on-demand detail),
-[`core/scope-triage`](../skills/core/scope-triage/SKILL.md) — optional
-split-advisory notes only (no routing verdict).
+[`helpers/plan-reference.md`](helpers/plan-reference.md) (on-demand detail).

package/README.md

@@ -86,9 +86,9 @@ time to confirm the install is healthy.
 >
 > Prefer a surgical alternative? Replace `shamefully-hoist` with a scoped
 > `public-hoist-pattern[]=` line per package listed in
-> `.agents/runtime-deps.json` (`ajv`, `ajv-formats`, `js-yaml`, `minimatch`,
-> `picomatch`, `typhonjs-escomplex`). If `mandrel doctor`
-> reports `runtime-deps missing: …`, this is the fix.
+> `.agents/runtime-deps.json` — read the file rather than copying a list from
+> here, since the complexity kernel's closure is several packages. If
+> `mandrel doctor` reports `runtime-deps missing: …`, this is the fix.
 
 `bootstrap.js` is interactive on a TTY and auto-accepts the
 owner/repo/base branch/operator handle it can infer from your local

package/docs/CHANGELOG.md

@@ -15,6 +15,14 @@ All notable changes to this project will be documented in this file.
 -->
 <!-- markdownlint-disable-file MD004 MD012 MD037 -->
 
+## [2.59.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.58.0...mandrel-v2.59.0) (2026-09-14)
+
+
+### Added
+
+* planning stops fragmenting cohesive work: the acceptance band goes, the dispatcher's own collision predicate becomes the split gate, and the audit seed stops pre-cutting the partition ([#5332](https://github.com/dsj1984/mandrel/issues/5332)) ([#5334](https://github.com/dsj1984/mandrel/issues/5334)) ([e6408e4](https://github.com/dsj1984/mandrel/commit/e6408e44d3f9a7fcbdf8c9a7df4a1b68fdffd88b))
+* replace the complexity kernel's parse and dispatch layers and declare the runtime closure it leaves behind, so the framework's dependency guards describe what actually loads ([#5336](https://github.com/dsj1984/mandrel/issues/5336)) ([#5337](https://github.com/dsj1984/mandrel/issues/5337)) ([821c4f5](https://github.com/dsj1984/mandrel/commit/821c4f55fe3fe9b91b83a4ef9fe9ddee5da9db8f))
+
 ## [2.58.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.57.0...mandrel-v2.58.0) (2026-09-12)