mandrel 2.56.0 → 2.58.0

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

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 
 /**
- * plan-critics.js — the /mandrel-plan critic-dispatch verdict CLI (Story #4592).
+ * plan-critics.js — the /mandrel-plan pre-mortem dispatch verdict CLI
+ * (Story #4592; pre-mortem only since Story #5312).
  *
- * `/mandrel-plan` step 2.5 (between Author and Persist) runs this against the draft
- * `stories.json`. It evaluates the consolidation + pre-mortem dispatch
- * conditions and prints the verdict as JSON on stdout so the workflow can
+ * The operator runs this between Author and Persist when they want the
+ * pre-mortem — it is no longer a step of the `/mandrel-plan` spine. It
+ * evaluates the pre-mortem dispatch condition against the draft
+ * `stories.json` and prints the verdict as JSON on stdout so the workflow can
  * act on it — dispatching a fresh-context critic sub-agent and folding its
  * findings into a re-author round **before** the plan is persisted.
  *
@@ -28,21 +30,15 @@
  *
  * CLI:
  *   --stories <file>     Required. The draft Story ticket array (JSON).
- *   --tech-spec <file>   Optional. Shared Tech Spec carrying the
- *                        `## Delivery Slicing` table the consolidation
- *                        precondition reads.
+ *   --tech-spec <file>   Optional. Shared Tech Spec, folded into the plan
+ *                        text the external-dependency probe scans.
  *
  * stdout is reserved for the verdict JSON (Story #2278 discipline):
  *
  *   {
- *     "consolidation": { "critic": "consolidation", "dispatch": false, "reasons": [...] },
- *     "premortem":     { "critic": "pre-mortem",    "dispatch": true,  "reasons": [...] },
- *     "textHygiene":   { "critic": "text-hygiene",  "findings": [...] }
+ *     "premortem": { "critic": "pre-mortem", "dispatch": true, "reasons": [...] }
  *   }
  *
- * `textHygiene` (Story #4599) is advisory-only: deterministic body lints with
- * no dispatch semantics — its findings fold into the re-author round.
- *
  * Human-readable log lines go to stderr, matching the sibling `plan-persist`.
  *
  * Exit codes: 0 success (any verdict); 1 usage/IO error.
@@ -192,11 +188,11 @@ export async function loadCriticArtifacts({
 }
 
 /**
- * Log each decision and record every skip on the plan-metrics ledger. The
+ * Log the decision and record a skip on the plan-metrics ledger. The
  * ledger write is best-effort by `appendCriticSkip`'s own contract — it can
  * never fail the plan step.
  *
- * @param {{ consolidation: object, premortem: object, textHygiene?: object }} verdict
+ * @param {{ premortem: object }} verdict
  * @param {object} config
  * @param {{ append?: typeof appendCriticSkip }} [deps]
  * @returns {Promise<void>}
@@ -206,48 +202,26 @@ export async function recordCriticSkips(
   config,
   { append = appendCriticSkip } = {},
 ) {
-  for (const decision of [verdict.consolidation, verdict.premortem]) {
-    Logger.info(
-      `[plan-critics] critic ${decision.critic}: ` +
-        `${decision.dispatch ? 'dispatch' : 'skip'} — ` +
-        decision.reasons.join('; '),
-    );
-    if (!decision.dispatch) {
-      await append(
-        {
-          critic: decision.critic,
-          reasons: decision.reasons,
-          cli: PLAN_CRITICS_CLI,
-        },
-        config,
-      );
-    }
-  }
-
-  // Text hygiene (Story #4599) is advisory-only — no dispatch semantics, so
-  // "skip" here means "zero findings". Recording that keeps the lint's
-  // fire/skip accounting on the same ledger as the dispatching critics.
-  const hygiene = verdict.textHygiene;
-  if (hygiene) {
-    const count = hygiene.findings.length;
-    Logger.info(
-      `[plan-critics] critic ${hygiene.critic}: ${count} finding(s) (advisory).`,
+  const decision = verdict.premortem;
+  Logger.info(
+    `[plan-critics] critic ${decision.critic}: ` +
+      `${decision.dispatch ? 'dispatch' : 'skip'} — ` +
+      decision.reasons.join('; '),
+  );
+  if (!decision.dispatch) {
+    await append(
+      {
+        critic: decision.critic,
+        reasons: decision.reasons,
+        cli: PLAN_CRITICS_CLI,
+      },
+      config,
     );
-    if (count === 0) {
-      await append(
-        {
-          critic: hygiene.critic,
-          reasons: ['No text-hygiene findings over the draft stories.'],
-          cli: PLAN_CRITICS_CLI,
-        },
-        config,
-      );
-    }
   }
 }
 
 /**
- * Load the artifacts, evaluate both critics, record the skips, and return the
+ * Load the artifacts, evaluate the pre-mortem, record a skip, and return the
  * verdict. Exported as the CLI's whole body so tests drive it in-process with
  * an explicit config and ledger seam.
  *
@@ -262,7 +236,7 @@ export async function recordCriticSkips(
  *   manifests declare, forwarded to the pre-mortem external-dependency probe
  *   (Story #4700). `main()` resolves them via `collectRepoPackages`; tests may
  *   pass an explicit set or omit it (defaults to `[]`).
- * @returns {Promise<{ consolidation: object, premortem: object, textHygiene: object }>}
+ * @returns {Promise<{ premortem: object }>}
  */
 export async function evaluateCriticArtifacts({
   storiesPath,
@@ -316,7 +290,7 @@ runAsCli(import.meta.url, main, {
     invocation:
       'node .agents/scripts/plan-critics.js --stories <file> [--tech-spec <file>]',
     summary:
-      'Score an authored plan draft with the maker-blind critics and print the verdict JSON on stdout.',
+      'Decide whether the maker-blind pre-mortem critic should run on an authored plan draft and print the verdict JSON on stdout.',
     flags: [
       ['--stories <file>', 'Authored stories.json (required).'],
       ['--tech-spec <file>', 'Optional companion techspec.md.'],

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

@@ -7,8 +7,8 @@
  * Given the author-written planning artifacts (`stories.json`, optional shared
  * Tech Spec), this CLI validates and creates Story issue(s) directly:
  *
- *   ticket validator / DAG / capacity → reachability →
- *   split-policy partition → fold/spill Spec into each Story body →
+ *   changes[] repair → ticket validator / DAG → reachability →
+ *   split-policy partition → fold Spec into each Story body →
  *   createIssue(s) with type::story, resumably by plan fingerprint (NOT
  *   agent::ready) → story-plan-state on every Story;
  *   plan-summary on the primary → flip every Story to agent::ready →
@@ -34,31 +34,23 @@
  *                             ids, for hand-driven runs. Each id must be
  *                             claimed by exactly one Story's `supersedes[]`;
  *                             they are commented on and closed as superseded
- *   --route-downgrade-reason <text>
- *                             Audited planner downgrade (Story #4707): treat
- *                             the envelope's `full` complexity verdict as
- *                             `lite`, recording <text> on every Story's
- *                             story-plan-state checkpoint. Absent this flag
- *                             the deterministic verdict stands; the gate
- *                             itself still fails toward `full`
  *   --no-close-superseded     Keep the source tickets open (no comment, no
  *                             close) — for a genuinely partial supersede
  *   --dry-run                 Assemble + validate without GitHub writes
- *   --chain-on-clean          Plan-diet fast path (Story #4741): run the
- *                             write-free dry-run first, and — only when it
- *                             passes clean AND the plan resolves to the `lite`
- *                             route — chain straight into the real persist in
- *                             the SAME invocation, collapsing the two operator
- *                             round-trips into one. A dry-run failure stops
- *                             before any createIssue; a full-route plan keeps
- *                             its review round-trip (the chain declines, no
- *                             writes). Ignored when `--dry-run` is also set
+ *   --chain-on-clean          Fast path (Story #4741; any plan since Story
+ *                             #5312): run the write-free dry-run first, and
+ *                             when it passes clean chain straight into the
+ *                             real persist in the SAME invocation, collapsing
+ *                             the two operator round-trips into one. A
+ *                             dry-run failure stops before any createIssue.
+ *                             Ignored when `--dry-run` is also set
  *   --force-review            Operator-forced review stop before persist lands
- *   --allow-over-budget / --allow-large-fan-out
  *
- * Run `--dry-run` first. It exercises every gate — validator, DAG, capacity,
- * budget, reachability, split/supersede partition, Spec fold — write-free, so
- * an authoring mistake surfaces before a single issue exists.
+ * Run `--dry-run` first. It exercises every gate — the changes[] repair, the
+ * validator, DAG, reachability, split/supersede partition, Spec fold —
+ * write-free, and lists every warning (a footprint probe that disagrees with
+ * the base branch, an open question in a body) so an authoring mistake
+ * surfaces before a single issue exists.
  *
  * stdout is reserved for the JSON result (Story #2278 discipline, extended to
  * this CLI by Story #4541): `routeAllOutputToStderr()` runs before any
@@ -116,14 +108,11 @@ const CLI_OPTIONS = {
   'plan-context': { type: 'string' },
   'plan-acceptance': { type: 'string' },
   'source-tickets': { type: 'string' },
-  'route-downgrade-reason': { type: 'string' },
   'close-superseded': { type: 'boolean', default: true },
   'no-close-superseded': { type: 'boolean', default: false },
   'dry-run': { type: 'boolean', default: false },
   'chain-on-clean': { type: 'boolean', default: false },
   'force-review': { type: 'boolean', default: false },
-  'allow-over-budget': { type: 'boolean', default: false },
-  'allow-large-fan-out': { type: 'boolean', default: false },
   'epic-title': { type: 'string' },
   'epic-goal': { type: 'string' },
   epic: { type: 'string' },
@@ -134,9 +123,7 @@ const USAGE =
   '[--tech-spec <file>] [--plan-dir <dir>] [--plan-context <file>] ' +
   '[--plan-acceptance <file>] ' +
   '[--source-tickets <ids>] [--no-close-superseded] ' +
-  '[--route-downgrade-reason <text>] ' +
   '[--dry-run] [--chain-on-clean] [--force-review] ' +
-  '[--allow-over-budget] [--allow-large-fan-out] ' +
   '[--epic-title <text> --epic-goal <text> | --epic <id>]';
 
 async function readOptional(filePath, { required }) {
@@ -293,14 +280,11 @@ export function buildPersistOptions(values, paths, planContextEnvelope) {
 
   return {
     forceReview: values['force-review'],
-    allowOverBudget: values['allow-over-budget'],
-    allowLargeFanOut: values['allow-large-fan-out'],
     dryRun: values['dry-run'],
     planDir: paths.planDir,
     skipCleanup: values['dry-run'],
     sourceTicketIds: source.ids,
     sourceTicketOrigin: source.origin,
-    routeDowngradeReason: values['route-downgrade-reason'] ?? null,
     epic: resolveEpicRequest(values),
     adoptEpicId: resolveEpicAdoptionId(values),
     // Default-on: `--no-close-superseded` is the explicit escape and always
@@ -323,12 +307,6 @@ async function runPersistInvocation({
   const paths = resolveInputPaths(values);
   const effectiveDryRun =
     typeof dryRun === 'boolean' ? dryRun : values['dry-run'] === true;
-  const settings = {
-    baseBranch: config.project?.baseBranch,
-    paths: config.project?.paths,
-    planning: config.planning,
-    docsContextFiles: config.project?.docsContextFiles,
-  };
 
   return recordPlanInvocation(
     {
@@ -341,7 +319,6 @@ async function runPersistInvocation({
         provider,
         artifacts,
         config,
-        settings,
         opts: {
           ...buildPersistOptions(values, paths, artifacts.planContextEnvelope),
           dryRun: effectiveDryRun,
@@ -353,23 +330,23 @@ async function runPersistInvocation({
 }
 
 /**
- * Plan-diet fast path (Story #4741 AC-1/AC-3): chain the lite dry-run into the
- * real persist in ONE operator invocation.
+ * Fast path (Story #4741 AC-1/AC-3; widened to any plan by Story #5312):
+ * chain a clean dry-run into the real persist in ONE operator invocation.
  *
  * Two passes over the **same** loaded artifacts:
  *
  *   1. A write-free dry-run. Every gate runs before any `createIssue` can
  *      happen, so a validation failure — which throws or returns reachability
  *      orphans — stops here, before a single issue exists (AC-3).
- *   2. The real write, run **only** when the dry-run passed clean AND resolved
- *      to the `lite` route. Because it replays the identical artifacts, the
- *      persisted output is byte-identical to what the dry-run validated
- *      (AC-1). A full-route plan keeps its review round-trip: the chain
- *      declines and returns the dry-run result, mutating nothing.
+ *   2. The real write, run when the dry-run passed clean. Because it replays
+ *      the identical artifacts, the persisted output is byte-identical to
+ *      what the dry-run validated (AC-1). The lite-route condition that used
+ *      to gate this step went with the plan-side lite claim: a clean dry-run
+ *      is the review the chain exists to fold.
  *
- * Exported for tests — this is where the round-trip collapse and its
- * fail-closed guard live, so a regression here silently re-opens the second
- * operator round-trip (or worse, persists a plan the dry-run never gated).
+ * Exported for tests — this is where the round-trip collapse lives, so a
+ * regression here silently re-opens the second operator round-trip (or
+ * worse, persists a plan the dry-run never gated).
  *
  * @param {{ values: object, config: object, provider: object,
  *   artifacts: object, metricsSince: string }} args
@@ -391,20 +368,6 @@ export async function runPersistChain({
     dryRun: true,
   });
 
-  if (dryResult.route?.route !== 'lite') {
-    dryResult.chain = {
-      attempted: true,
-      persisted: false,
-      reason: 'route-not-lite',
-    };
-    Logger.info(
-      '[plan-persist] --chain-on-clean: dry-run clean but the plan did not ' +
-        'resolve to the lite route — declining the auto-persist; run persist ' +
-        'explicitly after review.',
-    );
-    return dryResult;
-  }
-
   const persistResult = await runPersistInvocation({
     values,
     config,
@@ -416,7 +379,7 @@ export async function runPersistChain({
   persistResult.chain = {
     attempted: true,
     persisted: true,
-    reason: 'lite-dry-run-clean',
+    reason: 'dry-run-clean',
   };
   return persistResult;
 }
@@ -540,10 +503,6 @@ runAsCli(import.meta.url, main, {
       ],
       ['--plan-acceptance <file>', 'Acceptance artifact to attach.'],
       ['--source-tickets <ids>', 'Ticket ids this plan supersedes.'],
-      [
-        '--route-downgrade-reason <text>',
-        'Why the authored route was downgraded.',
-      ],
       ['--dry-run', 'Validate and report; create nothing.'],
       ['--chain-on-clean', 'Persist immediately when the dry run is clean.'],
       ['--no-close-superseded', 'Leave superseded source tickets open.'],
@@ -551,8 +510,6 @@ runAsCli(import.meta.url, main, {
         '--force-review',
         'Require the review gate even when it would be skipped.',
       ],
-      ['--allow-over-budget', 'Permit a Spec over the context budget.'],
-      ['--allow-large-fan-out', 'Permit a Story count above the fan-out gate.'],
       [
         '--epic-title <text>',
         'Group the persisted Stories under a container Epic with this title (needs --epic-goal).',

package/.agents/scripts/quality-preview.js

@@ -249,9 +249,56 @@ export function mergeEnvelopes(
         (crapEnvelope?.summary?.newViolations ?? 0),
     },
     cyclomaticFlag: flag,
+    // Story #5313: advisories ride the merge but never the exit code.
+    advisories: advisoriesOf(crapEnvelope),
   };
 }
 
+/**
+ * The cyclomatic advisories a CRAP envelope carries (Story #5313), or none.
+ *
+ * @param {{ cyclomaticAdvisories?: unknown } | null | undefined} crapEnvelope
+ * @returns {Array<{ file: string, method: string, startLine: number, cyclomatic: number }>}
+ */
+function advisoriesOf(crapEnvelope) {
+  const list = crapEnvelope?.cyclomaticAdvisories;
+  return Array.isArray(list) ? list : [];
+}
+
+/**
+ * Print the advisories block when there is one (Story #5313). Split out of
+ * `emitReport` so that function's branching stays inside its committed
+ * cyclomatic budget.
+ *
+ * @param {Array<object>} advisories
+ * @param {{ write: (s: string) => void }} stdout
+ * @returns {void}
+ */
+function writeAdvisories(advisories, stdout) {
+  const block = renderAdvisories(advisories);
+  if (block) stdout.write(`\n${block}\n`);
+}
+
+/**
+ * Render the cyclomatic advisories block (Story #5313), or `null` when the
+ * scan carried none. One line per method at or over the ceiling; the block
+ * says outright that it is advisory so a reader does not hunt for the exit
+ * code it did not change.
+ *
+ * @param {Array<{ file: string, method: string, startLine: number, cyclomatic: number }>} advisories
+ * @returns {string|null}
+ */
+export function renderAdvisories(advisories) {
+  const list = Array.isArray(advisories) ? advisories : [];
+  if (list.length === 0) return null;
+  return [
+    `Advisory — ${list.length} method(s) at cyclomatic 12 or above (reported, not a verdict; check-cyclomatic.js owns the ratchet):`,
+    ...list.map(
+      (a) => `  - ${a.file}:${a.startLine} ${a.method} (c=${a.cyclomatic})`,
+    ),
+  ].join('\n');
+}
+
 /**
  * Render the named diagnostics a gate envelope carries, or `null` when it
  * carries none (Story #4866).
@@ -286,6 +333,9 @@ export function renderDiagnostics(results) {
  * Both signals are combined so a transient gate failure (e.g. JSON write
  * error) still surfaces even if the violations array happens to be empty.
  *
+ * Advisories (`merged.advisories`, Story #5313) are deliberately not read
+ * here: a method at cyclomatic 12 or above is reported and exits 0.
+ *
  * @param {{ rows: Array<unknown>, totals: { miRegressions: number, crapViolations: number } }} merged
  * @param {number} miExit
  * @param {number} crapExit
@@ -484,6 +534,7 @@ function emitReport({
   stdout.write('\n--- quality:preview ---\n');
   stdout.write(stagedScopeLine({ staged, ref, cwd }));
   stdout.write(`${renderTable(merged)}\n`);
+  writeAdvisories(merged.advisories, stdout);
   const diagnostics = renderDiagnostics([miResult, crapResult]);
   if (diagnostics) stdout.write(`\n${diagnostics}\n`);
   if (miExit !== 0 || crapExit !== 0) {

package/.agents/scripts/run-tests.js

@@ -28,6 +28,11 @@
  * (`MAX_TARGET_CHARS`) and spawns one `node --test` process per chunk,
  * aggregating the exit codes. On POSIX the far larger
  * `POSIX_MAX_TARGET_CHARS` budget collapses every tier back into one spawn.
+ *
+ * Suite credit (Story #5313): a green full-tier run inside a `story-<id>`
+ * checkout deposits the `test` gate's evidence record — the one
+ * `single-story-close.js` reads — so a bare `npm test` in the worktree is
+ * credited at unchanged HEAD. See `lib/test-run-credit.js`.
  */
 
 import { spawnSync } from 'node:child_process';
@@ -37,6 +42,7 @@ import { assertNoReservedIdStreams } from './check-test-temp-hygiene.js';
 import { cleanupRepoTestTempArtifacts } from './cleanup-repo-test-temp.js';
 import { runAsCli } from './lib/cli-utils.js';
 import { buildWebhookSafeTestEnv } from './lib/test-env.js';
+import { reportTestRunCredit } from './lib/test-run-credit.js';
 import {
   resolveTestConcurrency,
   runTierPreflight,
@@ -171,6 +177,7 @@ export function runTestSuite({
   maxTargetChars = resolveMaxTargetChars(),
   fixtureStreamGuard = assertNoReservedIdStreams,
   preflight = runTierPreflight,
+  depositCredit = reportTestRunCredit,
 } = {}) {
   const { tier, rest } = parseTierArgv(argv);
 
@@ -185,6 +192,7 @@ export function runTestSuite({
   const chunks = chunkTestTargets(targets, maxTargetChars);
 
   const env = buildWebhookSafeTestEnv(process.env);
+  const startedAt = Date.now();
   let status = 0;
   let spawnError = null;
 
@@ -224,6 +232,10 @@ export function runTestSuite({
     throw spawnError;
   }
 
+  // Story #5313 — a green full run earns close's `test` credit; best-effort,
+  // never the exit code.
+  depositCredit({ cwd, tier, status, durationMs: Date.now() - startedAt });
+
   return status;
 }
 

package/.agents/scripts/stories-wave-tick.js

@@ -55,12 +55,13 @@
  *     inFlight: number,
  *     cycleError: string | null,
  *     wedged: { reason, stories: [{ id, unmetBlockers }] } | null,
- *     inFlightReservation: { available, withheld: [{ id, blockedBy, reason, source, paths, attribution }], note },
- *     footprintGuard: { mode, withheld: [{ id, blockedBy, scope, source, paths, attribution }], advisory, note }
+ *     inFlightReservation: { available, withheld: [{ id, blockedBy, reason, source, paths }], note },
+ *     footprintGuard: { mode, withheld: [{ id, blockedBy, scope, source, paths }], advisory, note }
  *   }
  *
  * `inFlightReservation` reports the cross-beat half of the co-dispatch guard
- * (Story #4875 widened the footprint; Story #4950 made it reserve). Under
+ * (Story #4950 made it reserve; Story #5313 narrowed the footprint back to
+ * the declared `changes[]`). Under
  * `--probe-live` the in-flight Stories' own records are handed to the kernel,
  * so a candidate sharing a CONCRETE path with a Story dispatched on an EARLIER
  * beat is withheld and named here with its blocker and a `reason`
@@ -75,10 +76,10 @@
  * reported nowhere: a same-beat overlap skip was a bare `continue` inside
  * `planReadySet`, so the Story vanished from `ready[]` with no field anywhere
  * naming the collision. Every entry in either report now also carries the
- * colliding `paths` and a `source` tag — `declared-overlap` when both Stories'
- * `changes[]` named the path (intended serialization: two Stories really do
- * rewrite the same generated baseline) versus `scraped-overlap` when only the
- * text evidence produced it. `mode` names the `footprintGuard` config value;
+ * colliding `paths` and a `source` tag — `declared-overlap`, the one class
+ * left since Story #5313: both Stories' `changes[]` named the path (intended
+ * serialization: two Stories really do rewrite the same generated baseline)
+ * or one declared a glob. `mode` names the `footprintGuard` config value;
  * under `advisory` the collisions are detected and listed in `advisory[]` but
  * dispatch follows the declared `depends_on` edges alone.
  *
@@ -130,10 +131,7 @@ import { AGENT_LABELS } from './lib/label-constants.js';
 import { parseIds } from './lib/orchestration/resolve-stories.js';
 import { buildStoryAdjacency } from './lib/story-adjacency.js';
 import { expandIdList } from './lib/util/parse-id-list.js';
-import {
-  OVERLAP_SOURCES,
-  renderScrapeAttribution,
-} from './lib/wave-runner/footprint.js';
+import { OVERLAP_SOURCES } from './lib/wave-runner/footprint.js';
 import {
   createProbeContext,
   probeLiveState,
@@ -240,10 +238,7 @@ Output envelope:
           "blockedBy": 4949,
           "reason": "in-flight-earlier-beat",
           "source": "declared-overlap",
-          "paths": ["lib/shared.js"],
-          "attribution": [
-            { "path": "lib/shared.js", "declared": true, "fields": [] }
-          ]
+          "paths": ["lib/shared.js"]
         }
       ],
       "note": "..."
@@ -255,15 +250,8 @@ Output envelope:
           "id": 4952,
           "blockedBy": 4951,
           "scope": "beat",
-          "source": "scraped-overlap",
-          "paths": ["lib/other.js"],
-          "attribution": [
-            {
-              "path": "lib/other.js",
-              "declared": false,
-              "fields": ["body:Verify"]
-            }
-          ]
+          "source": "declared-overlap",
+          "paths": ["lib/other.js"]
         }
       ],
       "advisory": [],
@@ -280,11 +268,9 @@ report is { available: false } and selection de-conflicts within the beat only.
 footprintGuard names each Story withheld from THIS beat by a peer already
 admitted on it — the half that used to be an unreported skip — and every
 entry in either report carries the colliding paths plus a source tag
-(declared-overlap when both changes[] declarations named the path, else
-scraped-overlap from the text evidence) and an "attribution" list naming, per
-path, the field the scrape read it from ("title", "spec", or "body:<section>"
-— so a path that reached the comparison only because every Story RUNS it in
-"## Verify" says so). Its "mode" echoes
+(declared-overlap: both changes[] declarations named the path, or one declared
+a glob — the text scrape that used to widen this was retired in Story #5313).
+Its "mode" echoes
 delivery.deliverRunner.footprintGuard: under "advisory" the collisions are
 detected and listed in "advisory" but never withhold, and dispatch follows the
 declared depends_on edges alone.
@@ -406,7 +392,6 @@ export function buildReservationReport(
       : RESERVATION_REASONS.EARLIER_BEAT,
     source: w.source ?? OVERLAP_SOURCES.DECLARED,
     paths: w.paths ?? [],
-    attribution: w.attribution ?? [],
   }));
   return {
     available: true,
@@ -438,16 +423,12 @@ export function buildReservationReport(
  */
 export function buildFootprintGuardReport(footprintWithholds, mode) {
   const ledger = Array.isArray(footprintWithholds) ? footprintWithholds : [];
-  const project = ({ id, blockedBy, scope, source, paths, attribution }) => ({
+  const project = ({ id, blockedBy, scope, source, paths }) => ({
     id,
     blockedBy,
     scope,
     source,
     paths,
-    // Story #5265: the per-path field attribution rides the entry itself, so
-    // a consumer reading the envelope never has to re-derive where a scraped
-    // path came from (and cannot get a different answer than the note did).
-    attribution: attribution ?? [],
   });
   const beat = ledger
     .filter((w) => w.scope === WITHHOLD_SCOPES.BEAT && w.enforced)
@@ -474,22 +455,19 @@ export function buildFootprintGuardReport(footprintWithholds, mode) {
 function footprintGuardNote(beat, advisory, mode) {
   const detail = (entries) =>
     entries
-      .map((w) => {
-        const scraped = renderScrapeAttribution(w.attribution);
-        const provenance = scraped ? `, scraped from ${scraped}` : '';
-        return `#${w.id} ← #${w.blockedBy} on ${w.paths.join(', ')} (${w.source}${provenance})`;
-      })
+      .map(
+        (w) =>
+          `#${w.id} ← #${w.blockedBy} on ${w.paths.join(', ')} (${w.source})`,
+      )
       .join('; ');
   if (beat.length > 0) {
     return (
       `${beat.length} Story(ies) withheld from THIS beat because their file ` +
       `footprint overlaps a peer already admitted on it — ${detail(beat)}. ` +
       `Each is still eligible and re-admits on a later beat once its peer ` +
-      `lands. A ${OVERLAP_SOURCES.SCRAPED} source means the collision came ` +
-      `from path evidence in the Story text rather than from either ` +
-      `changes[] declaration — the 'scraped from' clause names the field ` +
-      `each such path was read out of, so a path only cited in '## Verify' ` +
-      `is distinguishable from an unpredicted edit target.`
+      `lands. Both Stories declared every colliding path in changes[] (or ` +
+      `one declared a glob): since Story #5313 the guard reads declarations ` +
+      `only, never the Story text.`
     );
   }
   if (advisory.length > 0) {