mandrel 2.59.0 → 2.61.0

package/.agents/scripts/lib/orchestration/run-epilogue.js

@@ -1,18 +1,7 @@
 /**
- * run-epilogue.js — real per-run closeout for `/mandrel-deliver --run`.
- *
- * After the last Story in a multi-Story plan-run lands, this module:
- *   1. Selects the cross-Story audit lens roster over the combined landed
- *      tip vs base (deterministic `selectAudits` — host walks lenses).
- *   2. Rolls up friction follow-ups across every Story in the run and
- *      files/posts them on the primary Story.
- *   3. Checks sibling Spec/acceptance coherence across Story bodies.
- *   4. Reports what the per-Story land tails left the run's container Epics
- *      in — closed, or still open (Story #5139; read-only since #5280).
- *
- * There is no inert planner-only path: `planRunEpilogue` enumerates steps
- * and `runPlanRunEpilogue` executes them. Single-Story runs skip the
- * epilogue (`applicable: false`).
+ * Per-run closeout after the last Story of a multi-Story run lands: optional
+ * audit roster, friction roll-up, and a read-only container-Epic report.
+ * Single-Story runs are `applicable: false`.
  *
  * @module lib/orchestration/run-epilogue
  */
@@ -27,42 +16,28 @@ import {
   assessRollupOutcome,
   buildFollowUpsCommentBody,
   gatherRunFrictionSignals,
+  publishFollowUpsRollup,
   resolveFollowUpRepos,
   summarizeSignalCategories,
 } from './story-follow-ups.js';
 import { upsertStructuredComment } from './ticketing.js';
 
 /**
- * Canonical epilogue step kinds, in execution order.
- * @type {readonly ['audit-roster', 'follow-up-rollup', 'sibling-coherence', 'epic-close']}
+ * Step kinds in execution order. `audit-roster` is opt-in (`--audit-roster`)
+ * because it costs a sub-agent per lens; the other two are reporting.
+ *
+ * @type {readonly ['audit-roster', 'follow-up-rollup', 'epic-close']}
  */
 export const RUN_EPILOGUE_STEP_KINDS = Object.freeze([
   'audit-roster',
   'follow-up-rollup',
-  'sibling-coherence',
   'epic-close',
 ]);
 
 /**
- * Report which container Epics this run's Stories left closed, and which are
- * still open.
- *
- * **It derives nothing and writes nothing.** It used to: it walked every Story
- * and re-ran the full rollup, closing containers itself. That made sense while
- * the rollup only fired on the edges someone had wired, and the epilogue was
- * the backstop for the ones that were missed. Every child state change is now
- * an edge — init, post-land, the supersede close — so by the time the last
- * Story of a run has landed, its container has already been derived from a
- * complete child set by that Story's own land tail. Re-deriving here would ask
- * the same question a second time and answer it identically, at the cost of a
- * full re-read per Story and a second writer on the same issue.
- *
- * What survives is the report, which is why the step exists at all: one place
- * an operator reads to see what a multi-Story run did to its containers. A
- * pending Epic here is a real signal — it means a land tail's rollup declined
- * to close, and the tail's own outcome says why.
- *
- * Non-fatal throughout: a container it cannot read is simply not reported.
+ * Report which container Epics are closed vs still open. Read-only: each land
+ * tail already derived its container, so a pending Epic here means a tail's
+ * rollup declined to close. Unreadable containers are omitted.
  *
  * @param {{ stories: string[], provider: object }} opts
  * @returns {Promise<{ kind: string, closed: number[], pending: number[] }>}
@@ -70,8 +45,7 @@ export const RUN_EPILOGUE_STEP_KINDS = Object.freeze([
 async function executeEpicClose({ stories, provider }) {
   const closed = new Set();
   const pending = new Set();
-  // Siblings share a container: resolve each distinct Epic once, however many
-  // of the run's Stories point at it.
+  // Siblings share a container: report each Epic once.
   const seen = new Set();
 
   for (const raw of stories) {
@@ -97,11 +71,8 @@ async function executeEpicClose({ stories, provider }) {
 }
 
 /**
- * Read one Story's container Epic, or null.
- *
- * One request per Story via the declared parent port. Degrades to null on any
- * failure and on a provider without the port — this is a report, and a
- * container it could not read is better omitted than guessed at.
+ * Null on any failure or a provider without `getParentIssue` — omitted, never
+ * guessed.
  *
  * @param {{ storyId: number, provider: object }} opts
  * @returns {Promise<object|null>}
@@ -154,14 +125,17 @@ function normalizeStoryIds(stories) {
 }
 
 /**
- * Enumerate the ordered epilogue steps for a completed run.
- *
  * @param {object} args
  * @param {string} args.planRunId
  * @param {Array<string|number|{ id?: string|number, slug?: string }>} args.stories
+ * @param {boolean} [args.auditRoster] Default `false`.
  * @returns {object}
  */
