mandrel 2.58.0 → 2.59.0

package/.agents/scripts/lib/escomplex-kernel.js

@@ -0,0 +1,298 @@
+/**
+ * escomplex-kernel.js — the complexity kernel's parse and dispatch layers,
+ * in-repo.
+ *
+ * ## Why this file exists
+ *
+ * `typhonjs-escomplex` was a thin shell around four packages that do all the
+ * actual work. The shell contributed two things: a parser front-end
+ * (`@typhonjs/babel-parser`, a ~100-LOC shim over `@babel/parser`) and a
+ * generic plugin bus (`typhonjs-plugin-manager`, used as a hardcoded
+ * two-plugin synchronous dispatcher). Nine packages of plumbing hang off
+ * those two, and none of it computes anything.
+ *
+ * What this does **not** do is remove `core-js@2`. Four of the retained
+ * metric-core packages `require('babel-runtime/core-js/*')` themselves, so it
+ * is load-bearing for the code that stays; a change that claimed otherwise
+ * would be unshippable. What it buys instead is an honest closure —
+ * `babel-runtime` is required by those packages and declared by none of them,
+ * so today it resolves only because the removed plumbing hoists it. Declaring
+ * it turns an accident into a contract.
+ *
+ * This module reimplements exactly those two layers over the retained metric
+ * core — `typhonjs-escomplex-commons`, `escomplex-plugin-metrics-module`,
+ * `escomplex-plugin-syntax-babylon`, `typhonjs-ast-walker` — which compute
+ * every score. Nothing here computes a metric; the scores come from the same
+ * packages as before, which is why they do not move.
+ *
+ * ## The equivalence contract
+ *
+ * Reproducing the displaced shell's *behaviour* means reproducing three
+ * details it never documented:
+ *
+ * 1. **The parser's fixed plugin list**, verbatim and in order, with
+ *    `sourceType: 'unambiguous'` — see `PARSER_PLUGINS` below. The list is
+ *    what makes a `.ts` file, a decorator or a pipeline operator parse at
+ *    all, and `unambiguous` is what lets a CommonJS script and an ES module
+ *    both score.
+ * 2. **Both plugin instances, in registration order** — syntax first, then
+ *    metrics. The metrics plugin reads trait tables the syntax plugin put on
+ *    the event.
+ * 3. **One mutable event object per dispatch**, threaded through every plugin
+ *    in turn, with the caller reading the mutations back off it. The displaced
+ *    bus also stamped `$$plugin_invoke_count` / `$$plugin_invoke_names` onto
+ *    every event's data; no plugin and no report reads them, so they are not
+ *    reproduced.
+ *
+ * Equivalence is not asserted by reasoning: `tests/lib/escomplex-kernel.test.js`
+ * replays a corpus captured under the displaced kernel *before* it left the
+ * tree (`tests/fixtures/escomplex-kernel-parity/`), because afterwards there is
+ * nothing left to compare against.
+ *
+ * ## The one uncontrolled input
+ *
+ * `.agents/` materializes into a consumer's repository root, so `@babel/parser`
+ * resolves from **their** `node_modules`. The preflight guard checks presence,
+ * not range, and `@babel/parser@8` is GA and rejects several names in the
+ * fixed plugin list. A manifest range documents the requirement; it does not
+ * enforce it. So the resolved major is asserted here, at load, with an error
+ * that names the problem — rather than surfacing as an opaque plugin-list
+ * syntax error partway through a scan.
+ */
+
+// Every metric-core package is reached by a STATIC import specifier with an
+// explicit `.js` extension. That is not style: `tests/scripts/
+// runtime-deps-drift.test.js` scans for literal `import`/`require` callees, so
+// a package reached through an aliased `createRequire` would be a runtime
+// dependency that is neither declared nor preflighted. The extensions are
+// mandatory because `typhonjs-escomplex-commons` ships an empty
+// `package.json` — no `main`, no `exports` — so a deep path is the only door.
+import { parse as babelParse } from '@babel/parser';
+import PluginMetricsModule from 'escomplex-plugin-metrics-module/dist/PluginMetricsModule.js';
+import PluginSyntaxBabylon from 'escomplex-plugin-syntax-babylon/dist/PluginSyntaxBabylon.js';
+import ASTWalker from 'typhonjs-ast-walker/dist/ASTWalker.js';
+import ModuleScopeControl from 'typhonjs-escomplex-commons/dist/module/report/control/ModuleScopeControl.js';
+import ModuleReport from 'typhonjs-escomplex-commons/dist/module/report/ModuleReport.js';
+import { install as installAstCompat } from './escomplex-ast-compat.js';
+import { describeParserMajorError } from './runtime-deps/parser-major.js';
+
+/**
+ * The displaced parser shim's plugin list, verbatim and in order.
+ *
+ * Order is preserved because it is cheap to preserve, not because a
+ * reordering is known to matter. The two entries with options
+ * (`decorators`, `pipelineOperator`) carry the shim's exact settings —
+ * `decoratorsBeforeExport: false` and the `minimal` pipeline proposal — which
+ * decide whether decorated classes and `|>` parse. Re-cloned per parse so a
+ * parser that mutated its options could not poison a later call.
+ */
+const PARSER_PLUGINS = [
+  'asyncGenerators',
+  'bigInt',
+  'classProperties',
+  'classPrivateProperties',
+  'classPrivateMethods',
+  ['decorators', { decoratorsBeforeExport: false }],
+  'doExpressions',
+  'dynamicImport',
+  'exportDefaultFrom',
+  'exportNamespaceFrom',
+  'functionBind',
+  'functionSent',
+  'importMeta',
+  'jsx',
+  'logicalAssignment',
+  'nullishCoalescingOperator',
+  'numericSeparator',
+  'objectRestSpread',
+  'optionalCatchBinding',
+  'optionalChaining',
+  ['pipelineOperator', { proposal: 'minimal' }],
+  'throwExpressions',
+  'typescript',
+];
+
+/**
+ * The two plugins, in registration order: syntax populates the trait tables
+ * the metrics plugin then reads. Neither defines `onPluginLoad`, and the
+ * displaced bus was constructed without an eventbus, so there is no plugin
+ * lifecycle or eventbus coupling to reproduce — only this list.
+ */
+const PLUGINS = [
+  ['escomplex-plugin-syntax-babylon', new PluginSyntaxBabylon()],
+  ['escomplex-plugin-metrics-module', new PluginMetricsModule()],
+];
+
+// The kernel's code generator predates the Babel AST its own parser emits, so
+// ordinary modern syntax aborts a WHOLE module — see `escomplex-ast-compat.js`
+// for the defect and the upstream status. Installing at the kernel rather than
+// at each caller makes the next scoring entrypoint correct by construction.
+installAstCompat();
+
+const parserProblem = describeParserMajorError();
+if (parserProblem !== null) {
+  throw new Error(`[escomplex-kernel] ${parserProblem}`);
+}
+
+/**
+ * Run one synchronous plugin dispatch.
+ *
+ * Reproduces the displaced bus's `invokeSyncEvents` for the degenerate shape
+ * this kernel uses: no `copyProps` (the shell passed `void 0` at every call
+ * site, so the merge base was always `{}`), no eventbus, and the caller
+ * reading its results back off the same mutated `data` object every plugin
+ * saw.
+ *
+ * @param {string} method Plugin method name, e.g. `onEnterNode`.
+ * @param {object} passthru Properties placed on the event's `data`.
+ * @returns {object} The event `data`, after every plugin has mutated it.
+ */
+function dispatch(method, passthru) {
+  const event = {
+    data: { ...passthru },
+    extra: undefined,
+    eventbus: undefined,
+    pluginName: undefined,
+    pluginOptions: undefined,
+  };
+  for (const [name, instance] of PLUGINS) {
+    if (typeof instance[method] !== 'function') continue;
+    event.pluginName = name;
+    instance[method](event);
+  }
+  return event.data;
+}
+
+/**
+ * The `ignoreKeys` a syntax trait wants withheld from the walker, if any.
+ *
+ * @param {object|undefined} syntax The trait entry for this node type.
+ * @param {object} node
+ * @param {object} parent
+ * @returns {string[]}
+ */
+function traitIgnoreKeys(syntax, node, parent) {
+  return typeof syntax === 'object' && syntax?.ignoreKeys
+    ? syntax.ignoreKeys.valueOf(node, parent)
+    : [];
+}
+
+/**
+ * The new scope a syntax trait opens at this node, if any.
+ *
+ * @param {object|undefined} syntax The trait entry for this node type.
+ * @param {object} node
+ * @param {object} parent
+ * @returns {object|null}
+ */
+function traitNewScope(syntax, node, parent) {
+  if (typeof syntax !== 'object' || !syntax?.newScope) return null;
+  return syntax.newScope.valueOf(node, parent) ?? null;
+}
+
+/**
+ * Build the walker visitor for one module traversal.
+ *
+ * Split out of {@link analyzeModule} so the enter/exit symmetry is readable
+ * side by side: each resolves the trait's scope, brackets the `scopeControl`
+ * mutation with a pre/post dispatch, and straddles it with the node dispatch
+ * in opposite order on the way in and out.
+ *
+ * The two event shapes are not interchangeable, and the difference is the
+ * displaced shell's, not a simplification available here: node events carry
+ * `syntaxes` and scope events do not, and a scope event names its scope
+ * `newScope` on the way in but `scope` on the way out.
+ *
+ * @param {{
+ *   moduleReport: object,
+ *   scopeControl: object,
+ *   syntaxes: Record<string, object>,
+ *   settings: object,
+ * }} context
+ * @returns {{enterNode: Function, exitNode: Function}}
+ */
+function buildVisitor({ moduleReport, scopeControl, syntaxes, settings }) {
+  const nodeBase = { moduleReport, scopeControl, syntaxes, settings };
+  const scopeBase = { moduleReport, scopeControl, settings };
+  return {
+    enterNode(node, parent) {
+      const syntax = syntaxes[node.type];
+      const event = dispatch('onEnterNode', {
+        ...nodeBase,
+        ignoreKeys: traitIgnoreKeys(syntax, node, parent),
+        node,
+        parent,
+      });
+      const ignoreKeys = event !== null ? event.ignoreKeys : [];
+      const newScope = traitNewScope(syntax, node, parent);
+      if (newScope) {
+        const scoped = { ...scopeBase, newScope, node, parent };
+        dispatch('onModulePreScopeCreated', scoped);
+        scopeControl.createScope(newScope);
+        dispatch('onModulePostScopeCreated', scoped);
+      }
+      return ignoreKeys;
+    },
+    exitNode(node, parent) {
+      const syntax = syntaxes[node.type];
+      const newScope = traitNewScope(syntax, node, parent);
+      if (newScope) {
+        const scoped = { ...scopeBase, scope: newScope, node, parent };
+        dispatch('onModulePreScopePopped', scoped);
+        scopeControl.popScope(newScope);
+        dispatch('onModulePostScopePopped', scoped);
+      }
+      dispatch('onExitNode', { ...nodeBase, node, parent });
+    },
+  };
+}
+
+/**
+ * Parse and score one module.
+ *
+ * Drop-in replacement for the displaced `escomplex.analyzeModule(source)`:
+ * same report object, same `finalize()` shape, same thrown errors for source
+ * the kernel cannot handle.
+ *
+ * @param {string} source JavaScript (or TypeScript) source text.
+ * @param {object} [options] Passed to the plugins' `onConfigure`, as before.
+ * @returns {object} The finalized module report.
+ * @throws {SyntaxError} Propagated from the parser, as before.
+ */
+export function analyzeModule(source, options = {}) {
+  const ast = babelParse(source, {
+    plugins: structuredClone(PARSER_PLUGINS),
+    sourceType: 'unambiguous',
+  });
+
+  const settings = dispatch('onConfigure', { options, settings: {} }).settings;
+  Object.freeze(settings);
+  const syntaxes = dispatch('onLoadSyntax', {
+    settings,
+    syntaxes: {},
+  }).syntaxes;
+
+  const moduleReport = new ModuleReport(
+    ast.loc.start.line,
+    ast.loc.end.line,
+    settings,
+  );
+  dispatch('onModuleStart', { ast, moduleReport, syntaxes, settings });
+
+  const scopeControl = new ModuleScopeControl(moduleReport);
+  new ASTWalker().traverse(
+    ast,
+    buildVisitor({ moduleReport, scopeControl, syntaxes, settings }),
+  );
+
+  for (const phase of [
+    'onModuleCalculate',
+    'onModuleAverage',
+    'onModulePostAverage',
+    'onModuleEnd',
+  ]) {
+    dispatch(phase, { moduleReport, syntaxes, settings });
+  }
+
+  return moduleReport.finalize();
+}

