mandrel 2.59.0 → 2.60.0

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

@@ -10,20 +10,20 @@
  *   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`
- *      on the primary Story
+ *   5. Upsert the `story-plan-state` comment on every created Story — since
+ *      Story #5343 the one comment persist posts, carrying the plan summary
  *   6. Flip every Story to `agent::ready` — the terminal step, so `ready`
- *      always implies "checkpoints written"
+ *      always implies "plan comments written"
  *   7. Comment on + close the superseded `--tickets` source issues
  *      (Story #4535) — bookkeeping only; never fails the run
  *   8. Temp cleanup at terminal success + a stale-plan-dir reap
  *
  * **Why `agent::ready` moved to the end (Story #4541).** Issues used to be
- * born `agent::ready` in the creating POST while the checkpoints were
+ * born `agent::ready` in the creating POST while the plan comments were
  * written afterwards. Anything picking a Story up in that window — or after
- * a comment failure aborted the loop — read the checkpoint as `null`
- * (`story-plan-state.js` degrades missing/malformed to `null`). Creating
- * unlabelled, writing checkpoints, then flipping closes that race.
+ * a comment failure aborted the loop — found a ready Story carrying none of
+ * the operator's delivery instructions. Creating unlabelled, writing the
+ * comments, then flipping closes that race.
  *
  * **No authored risk artifact (Story #4542).** Persist neither requires nor
  * accepts a risk verdict, derives no envelope from one, and computes no
@@ -75,48 +75,48 @@ import {
   createStoryIssues,
   markStoriesReady,
 } from './story-ops.js';
-import {
-  buildPlanSummaryCommentBody,
-  buildWaveTable,
-  PLAN_SUMMARY_COMMENT_TYPE,
-} from './summary.js';
+import { buildPlanSummaryCommentBody, buildWaveTable } from './summary.js';
 import { closeSupersededTickets } from './supersede-ops.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;
-
-/** Structured-comment type for the per-plan Story checkpoint. */
+/** Structured-comment type for the per-plan Story comment. */
 const STORY_PLAN_STATE_TYPE = 'story-plan-state';
 
 /**
- * Write the `story-plan-state` checkpoint on a Story.
+ * Write the plan comment on a Story — the **one** comment persist posts per
+ * Story (Story #5343).
+ *
+ * It carries the human plan summary: the created Story set, the delivery order
+ * and the exact deliver command. That summary used to be a second
+ * `plan-summary` comment on the primary Story only, which meant the operator's
+ * instructions lived on a different marker from the rest — and on a different
+ * ticket from four Stories out of five.
+ *
+ * **No machine payload (Story #5367).** The comment used to lead with a fenced
+ * JSON checkpoint (a persist receipt: completion time, Story count, the
+ * cohort). Nothing ever read it back — the one module that parsed it had no
+ * production importer — so the payload and its readers are gone. The
+ * `story-plan-state` marker stays: it is what makes a re-persist upsert this
+ * comment in place instead of appending a second one.
  *
  * @param {object} provider
  * @param {number} storyId
- * @param {object} state
+ * @param {string} summary Rendered plan-summary markdown. The comment exists
+ *   to carry it, so an empty summary is a caller bug rather than a degenerate
+ *   comment worth posting.
+ * @returns {Promise<void>}
  */
-export async function writeCheckpointV2(provider, storyId, state) {
+export async function writePlanSummaryComment(provider, storyId, summary) {
   if (!Number.isInteger(storyId)) {
-    throw new TypeError('writeCheckpointV2 requires a numeric storyId');
+    throw new TypeError('writePlanSummaryComment requires a numeric storyId');
+  }
+  const body = summary?.trim();
+  if (!body) {
+    throw new TypeError(
+      'writePlanSummaryComment requires a non-empty plan summary',
+    );
   }
-  const body = [
-    '### story-plan-state',
-    '',
-    '```json',
-    JSON.stringify(
-      {
-        version: PLAN_CHECKPOINT_SCHEMA_VERSION_V2,
-        storyId,
-        ...state,
-      },
-      null,
-      2,
-    ),
-    '```',
-  ].join('\n');
   await upsertStructuredComment(provider, storyId, STORY_PLAN_STATE_TYPE, body);