-export function planRunEpilogue({ planRunId, stories } = {}) {
+export function planRunEpilogue({
+  planRunId,
+  stories,
+  auditRoster = false,
+} = {}) {
   const ids = normalizeStoryIds(stories);
   const runId =
     typeof planRunId === 'string' && planRunId.trim() !== ''
@@ -181,29 +155,26 @@ export function planRunEpilogue({ planRunId, stories } = {}) {
     };
   }
 
-  // Positional `/mandrel-deliver 101 102` has no plan-run label. Synthesize a
-  // stable adhoc id from the sorted Story set so the epilogue still
-  // anchors comments / audit roster without requiring `--run`.
+  // Positional delivery has no plan-run label: synthesize a stable adhoc id.
   const effectiveRunId =
     runId ??
     `adhoc-${[...ids].sort((a, b) => Number(a) - Number(b)).join('-')}`;
 
   const steps = [
-    {
-      kind: 'audit-roster',
-      description: `Select cross-Story audit lenses for run ${effectiveRunId}`,
-      stories: ids,
-    },
+    ...(auditRoster
+      ? [
+          {
+            kind: 'audit-roster',
+            description: `Select cross-Story audit lenses for run ${effectiveRunId}`,
+            stories: ids,
+          },
+        ]
+      : []),
     {
       kind: 'follow-up-rollup',
       description: `Friction follow-up roll-up for run ${effectiveRunId}`,
       stories: ids,
     },
-    {
-      kind: 'sibling-coherence',
-      description: `Sibling-coherence check across the ${ids.length} Story specs of run ${effectiveRunId}`,
-      stories: ids,
-    },
     {
       kind: 'epic-close',
       description: `Report the container Epic state the land tails of run ${effectiveRunId} left behind`,
@@ -220,10 +191,7 @@ export function planRunEpilogue({ planRunId, stories } = {}) {
 }
 
 /**
- * How many first-parent commits of the base ref to scan when looking for the
- * run's landed squash-merges. The epilogue fires immediately after the run's
- * last Story lands, so the run's merges sit within the first handful of
- * commits; the limit only bounds the pathological case.
+ * The run's merges sit near the tip; this only bounds the pathological case.
  * @type {number}
  */
 const BASE_SCAN_LIMIT = 500;
@@ -232,8 +200,7 @@ const BASE_SCAN_LIMIT = 500;
 const FIELD_SEP = '\x1f';
 
 /**
- * Read the base ref's first-parent history as `{ sha, parents, subject }`
- * records, newest-first.
+ * Newest-first.
  *
  * @param {object} args
  * @param {string} args.cwd
@@ -283,35 +250,12 @@ function readFirstParentHistory({ cwd, baseRef, scanLimit, git }) {
   return { ok: true, commits };
 }
 
-/**
- * One trailing `(#<n>)` / `(refs #<n>)` marker, anchored at the end of what
- * is left of a subject after the markers to its right have been peeled off.
- */
 const TRAILING_MARKER_RE = /\s*\((?:refs\s+)?#(\d+)\)$/;
 
 /**
- * Peel the **trailing run** of `(#<n>)` markers off a squash subject.
- *
- * The shape this parses is fixed by the close pipeline plus GitHub: the PR
- * title `normalizePrTitle` writes ends with `(#<storyId>)`, and GitHub's
- * squash appends ` (#<prNumber>)` to it — so a landed Story merge reads
- * `<subject> (#<storyId>) (#<prNumber>)` and the Story's own marker is the
- * *second-to-last* marker, not the last one. Both are returned; the caller
- * decides which ids it cares about.
- *
- * Why the trailing run rather than a substring scan (the bug this replaces):
- * `subject.includes('(#101)')` matched the id **anywhere**, so an unrelated
- * later commit quoting an old marker — canonically a revert, whose subject
- * embeds the reverted title verbatim: `revert: "fix: x (#101) (#900)" (#950)`
- * — anchored the run on a far-older commit and inflated the roster diff with
- * everything in between. Peeling from the right stops at the first character
- * that is not part of a marker (the closing quote, above), so a quoted marker
- * is structurally out of reach.
- *
- * The `refs #` form is accepted because it is the other PR-title shape this
- * repo's own history carries (`feat(x): … (refs #4575) (#4582)`) — the
- * `refs #<id>` convention from `rules/git-conventions.md`. A plain substring
- * scan for `(#4575)` never matched those at all.
+ * Peel the trailing run of `(#<n>)` / `(refs #<n>)` markers off a squash
+ * subject (`<title> (#<storyId>) (#<prNumber>)`). Only the trailing run
+ * counts, so a revert quoting an old title can't anchor the run on an ancient commit.
  *
  * @param {string} subject
  * @returns {number[]} Marker ids, right-to-left (PR number first).
@@ -328,27 +272,15 @@ function trailingMarkerIds(subject) {
 }
 
 /**
- * Resolve the **pre-run base sha**: the commit the base branch pointed at
- * before the run's first Story landed.
- *
- * Why not `origin/main...HEAD` (the bug this replaces): the epilogue runs
- * *after* the run's last Story lands, so HEAD in the main checkout is either
- * `origin/main` itself or an ancestor of it. The three-dot merge-base is then
- * HEAD, and the diff is empty **by construction** — it never reported the
- * run's real diff. Rolling HEAD back does not help, so branch-reaping /
- * cleanup ordering is not the cause; the refs being compared are.
- *
- * The derivation walks the base ref's first-parent history for the run's
- * landed squash-merges. Every Story PR title carries a `(#<storyId>)` suffix
- * (guaranteed by `normalizePrTitle` in the close pipeline) and GitHub uses the
- * PR title as the squash subject, so the marker is a reliable, offline handle
- * that does **not** depend on the Story branches still existing. The earliest
- * such merge's first parent is the pre-run base.
+ * The commit the base pointed at before the run's first Story landed: the
+ * first parent of the earliest first-parent squash-merge carrying a run
+ * Story's `(#<storyId>)` marker. `origin/main...HEAD` would be empty by
+ * construction, since the epilogue runs after the last land.
  *
  * @param {object} args
- * @param {Array<string|number>} args.stories - Story ids in the run.
+ * @param {Array<string|number>} args.stories
  * @param {string} args.cwd
- * @param {string} [args.baseRef] - Remote-tracking base ref, e.g. `origin/main`.
+ * @param {string} [args.baseRef] - e.g. `origin/main`.
  * @param {number} [args.scanLimit]
  * @param {{ gitSpawn: Function }} [args.git]
  * @returns {{ resolved: true, baseSha: string, mergeSha: string, storyId: number, baseRef: string }
@@ -378,8 +310,7 @@ export function resolveRunBaseSha({
     return { resolved: false, baseRef, reason: history.reason };
   }
 
-  // `git log` is newest-first; walk backwards so the first hit is the
-  // *earliest* merge belonging to the run.
+  // Walk oldest-first so the first hit is the run's earliest merge.
   const wanted = new Set(ids);
   for (let i = history.commits.length - 1; i >= 0; i -= 1) {
     const commit = history.commits[i];
@@ -414,8 +345,6 @@ export function resolveRunBaseSha({
 }
 
 /**
- * List the files the run changed: `<pre-run base>...<baseRef>`.
- *
  * @returns {{ ok: true, files: string[] } | { ok: false, reason: string }}
  */
 function listChangedFiles({ cwd, baseSha, headRef, git }) {
@@ -444,8 +373,7 @@ function listChangedFiles({ cwd, baseSha, headRef, git }) {
 }
 
 /**
- * Resolve the run's combined landed diff, or an explicit reason it could not
- * be computed. Never conflates "could not compute" with "zero files changed".
+ * Never conflates "could not compute" with "zero files changed".
  *
  * @returns {{ resolved: boolean, changedFiles: string[], baseSha: string|null,
  *             mergeSha: string|null, baseRef: string, reason: string|null }}
@@ -489,8 +417,7 @@ function resolveCombinedDiff({ stories, cwd, baseRef, git }) {
 }
 
 /**
- * The diff line of the roster comment. An unresolved base MUST read as a
- * loud failure, never as `Changed files considered: 0`.
+ * An unresolved base reads as a loud failure, never as zero files.
  *
  * @param {ReturnType<typeof resolveCombinedDiff>} diff
  * @returns {string[]}
@@ -526,48 +453,18 @@ function resolveBaseRef(config) {
   return `origin/${branch}`;
 }
 
-async function executeAuditRoster({
+/**
+ * @param {object} args
+ * @returns {string}
+ */
+function renderAuditRosterBody({
   planRunId,
   stories,
-  cwd,
-  provider,
-  config,
-  git,
-  selectAuditsFn,
+  diff,
+  lensGrounding,
+  selectedAudits,
 }) {
-  const primaryId = Number(stories[0]);
-  const diff = resolveCombinedDiff({
-    stories,
-    cwd,
-    baseRef: resolveBaseRef(config),
-    git,
-  });
-  // Hand `selectAudits` the change set we just resolved — never a git range for
-  // it to re-derive. This function runs in the main checkout *after* the run's
-  // Stories merged, so every range it could name (`main...HEAD`) is empty by
-  // construction; asking for one is how the roster came to select lenses from
-  // zero files while printing the correct file list beside them (Story #4571).
-  const lensGrounding = diff.resolved ? 'diff' : 'keyword-only';
-  let selectedAudits = [];
-  if (Number.isInteger(primaryId) && primaryId > 0) {
-    const selected = await selectAuditsFn({
-      ticketId: primaryId,
-      gate: 'gate3',
-      provider,
-      changedFiles: diff.resolved ? diff.changedFiles : [],
-    });
-    selectedAudits = Array.isArray(selected?.selectedAudits)
-      ? selected.selectedAudits
-      : Array.isArray(selected)
-        ? selected
-        : [];
-  }
-  if (!diff.resolved) {
-    Logger.warn(
-      `[run-epilogue] plan-run ${planRunId}: combined landed diff unavailable — ${diff.reason}`,
-    );
-  }
-  const body = [
+  return [
     '### plan-run-audit-roster',
     '',
     `Cross-Story audit roster for plan-run \`${planRunId}\`.`,
@@ -580,11 +477,7 @@ async function executeAuditRoster({
       ? selectedAudits.map((lens) => `- \`${lens}\``)
       : ['- _(none — docs-only or no matching change-set lenses)_']),
     '',
-    // Story #4949 — the roster used to name the lenses and say nothing about
-    // how to dispatch them, which made a serial walk (and a nested
-    // coordinator) fully compliant with it. The lenses are read-only and share
-    // no write paths, so they are the textbook independent fan-out; naming the
-    // shape here is what turns that from an option into the instruction.
+    // Lenses are read-only and independent; state the fan-out shape explicitly.
     '**Dispatch shape (MUST): flat, parallel, one turn.** Spawn one ' +
       '`auditor` sub-agent per lens listed above and issue every one of those ' +
       'spawns in a SINGLE turn — no nested fan-out, no serial walk. A ' +
@@ -613,6 +506,53 @@ async function executeAuditRoster({
     ),
     '```',
   ].join('\n');
+}
+
+async function executeAuditRoster({
+  planRunId,
+  stories,
+  cwd,
+  provider,
+  config,
+  git,
+  selectAuditsFn,
+}) {
+  const primaryId = Number(stories[0]);
+  const diff = resolveCombinedDiff({
+    stories,
+    cwd,
+    baseRef: resolveBaseRef(config),
+    git,
+  });
+  // Pass the resolved change set, never a range: post-merge, any range
+  // `selectAudits` could derive is empty by construction.
+  const lensGrounding = diff.resolved ? 'diff' : 'keyword-only';
+  let selectedAudits = [];
+  if (Number.isInteger(primaryId) && primaryId > 0) {
+    const selected = await selectAuditsFn({
+      ticketId: primaryId,
+      gate: 'gate3',
+      provider,
+      changedFiles: diff.resolved ? diff.changedFiles : [],
+    });
+    selectedAudits = Array.isArray(selected?.selectedAudits)
+      ? selected.selectedAudits
+      : Array.isArray(selected)
+        ? selected
+        : [];
+  }
+  if (!diff.resolved) {
+    Logger.warn(
+      `[run-epilogue] plan-run ${planRunId}: combined landed diff unavailable — ${diff.reason}`,
+    );
+  }
+  const body = renderAuditRosterBody({
+    planRunId,
+    stories,
+    diff,
+    lensGrounding,
+    selectedAudits,
+  });
   if (Number.isInteger(primaryId) && primaryId > 0) {
     await upsertStructuredComment(
       provider,
@@ -624,14 +564,9 @@ async function executeAuditRoster({
   return {
     kind: 'audit-roster',
     selectedAudits,
-    // Whether the lenses above were chosen from the run's landed files
-    // (`diff`) or, with no resolvable base, from the primary Story's prose
-    // alone (`keyword-only`). The two are not interchangeable: a keyword-only
-    // roster cannot select a lens that declares no keywords, so its silence
-    // about a lens says nothing about the code.
+    // A keyword-only roster's silence about a lens says nothing about the code.
     lensGrounding,
-    // `null` — not `0` — when unresolved: a zero count must only ever mean
-    // "the run genuinely changed nothing".
+    // `null`, not `0`, when unresolved.
     changedFileCount: diff.resolved ? diff.changedFiles.length : null,
     changedFiles: diff.resolved ? diff.changedFiles : null,
     baseResolution: {
@@ -644,31 +579,19 @@ async function executeAuditRoster({
   };
 }
 
-async function executeFollowUpRollup({
+/**
+ * @param {object} args
+ * @returns {object}
+ */
+function composeRunProposals({
+  primaryId,
   planRunId,
   stories,
-  provider,
+  signals,
   config,
-  cwd,
-  graduateFn = graduateRetroProposals,
 }) {
-  // Shared with the story-scoped gather (Story #4649): `storyId` + `details`
-  // are what the composer's recovery-netting keys on, and two hand-rolled
-  // copies of this loop are how they got dropped in the first place.
-  const { signals, window: frictionWindow } = await gatherRunFrictionSignals(
-    stories,
-    config,
-  );
   const repos = resolveFollowUpRepos(config);
-  const primaryId = Number(stories[0]);
-  // Story #4850 — `runToken` and `anchorStoryIds` are INPUTS. This used to
-  // compose with the primary Story's numeric id standing in for the run and
-  // then rewrite the rendered title/body by regex over a `plan-run \d+`
-  // substring, which meant the composer's own wording could not be changed
-  // without silently breaking the patch. `anchorStoryIds` is what lets the
-  // composer tell a corpus confined to this run from one spanning the whole
-  // surviving window, so it never titles the latter as if it were the former.
-  const proposals = composeRoutedProposals({
+  return composeRoutedProposals({
     anchorId: Number.isInteger(primaryId) ? primaryId : 1,
     anchorKind: 'run',
     runToken: String(planRunId ?? ''),
@@ -678,18 +601,61 @@ async function executeFollowUpRollup({
     signals,
     unresolvedBlockedEvents: [],
   });
-  const graduated = await graduateFn({
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+function fileRunProposals({
+  primaryId,
+  proposals,
+  provider,
+  config,
+  cwd,
+  graduateFn,
+}) {
+  const repos = resolveFollowUpRepos(config);
+  return graduateFn({
     epicId: primaryId,
     provider,
     config,
     currentRepo: repos.currentRepo,
-    // The resolved bucket object, not a re-split of the slug: routing is
-    // decided once in `github/framework-repo.js`.
     frameworkRepo: repos.repos.framework,
     platformRepo: repos.repos.platform,
     routedProposals: proposals,
     cwd,
   });
+}
+
+async function executeFollowUpRollup({
+  planRunId,
+  stories,
+  provider,
+  config,
+  cwd,
+  graduateFn = graduateRetroProposals,
+}) {
+  const { signals, window: frictionWindow } = await gatherRunFrictionSignals(
+    stories,
+    config,
+  );
+  const primaryId = Number(stories[0]);
+  const proposals = composeRunProposals({
+    primaryId,
+    planRunId,
+    stories,
+    signals,
+    config,
+  });
+  const graduated = await fileRunProposals({
+    primaryId,
+    proposals,
+    provider,
+    config,
+    cwd,
+    graduateFn,
+  });
   const categories = summarizeSignalCategories(signals);
   const proposalCount = proposals.framework.length + proposals.consumer.length;
   const outcome = assessRollupOutcome({
@@ -700,55 +666,97 @@ async function executeFollowUpRollup({
     filingErrors: graduated.errors,
     filingSkipped: graduated.skipped,
   });
-  if (Number.isInteger(primaryId) && primaryId > 0) {
-    const body = buildFollowUpsCommentBody({
-      storyId: primaryId,
-      proposals,
-      graduated,
-      // Story #4578 — the run's Story count is what lets an empty roll-up
-      // render as a flagged claim ("0 signals across N Stories") rather than
-      // as "nothing to follow up".
-      storyCount: stories.length,
-      // Story #4828 — and the corpus is what lets a zero-proposal or
-      // zero-filed roll-up name what it saw instead of rendering as clean.
-      signalCount: signals.length,
-      categories,
-    }).replace(
-      `from Story #${primaryId}`,
-      `from plan-run \`${planRunId}\` (primary Story #${primaryId})`,
-    );
-    await upsertStructuredComment(provider, primaryId, 'follow-ups', body);
-  }
+  await publishRunRollup({
+    primaryId,
+    planRunId,
+    provider,
+    config,
+    proposals,
+    graduated,
+    storyCount: stories.length,
+    signalCount: signals.length,
+    categories,
+    filedCount: graduated.filed?.length ?? 0,
+  });
+  return buildRollupStepResult({
+    signals,
+    storyCount: stories.length,
+    graduated,
+    proposals,
+    proposalCount,
+    categories,
+    outcome,
+    frictionWindow,
+  });
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<void>}
+ */
+async function publishRunRollup({
+  primaryId,
+  planRunId,
+  provider,
+  config,
+  proposals,
+  graduated,
+  storyCount,
+  signalCount,
+  categories,
+  filedCount,
+}) {
+  if (!Number.isInteger(primaryId) || primaryId <= 0) return;
+  const body = buildFollowUpsCommentBody({
+    storyId: primaryId,
+    proposals,
+    graduated,
+    storyCount,
+    signalCount,
+    categories,
+  }).replace(
+    `from Story #${primaryId}`,
+    `from plan-run \`${planRunId}\` (primary Story #${primaryId})`,
+  );
+  await publishFollowUpsRollup({
+    anchorId: primaryId,
+    body,
+    filedCount,
+    provider,
+    config,
+  });
+}
+
+/**
+ * The step result carries every suspect flag so the CLI never regexes the
+ * comment body.
+ *
+ * @param {object} args
+ * @returns {object}
+ */
+function buildRollupStepResult({
+  signals,
+  storyCount,
+  graduated,
+  proposals,
+  proposalCount,
+  categories,
+  outcome,
+  frictionWindow,
+}) {
   return {
     kind: 'follow-up-rollup',
     signalCount: signals.length,
-    storyCount: stories.length,
+    storyCount,
     filed: graduated.filed?.length ?? 0,
-    // Story #4850 — the recurrence window the gather actually applied, and what
-    // it dropped. `signalCount` alone cannot distinguish "the window is bounded
-    // at 30 days and 40 rows aged out" from "nothing older exists", and an
-    // operator triaging a roll-up needs to know which corpus produced it.
+    // What the age window excluded, so a bounded corpus is distinguishable.
     frictionWindow,
-    // Story #4828 — everything below is what the roll-up saw and what became
-    // of it. The pre-#4828 result reported `signalCount` and `filed` and
-    // nothing in between, so nine signals routing into one proposal whose
-    // every filing attempt errored rendered as `{signalCount: 9, filed: 0,
-    // discarded: []}` — arithmetically consistent, and indistinguishable from
-    // a run with nothing to do.
     proposalCount,
-    // The categories the corpus actually contained, so a zero-proposal
-    // roll-up names its own input rather than asserting emptiness.
     categories,
     filingErrors: Array.isArray(graduated.errors) ? graduated.errors : [],
     filingSkipped: outcome.blockingSkipReasons,
-    // Signals in, nothing out — not even a below-threshold row.
     zeroProposalSuspect: outcome.zeroProposals,
-    // Proposals cleared the threshold and the filer produced none of them.
     unfiledProposalSuspect: outcome.unfiledProposals,
-    // Story #4824 — a roll-up that discards every candidate must still name
-    // what it discarded. Rendering that as "nothing to follow up" is how a
-    // defect recurring once per Story survived eighteen consecutive Stories.
-    // Surfaced on the step result so the CLI need not regex the comment body.
     discarded: proposals.discarded.map((item) => ({
       category: item.category,
       occurrences: item.occurrences,
@@ -757,93 +765,12 @@ async function executeFollowUpRollup({
       tools: item.tools ?? [],
       fingerprint: item.fingerprint ?? null,
     })),
-    // Story #4578 — zero signals across a multi-Story run is a claim, not a
-    // clean bill of health. Surfaced on the step result so the CLI can warn
-    // the operator without re-deriving it from the comment prose.
-    emptyRollupSuspect: signals.length === 0 && stories.length > 1,
+    emptyRollupSuspect: signals.length === 0 && storyCount > 1,
   };
 }
 
-function extractSection(body, heading) {
-  if (typeof body !== 'string') return '';
-  const re = new RegExp(
-    `(?:^|\\n)## ${heading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`,
-    'i',
-  );
-  const match = body.match(re);
-  return match ? match[1].trim() : '';
-}
-
-async function executeSiblingCoherence({ planRunId, stories, provider }) {
-  const findings = [];
-  const bodies = [];
-  for (const raw of stories) {
-    const sid = Number(raw);
-    if (!Number.isInteger(sid) || sid <= 0) continue;
-    const ticket = await provider.getTicket(sid);
-    bodies.push({
-      id: sid,
-      title: ticket?.title ?? '',
-      acceptance: extractSection(ticket?.body ?? '', 'Acceptance'),
-      spec: extractSection(ticket?.body ?? '', 'Spec'),
-    });
-  }
-  const withAcceptance = bodies.filter((b) => b.acceptance.length > 0);
-  if (withAcceptance.length > 0 && withAcceptance.length < bodies.length) {
-    const missing = bodies
-      .filter((b) => b.acceptance.length === 0)
-      .map((b) => `#${b.id}`);
-    findings.push(
-      `Stories missing ## Acceptance while siblings declare ACs: ${missing.join(', ')}`,
-    );
-  }
-  // Detect identical non-empty Spec blobs (likely copy-paste drift).
-  const specMap = new Map();
-  for (const b of bodies) {
-    if (!b.spec) continue;
-    const key = b.spec.replace(/\s+/g, ' ').slice(0, 400);
-    if (!specMap.has(key)) specMap.set(key, []);
-    specMap.get(key).push(b.id);
-  }
-  for (const ids of specMap.values()) {
-    if (ids.length > 1) {
-      findings.push(
-        `Duplicate ## Spec prose across Stories ${ids.map((id) => `#${id}`).join(', ')} — split or dedupe.`,
-      );
-    }
-  }
-  const primaryId = Number(stories[0]);
-  const body = [
-    '### plan-run-sibling-coherence',
-    '',
-    `Sibling-coherence check for plan-run \`${planRunId}\`.`,
-    '',
-    findings.length === 0
-      ? '_No coherence findings._'
-      : findings.map((f) => `- ${f}`).join('\n'),
-    '',
-    '```json',
-    JSON.stringify(
-      { planRunId, stories: stories.map(Number), findings },
-      null,
-      2,
-    ),
-    '```',
-  ].join('\n');
-  if (Number.isInteger(primaryId) && primaryId > 0) {
-    await upsertStructuredComment(
-      provider,
-      primaryId,
-      'plan-run-sibling-coherence',
-      body,
-    );
-  }
-  return { kind: 'sibling-coherence', findings };
-}
-
 /**
- * Execute the per-run epilogue. Throws only on programmer misuse; step
- * failures are collected into `errors[]`.
+ * Throws only on programmer misuse; step failures collect into `errors[]`.
  *
  * @param {object} args
  * @param {string} args.planRunId
@@ -851,11 +778,10 @@ async function executeSiblingCoherence({ planRunId, stories, provider }) {
  * @param {object} args.provider
  * @param {object} [args.config]
  * @param {string} [args.cwd]
- * @param {{ gitSpawn: Function }} [args.git] - Injection seam for tests.
- * @param {typeof selectAudits} [args.selectAuditsFn] - Injection seam for tests.
- * @param {typeof graduateRetroProposals} [args.graduateFn] - Injection seam so
- *   the roll-up's reporting layer can be asserted against a filer that fails
- *   (Story #4828) without spawning a real `gh`.
+ * @param {{ gitSpawn: Function }} [args.git]
+ * @param {typeof selectAudits} [args.selectAuditsFn]
+ * @param {typeof graduateRetroProposals} [args.graduateFn]
+ * @param {boolean} [args.auditRoster] Default `false`.
  * @returns {Promise<object>}
  */
 export async function runPlanRunEpilogue({
@@ -867,8 +793,9 @@ export async function runPlanRunEpilogue({
   git = { gitSpawn },
   selectAuditsFn = selectAudits,
   graduateFn = graduateRetroProposals,
+  auditRoster = false,
 } = {}) {
-  const plan = planRunEpilogue({ planRunId, stories });
+  const plan = planRunEpilogue({ planRunId, stories, auditRoster });
   if (!plan.applicable) {
     return { ...plan, results: [], errors: [] };
   }
@@ -903,14 +830,6 @@ export async function runPlanRunEpilogue({
             graduateFn,
           }),
         );
-      } else if (step.kind === 'sibling-coherence') {
-        results.push(
-          await executeSiblingCoherence({
-            planRunId: plan.planRunId,
-            stories: plan.stories,
-            provider,
-          }),
-        );
       } else if (step.kind === 'epic-close') {
         results.push(
           await executeEpicClose({ stories: plan.stories, provider }),