package/.agents/scripts/lib/maintainability-engine.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
-import escomplex from 'typhonjs-escomplex';
 import { install as installAstCompat } from './escomplex-ast-compat.js';
+import { analyzeModule } from './escomplex-kernel.js';
 import { transpileIfNeeded } from './transpile.js';
 
 /**
@@ -45,7 +45,7 @@ const UNSCORABLE = 0;
  */
 export function scoreSource(sourceCode) {
   try {
-    const score = escomplex.analyzeModule(sourceCode)?.maintainability;
+    const score = analyzeModule(sourceCode)?.maintainability;
     return Number.isFinite(score)
       ? { score, unscorable: false, reason: null }
       : unscorable(`kernel returned a non-finite index (${String(score)})`);
@@ -141,7 +141,7 @@ export function scoreFile(filePath) {
  */
 export function calculateReport(sourceCode) {
   try {
-    const result = escomplex.analyzeModule(sourceCode);
+    const result = analyzeModule(sourceCode);
     const methods = (result.methods ?? []).map((m) => ({
       name: m.name,
       maintainability:

package/.agents/scripts/lib/orchestration/plan-context.js

@@ -31,10 +31,6 @@ import {
   renderStorySplitRules,
   ticketsModePromptField,
 } from '../templates/decomposer-prompts.js';
-import {
-  renderAcceptanceSpecSystemPrompt,
-  renderTechSpecSystemPrompt,
-} from '../templates/spec-author-prompts.js';
 import { concurrentMap, FANOUT_CONCURRENCY } from '../util/concurrent-map.js';
 import { buildComplexitySignals } from './complexity-gate.js';
 import { findDependencyCandidates } from './dependency-candidates.js';
@@ -329,6 +325,17 @@ export function renderStoriesTemplate({ complexitySignals = null } = {}) {
       title: 'Fill: short descriptive title',
       body: {
         goal: 'Fill: one sentence stating why this Story exists.',
+        // A filled, multi-checkpoint example rather than a placeholder
+        // (Story #5332): `## Slicing` is how one cohesive sweep stays one
+        // Story, so the skeleton has to show an author what a checkpoint
+        // list looks like. Each line is a stage of the work — a commit
+        // boundary inside one session — never a restatement of an
+        // acceptance item, which states what is true once the Story lands.
+        slicing:
+          '1. Re-anchor the shared constant and its consumers.\n' +
+          '2. Move the gate ahead of the first write and arm the refusal.\n' +
+          '3. Delete the superseded module, its test and its flag.\n' +
+          '4. Regenerate the affected baselines; run the full gate chain.',
         spec:
           'Optional — contract and invariants only: interfaces, status ' +
           'codes, security invariants, and load-bearing constraints with ' +
@@ -340,7 +347,7 @@ export function renderStoriesTemplate({ complexitySignals = null } = {}) {
         non_goals: [],
       },
       acceptance: [
-        'Fill: an outcome a PR reviewer can confirm from the diff and the verify output (three to six items)',
+        'Fill: an outcome a PR reviewer can confirm from the diff and the verify output — as many as the capability has, no target and no ceiling',
       ],
       verify: [
         'Fill: exact command or test path — the mechanical check the acceptance item rests on',
@@ -367,25 +374,23 @@ function countEnumeratedItems(text) {
 }
 
 /**
- * Delta-shaped change-request verbs — the `core/scope-triage` skill's
- * change-request rubric routes these to `story` by default when the
- * footprint stays inside Story width.
+ * Delta-shaped change-request verbs — a change request naming one of these
+ * stays a Story by default when the footprint stays inside Story width.
  */
 const DELTA_VERB_RE =
   /\b(fix(?:es)?|tweak(?:s)?|extend(?:s)?|update(?:s)?|adjust(?:s)?|rename(?:s)?|correct(?:s)?|patch(?:es)?|bug|regression|flaky)\b/i;
 
 /**
- * Deterministic, CLI-applied scope-triage verdict over a raw `--seed` text
- * (#4496 fix 6). Embedding the verdict in the `--seed` envelope removes the
- * two skill Reads (`core/scope-triage` + the gate fragment's rubric pass)
- * from the headless path; the attended path keeps the skill-based judgment.
+ * Deterministic, CLI-applied scope signal over a raw `--seed` text
+ * (#4496 fix 6). Embedding it in the `--seed` envelope keeps the headless
+ * path from needing a judgment pass of its own.
  *
- * The heuristics anchor to the same granularity SSOT the skill anchors to —
+ * The heuristics anchor to the granularity SSOT —
  * `DELIVERABLE_GRANULARITY_GUIDANCE` in `ticket-validator-sizing.js` (one
  * Story = one coherent capability slice; multiple independent capabilities =
- * an Epic) — and to the skill's change-request delta rubric. Like the skill,
- * the verdict is **advisory**: being wrong in the `epic` direction is cheap,
- * and `borderline` is a first-class output, not a forced call.
+ * an Epic) — and to the change-request delta rubric above. The verdict is
+ * **advisory**: being wrong in the `epic` direction is cheap, and
+ * `borderline` is a first-class output, not a forced call.
  *
  * @param {{ seedText?: string }} args
  * @returns {{ verdict: 'epic'|'story'|'borderline', reasons: string[], advisory: true, appliedBy: 'cli' }}
@@ -634,12 +639,15 @@ function withAdvisorySignals(complexitySignals, { config, cwd } = {}) {
 
 /**
  * Render the authoring system prompts the collapsed pipeline's single
- * authoring pass consumes. The spec/acceptance prompts render from
- * `lib/templates/spec-author-prompts.js` (the M3/M8 handshake — envelope
- * authoritative from day one); the story prompt is the N=1 core from
- * `lib/templates/decomposer-prompts.js`, with the schedule and partition
- * rules a planner reads only when the default-single split policy clears
- * carried separately as `storySplitRules` (Story #5312).
+ * authoring pass consumes: the N=1 core from
+ * `lib/templates/decomposer-prompts.js`, with the schedule rules and the
+ * collision refusal a planner reads only when the default-single split policy
+ * clears carried separately as `storySplitRules` (Story #5312).
+ *
+ * Story #5332 deleted the `spec` / `acceptance` fields with the module that
+ * rendered them: nothing read either, and both contradicted the current
+ * contract — one asserting Spec budgets that no longer exist, the other
+ * demanding the verify tier suffixes tickets mode now strips.
  *
  * `storyTicketsRules` is the one mode-conditional field (Story #5323): it
  * only means anything when the seed is an existing ticket, and an envelope
@@ -647,12 +655,10 @@ function withAdvisorySignals(complexitySignals, { config, cwd } = {}) {
  * ticket that a `--seed` run does not have.
  *
  * @param {{ mode?: string }} [args]
- * @returns {{ spec: string, acceptance: string, story: string, storySplitRules: string, storyTicketsRules?: string }}
+ * @returns {{ story: string, storySplitRules: string, storyTicketsRules?: string }}
  */
 export function buildSystemPrompts({ mode } = {}) {
   return {
-    spec: renderTechSpecSystemPrompt(),
-    acceptance: renderAcceptanceSpecSystemPrompt(),
     story: renderStoryAuthorCore(),
     storySplitRules: renderStorySplitRules(),
     ...ticketsModePromptField(mode),

package/.agents/scripts/lib/orchestration/plan-persist/run-plan-persist.js

@@ -7,7 +7,7 @@
  *
  *   1. `changes[]` repair + ticket validator + file-assumption + DAG
  *   2. Draft reachability (named soft failure, exit 3)
- *   3. Split-policy partition (`assertAcceptancePartition`) + spec fold
+ *   3. Same-wave collision refusal (`assertNoWaveCollisions`) + spec fold
  *   4. Create Story issues (`type::story` + sanitized authored labels —
  *      deliberately NOT `agent::ready`), resumably via a plan fingerprint
  *   5. Upsert `story-plan-state` on every created Story; upsert `plan-summary`
@@ -81,7 +81,7 @@ import {
   PLAN_SUMMARY_COMMENT_TYPE,
 } from './summary.js';
 import { closeSupersededTickets } from './supersede-ops.js';
-import { predictWaveSerialisation } from './wave-serialisation.js';
+import { assertNoWaveCollisions } from './wave-collision-gate.js';
 
 /** Checkpoint schema version written on each Story's story-plan-state. */
 const PLAN_CHECKPOINT_SCHEMA_VERSION_V2 = 2;
@@ -543,7 +543,6 @@ function logPersistEpilogue({
  *   artifacts: {
  *     stories: Array<object>,
  *     techSpecContent?: string|null,
- *     planAcceptance?: string[]|null,
  *     planContextEnvelope?: object|null,
  *   },
  *   config?: object,
@@ -569,7 +568,6 @@ export async function runPlanPersist({
   const {
     stories: rawStories = null,
     techSpecContent = null,
-    planAcceptance = null,
     planContextEnvelope = null,
   } = artifacts ?? {};
   const {
@@ -623,11 +621,10 @@ export async function runPlanPersist({
     epicId: opts.adoptEpicId ?? null,
   });
 
-  // Split policy + inline Spec fold (Specs stay inline, never under docs/).
+  // Inline Spec fold (Specs stay inline, never under docs/).
   const seedContent = planContextEnvelope?.seed?.content ?? '';
   const { stories: assembled } = assemblePlanStories(rawStories, {
     sharedSpec: techSpecContent,
-    planAcceptance: planAcceptance ?? undefined,
     sourceTicketIds,
     // The seed this plan was authored from: an audit sweep's Single-plan seed
     // carries the `audit-fingerprints` / `audit-semantic-keys` footers, and
@@ -654,6 +651,31 @@ export async function runPlanPersist({
     rawFindings: validated.findings,
   });
 
+  // Story #5332 — the split gate, ahead of the first create. `buildWaveTable`
+  // needs only `{slug, title, depends_on}` and the prediction needs only the
+  // assembled bodies, so both can run before anything is written; they used
+  // to sit *after* creation, which is why the collision table could only ever
+  // be a receipt for a plan already live. The same computed value is handed
+  // to the summary rendering below rather than recomputed, so the refusal and
+  // the receipt can never disagree.
+  const waveTable = buildWaveTable(
+    stories.map((s) => ({
+      slug: s.slug,
+      title: s.title,
+      depends_on: s.depends_on,
+    })),
+  );
+
+  // Story #5265: the table says which Stories share an order; the dispatcher
+  // decides which of those actually run together. Run its own predicate over
+  // the assembled bodies — the exact artifact the tick will read back off
+  // GitHub — so an N>1 draft it would serialize is refused here, and the
+  // summary comment names the serialisation instead of promising parallelism
+  // the next tick refuses. One enumeration feeds both.
+  const waveCollisions = assertNoWaveCollisions(waveTable, stories, {
+    tempRoot: getPaths(config).tempRoot,
+  });
+
   const { created, planRunLabel, planRunLabelApplied } =
     await createStoryIssues({
       provider,
@@ -666,24 +688,6 @@ export async function runPlanPersist({
   recordAuditFilings({ stories, created, tickets: rawStories, dryRun });
 
   const primary = created[0];
-  const waveTable = buildWaveTable(
-    stories.map((s) => ({
-      slug: s.slug,
-      title: s.title,
-      depends_on: s.depends_on,
-    })),
-  );
-
-  // Story #5265: the table says which Stories share an order; the dispatcher
-  // decides which of those actually run together, and it decides on the
-  // evidence-widened footprint. Run its own predicate over the assembled
-  // bodies — the exact artifact the tick will read back off GitHub — so the
-  // comment names the serialisation instead of promising parallelism the
-  // next tick refuses. `tempRoot` is threaded for the same reason the tick
-  // threads it: the scrape must ignore this project's scratch root.
-  const waveCollisions = predictWaveSerialisation(waveTable, stories, {
-    tempRoot: getPaths(config).tempRoot,
-  });
 
   // Story #4541: `readPlanMetrics` is declared `(epicId, config)` but was
   // called with `config` first, so the ledger path resolver received the

package/.agents/scripts/lib/orchestration/plan-persist/story-ops.js

@@ -4,7 +4,7 @@
  * Under the Story collapse (`docs/roadmap.md` § Stage 3), `/mandrel-plan` persists
  * zero-or-more Story issues directly — no Epic parent, no reconciler tree,
  * no `deliveryShape` mode matrix. Default is **one Story**; N>1 is gated by
- * the Stage-1 split-policy validator (`assertAcceptancePartition`).
+ * the supersede partition check.
  *
  * Each Story body is the single executable document: Tech Spec stays inline
  * under `## Spec`, at whatever length the work needs (Story #5312 deleted
@@ -34,7 +34,6 @@ import {
   concurrentMap,
   FANOUT_CONCURRENCY,
 } from '../../util/concurrent-map.js';
-import { assertAcceptancePartition } from '../split-policy-validator.js';
 import {
   externalDependencyId,
   isExternalDependencyRef,
@@ -514,15 +513,18 @@ function assertSharedSpecAllowed(tickets, sharedSpec) {
 
 /**
  * Assemble markdown bodies for every Story: normalize → fold spec →
- * assertAcceptancePartition → assertSupersedePartition → serialize.
+ * assertSupersedePartition → serialize.
  *
- * Both partition checks run **before** any GitHub write so a mis-authored
- * plan never leaves Stories live against an inconsistent tracker.
+ * The partition check runs **before** any GitHub write so a mis-authored
+ * plan never leaves Stories live against an inconsistent tracker. Story #5332
+ * retired the acceptance partition that used to run beside it: it refused
+ * only byte-identical acceptance text across siblings, and the split gate is
+ * now `assertNoWaveCollisions` in `run-plan-persist.js`, ahead of the first
+ * create.
  *
  * @param {object[]} tickets
  * @param {object} [opts]
  * @param {string|null} [opts.sharedSpec]
- * @param {string[]} [opts.planAcceptance]
  * @param {number[]} [opts.sourceTicketIds] Ids passed to `/mandrel-plan --tickets`.
  * @returns {{ stories: Array<{ slug: string, title: string, body: string, acceptance: string[], depends_on: string[], supersedes: Array<{ id: number, note: string|null }> }> }}
  */
@@ -539,9 +541,6 @@ export function assemblePlanStories(tickets, opts = {}) {
     (ticket) => assembleOnePlanStory(ticket, opts).story,
   );
 
-  assertAcceptancePartition(stories, {
-    planAcceptance: opts.planAcceptance,
-  });
   assertSupersedePartition(stories, opts.sourceTicketIds ?? []);
 
   return { stories };

package/.agents/scripts/lib/orchestration/plan-persist/supersede-ops.js

@@ -16,7 +16,7 @@
  * Two halves, deliberately separated by the `createIssue` boundary:
  *
  *   1. **`assertSupersedePartition`** — a plan-time, fail-closed check that
- *      runs *before* any GitHub write. Mirrors `assertAcceptancePartition`:
+ *      runs *before* any GitHub write. Same fail-closed shape as the
  *      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. A partial
  *      supersede map is a planning error, not something to paper over at