-  return state;
 }
 
 /**
@@ -130,7 +130,7 @@ export async function writeCheckpointV2(provider, storyId, state) {
  * the helper applied are reported alongside so the operator sees what was
  * rewritten.
  *
- * The returned freshness counts feed the posted `plan-summary`'s freshness
+ * The returned freshness counts feed the posted summary's freshness
  * line: every warning is a reference the base branch disagreed with, so it
  * counts as `stale` there rather than the comment reading "clean" on a run
  * that had something to say.
@@ -197,8 +197,9 @@ function collectTextHygieneWarnings(rawStories) {
 
 /**
  * Print every warning the run collected under one heading. The dry-run is
- * where an operator reads these; the persist prints the same list so a
- * `--chain-on-clean` run loses nothing.
+ * where an operator reads these; the persist prints the same list so the
+ * chained run loses nothing on stderr, as the chain's envelope merge keeps
+ * it from losing anything on stdout (Story #5361).
  *
  * @param {string[]} warnings
  * @returns {void}
@@ -248,7 +249,7 @@ async function runSupersedePhase(args) {
 }
 
 /**
- * Render the plan-metrics line for the **posted** `plan-summary` comment,
+ * Render the plan-metrics line for the **posted** summary section,
  * scoped to this invocation.
  *
  * The ordering hazard this closes: the ledger record for the current run is
@@ -313,7 +314,7 @@ async function renderRunScopedPlanMetricsLine({
  * writes — and the passes that scan `body.acceptance` / `body.verify` were
  * inert on the canonical top-level authoring shape as a result. Findings the
  * raw pass already reported are dropped so the same collision is not
- * announced twice per run; the rest are returned for the plan-summary
+ * announced twice per run; the rest are returned for the summary
  * comment, which is where these findings stop being a stderr line nobody
  * keeps. Every finding is advisory (Story #5312).
  *
@@ -419,56 +420,33 @@ async function enforceReachability(reachability, config) {
 }
 
 /**
- * Write the per-Story checkpoint, upsert the plan-summary comment, and flip
- * every created Story to `agent::ready`. Terminal ordering is load-bearing:
- * `agent::ready` lands last so it can honestly mean "fully persisted"
- * (Story #4541). A dry run performs none of it.
+ * Write the per-Story plan comment — one comment per Story, carrying the plan
+ * summary (Story #5343) — and flip every created Story to `agent::ready`.
+ * Terminal ordering is load-bearing: `agent::ready` lands last so it can
+ * honestly mean "fully persisted" (Story #4541). A dry run performs none of it.
  *
- * **The checkpoints fan out; the phase boundary does not** (Story #4952). The
+ * **The comments fan out; the phase boundary does not** (Story #4952). The
  * per-Story upserts are independent of one another and run under bounded
  * concurrency, but the `await` on that whole fan-out is what keeps the
- * Story #4541 invariant intact: *every* checkpoint is on its ticket before the
- * first `agent::ready` flip is issued, so `ready` still means "fully
- * persisted" and a `/mandrel-deliver` that picks a Story up cannot read a null
- * checkpoint. Concurrency inside the phase is safe; overlapping the phases is
- * the race this ordering exists to close.
+ * Story #4541 invariant intact: *every* Story carries its plan comment before
+ * the first `agent::ready` flip is issued, so `ready` still means "fully
+ * persisted" and the operator's instructions are never missing from a ticket
+ * something else may already be picking up. Concurrency inside the phase is
+ * safe; overlapping the phases is the race this ordering exists to close.
  *
  * @param {object} args
  * @returns {Promise<void>}
  */
-async function persistStoryArtifacts({
-  provider,
-  created,
-  primary,
-  summaryBody,
-}) {
-  const cohort = created.map((createdStory) => ({
-    slug: createdStory.slug,
-    id: createdStory.id,
-  }));
+async function persistStoryArtifacts({ provider, created, summaryBody }) {
   await concurrentMap(
     created,
-    (story) =>
-      writeCheckpointV2(provider, story.id, {
-        persist: {
-          completedAt: new Date().toISOString(),
-          storyCount: created.length,
-          primaryStoryId: primary.id,
-          stories: cohort,
-        },
-      }),
-    // The per-Story checkpoint upserts (Story #4952): each targets a
+    (story) => writePlanSummaryComment(provider, story.id, summaryBody),
+    // The per-Story comment upserts (Story #4952): each targets a
     // different issue and reads nothing another writes, so this loop was
     // serial only by construction — but see {@link persistStoryArtifacts}
     // for the phase ordering that is *not* incidental.
     { concurrency: FANOUT_CONCURRENCY },
   );
-  await upsertStructuredComment(
-    provider,
-    primary.id,
-    PLAN_SUMMARY_COMMENT_TYPE,
-    summaryBody,
-  );
   await markStoriesReady({ provider, created });
 }
 
@@ -623,18 +601,26 @@ export async function runPlanPersist({
 
   // Inline Spec fold (Specs stay inline, never under docs/).
   const seedContent = planContextEnvelope?.seed?.content ?? '';
-  const { stories: assembled } = assemblePlanStories(rawStories, {
-    sharedSpec: techSpecContent,
-    sourceTicketIds,
-    // The seed this plan was authored from: an audit sweep's Single-plan seed
-    // carries the `audit-fingerprints` / `audit-semantic-keys` footers, and
-    // assembly copies them into the persisted Story bodies so the next sweep
-    // recognises what it already planned (Story #4877). Since Story #5045 this
-    // is the **fallback** — it is carried onto every Story that did not
-    // attribute its own `provenance`, which keeps an un-attributed plan exactly
-    // as recall-safe as it was. Empty for a `--tickets` run, a no-op there.
-    provenanceSource: seedContent,
-  });
+  const { stories: assembled, warnings: supersedeWarnings } =
+    assemblePlanStories(rawStories, {
+      sharedSpec: techSpecContent,
+      sourceTicketIds,
+      // The seed this plan was authored from: an audit sweep's Single-plan seed
+      // carries the `audit-fingerprints` / `audit-semantic-keys` footers, and
+      // assembly copies them into the persisted Story bodies so the next sweep
+      // recognises what it already planned (Story #4877). Since Story #5045 this
+      // is the **fallback** — it is carried onto every Story that did not
+      // attribute its own `provenance`, which keeps an un-attributed plan exactly
+      // as recall-safe as it was. Empty for a `--tickets` run, a no-op there.
+      provenanceSource: seedContent,
+    });
+
+  // Story #5342: the source ids assembly assigned to the primary Story by
+  // default. They ride the same list every other dry-run warning does, so a
+  // default-assigned supersede is visible in the output the operator already
+  // reads rather than only in the tracker afterwards.
+  warnings.push(...supersedeWarnings);
+  logWarnings(supersedeWarnings);
 
   // Stamp the `audit::*` labels the dedup corpus is listed by. Without them a
   // Story this path files is absent from the pool an indexed sweep matches
@@ -722,12 +708,7 @@ export async function runPlanPersist({
   });
 
   if (!dryRun) {
-    await persistStoryArtifacts({
-      provider,
-      created,
-      primary,
-      summaryBody,
-    });
+    await persistStoryArtifacts({ provider, created, summaryBody });
   }
 
   // Story #5139 — the container Epic is created LAST among the writes: its

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

@@ -39,8 +39,8 @@ import {
   isExternalDependencyRef,
 } from './external-deps.js';
 import {
-  assertSupersedePartition,
   normalizeSupersedes,
+  resolveSupersedePartition,
 } from './supersede-ops.js';
 
 /**
@@ -157,7 +157,7 @@ const PLAN_FINGERPRINT_LENGTH = 16;
  *
  *   1. A later, unrelated plan that reused a slug **and** title adopted the
  *      stale open Story — never rewriting its body or Spec, and landing this
- *      run's checkpoints, ready-flip, and supersede comments on the wrong
+ *      run's plan comments, ready-flip, and supersede comments on the wrong
  *      issue.
  *   2. A legitimate resume after the operator edited `stories.json` adopted
  *      the pre-edit Story and kept its stale body, discarding the edit.
@@ -513,9 +513,19 @@ function assertSharedSpecAllowed(tickets, sharedSpec) {
 
 /**
  * Assemble markdown bodies for every Story: normalize → fold spec →
- * assertSupersedePartition → serialize.
+ * order by dependency → resolveSupersedePartition → serialize.
  *
- * The partition check runs **before** any GitHub write so a mis-authored
+ * **The dependency sort runs here, once** (Story #5361). It used to run again
+ * inside the create loop, which meant "the primary Story" was derived twice
+ * from two different orderings: supersede assignment took the first *authored*
+ * Story, while the plan summary took the first *created*
+ * one. A draft whose authoring order differed from its dependency order made
+ * the `superseded-by` comment name a different Story from the summary. One
+ * sort, one ordered list threaded on to every consumer, so `stories[0]` is the
+ * only primary there is. The sort also refuses an unknown sibling or a cycle,
+ * which now fails the write-free pass rather than the first create.
+ *
+ * The partition pass 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
@@ -526,7 +536,7 @@ function assertSharedSpecAllowed(tickets, sharedSpec) {
  * @param {object} [opts]
  * @param {string|null} [opts.sharedSpec]
  * @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 }> }> }}
+ * @returns {{ stories: Array<{ slug: string, title: string, body: string, acceptance: string[], depends_on: string[], supersedes: Array<{ id: number, note: string|null }> }>, warnings: string[] }}
  */
 export function assemblePlanStories(tickets, opts = {}) {
   if (!Array.isArray(tickets) || tickets.length === 0) {
@@ -537,13 +547,16 @@ export function assemblePlanStories(tickets, opts = {}) {
 
   assertSharedSpecAllowed(tickets, opts.sharedSpec);
 
-  const stories = tickets.map(
-    (ticket) => assembleOnePlanStory(ticket, opts).story,
+  const stories = orderStoriesByDependencies(
+    tickets.map((ticket) => assembleOnePlanStory(ticket, opts).story),
   );
 
-  assertSupersedePartition(stories, opts.sourceTicketIds ?? []);
+  const warnings = resolveSupersedePartition(
+    stories,
+    opts.sourceTicketIds ?? [],
+  );
 
-  return { stories };
+  return { stories, warnings };
 }
 
 function orderStoriesByDependencies(stories) {
@@ -901,12 +914,13 @@ async function ensurePersistLabel({
  * Create Story issues via `provider.createIssue`, resumably.
  *
  * **Stories are born without `agent::ready`** (Story #4541). They used to
- * carry it in the creating POST while the `story-plan-state` checkpoint was
+ * carry it in the creating POST while the `story-plan-state` comment was
  * upserted afterwards, so anything that picked a Story up inside that window —
- * or after a comment failure aborted the loop — read the checkpoint as `null`.
- * Creation now applies `type::story` plus the sanitized authored labels only;
- * `markStoriesReady` performs the flip as the terminal step, once every
- * checkpoint is on the ticket.
+ * or after a comment failure aborted the loop — found a ready Story carrying
+ * none of the operator's delivery instructions. Creation now applies
+ * `type::story` plus the sanitized authored labels only; `markStoriesReady`
+ * performs the flip as the terminal step, once every plan comment is on the
+ * ticket.
  *
  * **The loop is resumable, and adoption is content-keyed.** Each body carries
  * a plan-fingerprint marker, and the open `type::story` backlog is indexed by
@@ -1002,7 +1016,10 @@ export async function createStoryIssues({ provider, stories, opts = {} }) {
   const created = [];
   const idBySlug = new Map();
 
-  for (const story of orderStoriesByDependencies(list)) {
+  // Already in dependency order: `assemblePlanStories` sorted once, and
+  // sorting again here is what gave the run a second, disagreeing notion of
+  // which Story is primary (Story #5361).
+  for (const story of list) {
     const already = byFingerprint.get(story.fingerprint);
     if (!already) warnOnDivergentSameTitleStory(story, idsByTitle);
     if (already) {
@@ -1087,8 +1104,8 @@ export async function createStoryIssues({ provider, stories, opts = {} }) {
  * (Story #4541).
  *
  * This is what makes `agent::ready` *mean* "fully persisted": by the time it
- * lands, the Story's `story-plan-state` checkpoint is already on the ticket, so
- * a `/mandrel-deliver` that picks it up cannot read a null checkpoint.
+ * lands, the Story's `story-plan-state` comment is already on the ticket, so a
+ * `/mandrel-deliver` that picks it up always has the plan summary beside it.
  *
  * Fails closed: an un-flipped Story is invisible to `/mandrel-deliver`, which is the
  * safe direction — the operator is told exactly which ids need the label.
@@ -1144,7 +1161,7 @@ export async function markStoriesReady({ provider, created }) {
   if (failed.length > 0) {
     throw new Error(
       `[plan-persist] ${failed.length} Story(ies) were created with their ` +
-        'checkpoints but could not be flipped to agent::ready:\n' +
+        'plan comments but could not be flipped to agent::ready:\n' +
         `${failed.map((f) => `  - ${f}`).join('\n')}\n` +
         'They are invisible to /mandrel-deliver until the label lands. Re-run persist ' +
         '(it resumes rather than duplicating) or add the label by hand.',

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

@@ -1,10 +1,14 @@
 /**
  * summary.js — plan-persist terminal summary (v2 Stage 3).
  *
- * Upserts a single `plan-summary` structured comment on the primary Story
- * at terminal success. Carries the persist receipts — including whether the
- * operator forced a review stop — and the dry-run `depends_on` ordering table
- * for the rare N>1 plan.
+ * Renders the persist receipts — the created Story set, whether the operator
+ * forced a review stop, the `depends_on` ordering table and the exact deliver
+ * command. Story #5343 moved that rendering onto the **`story-plan-state`**
+ * marker every created Story already carries: it used to be a second,
+ * primary-Story-only `plan-summary` comment, which cost one more write per
+ * plan and split the operator's reading between two markers. Story #5367
+ * deleted the machine checkpoint that shared the marker with it, so this
+ * rendering is now the whole body of the one comment persist posts.
  *
  * Story #4542 removed the risk / review-routing line: no risk level, gate
  * decision, or acceptance disposition is computed at plan time any more, so
@@ -16,11 +20,6 @@
 import { computeStoryWaves } from '../dependency-analyzer.js';
 import { renderPredictedSerialisationLines } from './wave-serialisation.js';
 
-/**
- * Structured-comment type for the persist summary.
- */
-export const PLAN_SUMMARY_COMMENT_TYPE = 'plan-summary';
-
 /**
  * Compute the dry-run wave assignment for a validated ticket set.
  *
@@ -114,7 +113,8 @@ function renderSharedEditorLines(conflictFindings) {
 }
 
 /**
- * Build the `plan-summary` structured-comment body.
+ * Build the body of each Story's `story-plan-state` comment (Story #5343;
+ * Story #5367 made it the whole body).
  *
  * @param {object} input
  * @returns {string}
@@ -169,7 +169,7 @@ export function buildPlanSummaryCommentBody({
       : '/mandrel-deliver <storyId> [<storyId> ...]';
 
   return [
-    `### 📋 Plan Summary — Story #${epicId} is \`agent::ready\``,
+    `#### 📋 Plan Summary — Story #${epicId} is \`agent::ready\``,
     '',
     `- ${ticketCount} Story ticket(s) persisted: ${storyList}.`,
     ...reviewLines,

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

@@ -15,12 +15,12 @@
  *
  * Two halves, deliberately separated by the `createIssue` boundary:
  *
- *   1. **`assertSupersedePartition`** — a plan-time, fail-closed check that
- *      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
- *      write time.
+ *   1. **`resolveSupersedePartition`** — the plan-time completion pass that
+ *      runs *before* any GitHub write. No id may be claimed by two Stories
+ *      and no Story may claim an id that was not a source ticket — both fail
+ *      closed. A source id nobody claimed is assigned to the primary Story
+ *      with a warning (Story #5342): the plan is replacing it either way, so
+ *      the only open question was bookkeeping.
  *   2. **`closeSupersededTickets`** — the bookkeeping pass that runs *after*
  *      the Stories exist. It **never throws**: a throw here would leave the
  *      run half-done with Stories already live. An already-closed, deleted,
@@ -279,18 +279,12 @@ function describeStoryIds(entries) {
 }
 
 /**
- * Fail closed on a partial supersede map.
+ * Index which Story claims each source id.
  *
- * Runs **before** `createIssue` so a mis-authored map never leaves Stories
- * live against an inconsistent tracker.
- *
- * @param {Array<{ slug: string, supersedes: Array<{ id: number }> }>} stories
- * @param {number[]} sourceTicketIds Ids passed to `/mandrel-plan --tickets`.
+ * @param {Array<{ slug: string, supersedes?: Array<{ id: number }> }>} list
+ * @returns {Map<number, string[]>} id → claiming slugs, in draft order.
  */
-export function assertSupersedePartition(stories, sourceTicketIds = []) {
-  const list = Array.isArray(stories) ? stories : [];
-  const sources = new Set(sourceTicketIds);
-
+function indexSupersedeClaims(list) {
   /** @type {Map<number, string[]>} */
   const claims = new Map();
   for (const story of list) {
@@ -300,9 +294,47 @@ export function assertSupersedePartition(stories, sourceTicketIds = []) {
       claims.set(id, owners);
     }
   }
+  return claims;
+}
 
-  const errors = [];
+/**
+ * Complete the supersede map, refusing only what the plan gets wrong.
+ *
+ * Two halves, split by who can be right (Story #5342):
+ *
+ *   - **Refused.** A Story claiming an id that was never a source ticket, and
+ *     two Stories claiming the same id. Both name an intent the run cannot
+ *     act on — the first would comment on and close an issue nobody asked
+ *     about, the second cannot say which Story replaced it — so they fail
+ *     closed, **before** `createIssue`, and no Story goes live against an
+ *     inconsistent tracker.
+ *   - **Assigned with a warning.** A source id no Story claimed. Every id
+ *     passed to `--tickets` is being replaced by this plan by construction;
+ *     which Story records it is a bookkeeping detail, and the primary Story
+ *     is the answer the operator would have given. Refusing cost a whole
+ *     re-author round to type back a fact the run already knew.
+ *
+ * Mutates the unclaimed ids onto the primary Story's `supersedes[]`.
+ *
+ * **`stories[0]` is the primary, and it is the *only* derivation of it**
+ * (Story #5361): `assemblePlanStories` hands this list over already sorted by
+ * `orderStoriesByDependencies`, which is the same order the create loop files
+ * the Stories in — so the `superseded-by` comment this assignment produces
+ * can never name a different Story from the checkpoint and the plan summary.
+ * A non-empty list is the caller's contract (assembly refuses an empty
+ * draft before it gets here).
+ *
+ * @param {Array<{ slug: string, supersedes: Array<{ id: number, note: string|null }> }>} stories
+ *   Dependency-ordered and non-empty.
+ * @param {number[]} sourceTicketIds Ids passed to `/mandrel-plan --tickets`.
+ * @returns {string[]} One warning per id assigned by default.
+ */
+export function resolveSupersedePartition(stories, sourceTicketIds = []) {
+  const list = Array.isArray(stories) ? stories : [];
+  const sources = new Set(sourceTicketIds);
+  const claims = indexSupersedeClaims(list);
 
+  const errors = [];
   for (const [id, owners] of claims) {
     if (owners.length > 1) {
       errors.push(
@@ -317,23 +349,25 @@ export function assertSupersedePartition(stories, sourceTicketIds = []) {
       );
     }
   }
-
-  for (const id of sources) {
-    if (!claims.has(id)) {
-      errors.push(
-        `source ticket #${id} is not claimed by any Story's supersedes[] — ` +
-          'a partial supersede map is a planning error. Claim it, or drop it ' +
-          'from --tickets.',
-      );
-    }
-  }
-
   if (errors.length > 0) {
     throw new Error(
       `[plan-persist] supersede partition failed with ${errors.length} ` +
         `error(s):\n${errors.map((e) => `  - ${e}`).join('\n')}`,
     );
   }
+
+  const primary = list[0];
+  const warnings = [];
+  for (const id of sources) {
+    if (claims.has(id)) continue;
+    primary.supersedes = [...(primary.supersedes ?? []), { id, note: null }];
+    warnings.push(
+      `source ticket #${id} was claimed by no Story's supersedes[] — ` +
+        `assigned to the primary Story "${primary.slug}". Author the claim ` +
+        'explicitly if another Story is the one that replaces it.',
+    );
+  }
+  return warnings;
 }
 
 /**
@@ -567,7 +601,7 @@ export async function closeSupersededTickets({
       });
     },
     // The per-source-ticket close (Story #4952) fans out across **distinct**
-    // tickets — `assertSupersedePartition` has already failed the run closed
+    // tickets — `resolveSupersedePartition` has already failed the run closed
     // if two Stories claim the same id, so no two units in flight can touch
     // the same issue. Within one unit the probe → comment → close sequence
     // stays strictly ordered: commenting on an issue the probe reported

package/.agents/scripts/lib/orchestration/review-depth.js

@@ -75,19 +75,22 @@ export const DEFAULT_DIFF_WIDTH = Object.freeze({
  * `audit-rules.json`?
  *
  * This is the **single source** of the derived level — the review depth
- * ({@link resolveDepth}), the acceptance-critic fresh-vs-inline routing
- * (`ceremony-routing.js#resolveCeremonyForRisk`), and the dispatch-side
- * complexity routing (`complexity-gate.js#deriveStoryShape`, Story #4722)
- * all consume what this returns, so no ceremony decision can disagree about
- * how risky a change is. Dispatch reads the **predicted** shape (the Story's
- * declared `changes[]` footprint) and close reads the **actual** diff — one
- * taxonomy, two read points, which is what keeps a lite-shaped Story whose
- * footprint touches a sensitive path on the full route with its fresh critic.
+ * ({@link resolveDepth}) and the dispatch-side complexity routing
+ * (`complexity-gate.js#deriveStoryShape`, Story #4722) both consume what this
+ * returns, so no risk decision can disagree about how risky a change is.
+ * Dispatch reads the **predicted** shape (the Story's declared `changes[]`
+ * footprint) and close reads the **actual** diff — one taxonomy, two read
+ * points, which is what keeps a lite-shaped Story whose footprint touches a
+ * sensitive path on the full route and under a deep review.
+ *
+ * The acceptance verdict owner is **not** downstream of this level: Story
+ * #5343 re-based `ceremony-routing.js#resolveCeremonyForRisk` on the ceremony
+ * profile alone, and Story #5366 removed the level from its signature.
  *
  * Returns `null` — the fail-safe "no derivable signal" level — when the change
- * set is empty/unknown or the manifest cannot be read. Both downstream
- * consumers treat `null` as the more thorough posture (`standard` depth, a
- * `fresh` critic), so a derivation failure never buys a change less checking.
+ * set is empty/unknown or the manifest cannot be read. Both consumers treat
+ * `null` as the more thorough posture (`standard` depth, the conservative
+ * `full` route), so a derivation failure never buys a change less checking.
  *
  * Total: never throws.
  *