mandrel 2.20.0 → 2.22.0

package/.agents/scripts/lib/orchestration/review-providers/scoped-lint.js

@@ -0,0 +1,300 @@
+/**
+ * review-providers/scoped-lint.js — the scoped-lint surface of the native
+ * review provider (extracted from `native.js` by Story #4839).
+ *
+ * ## Why this module exists
+ *
+ * The scoped-lint gate reported `executionFailed` — and therefore emitted zero
+ * findings while the review reported clean — on 18 of 23 Beestera/swarm-os
+ * Stories carrying friction (78%) and on 5 mandrel Stories. Measured
+ * 2026-07-29, the cause was **not** environmental and **not** a parse failure.
+ * Three defects in how the runners were invoked and reconciled produced the
+ * same symptom:
+ *
+ * 1. **The markdown runner was never resolvable.** The provider spawned
+ *    `npx --no markdownlint`, but the binary this project (and the consumer)
+ *    installs is `markdownlint-cli2` — `markdownlint-cli2` is the package and
+ *    the bin name; a bare `markdownlint` bin does not exist. `npx --no` with an
+ *    unresolvable bin exits 1 printing `could not determine executable to run`
+ *    and nothing else, so the summary parsed nothing and the gate degraded.
+ *    The parser was already written for **cli2's** `Summary: N error(s)` line,
+ *    so the invocation and the parser had never agreed. The `--ignore
+ *    node_modules` flag was likewise `markdownlint-cli` (v1) syntax, which
+ *    cli2 does not accept. Fix: resolve the runner from what is actually
+ *    installed and pass each candidate its own argument shape.
+ *
+ * 2. **One runner's failure poisoned the other's verdict.** The two runs were
+ *    folded into a *single* `parseLintOutput` call over concatenated output and
+ *    the maximum exit status. So the unresolvable markdown runner's exit 1
+ *    became the verdict for biome too: any change set containing at least one
+ *    `.md` file degraded the whole gate whenever biome itself had nothing to
+ *    report — i.e. exactly the clean case the gate exists to confirm. Fix:
+ *    classify each surface independently and merge structurally.
+ *
+ * 3. **Biome's "nothing in scope" exit was read as a failure.** `biome lint`
+ *    exits 1 with `No files were processed in the specified paths.` when every
+ *    supplied path is excluded by `biome.json` (`temp/`, `dist/`,
+ *    `.worktrees/`, anything in the VCS ignore file). That is an empty scope,
+ *    not a runner that could not execute. Fix: recognise the sentinel.
+ *
+ * ## What a degraded surface now produces
+ *
+ * `runScopedLint` still reports `executionFailed` — the friction-telemetry
+ * emission in `native.js` is deliberately unchanged (Story #4699 routed an
+ * unexecutable tool to telemetry so severity tiers reflect code findings only,
+ * and that intent stands). It additionally reports a `degradations[]` array
+ * naming **which** surface could not run and **why**, so the review outcome can
+ * say "this gate did not run" instead of silently reading clean.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+/** Paths these extensions land on the biome (code) runner. */
+const CODE_EXTENSIONS = /\.(js|mjs|cjs|jsx|ts|tsx|json|jsonc)$/i;
+
+/** npx's message when the requested bin cannot be resolved. */
+const NPX_UNRESOLVABLE = /could not determine executable to run/i;
+
+/** Biome's exit-1 message when every supplied path is config-excluded. */
+const BIOME_EMPTY_SCOPE = /No files were processed in the specified paths/i;
+
+/**
+ * Markdown runners in preference order, each with the argument shape *it*
+ * accepts. `markdownlint-cli2` takes bare paths/globs and rejects `--ignore`;
+ * `markdownlint` (cli v1) takes `--ignore`. Explicit changed-file paths are
+ * passed either way, so the v1 ignore flag is belt-and-braces only.
+ */
+const MARKDOWN_RUNNERS = Object.freeze([
+  Object.freeze({ bin: 'markdownlint-cli2', extraArgs: Object.freeze([]) }),
+  Object.freeze({
+    bin: 'markdownlint',
+    extraArgs: Object.freeze(['--ignore', 'node_modules']),
+  }),
+]);
+
+/** Reason codes carried on a degradation record. */
+const DEGRADATION_REASONS = Object.freeze({
+  RUNNER_NOT_INSTALLED: 'runner-not-installed',
+  RUNNER_NOT_RESOLVABLE: 'runner-not-resolvable',
+  UNPARSEABLE_OUTPUT: 'unparseable-output',
+});
+
+/**
+ * Spawn one lint runner through `npx --no` (never install on the fly).
+ *
+ * @param {string} bin
+ * @param {string[]} args
+ * @param {string} cwd
+ * @returns {{ status: number, stdout: string, stderr: string }}
+ */
+function spawnLintRunner(bin, args, cwd) {
+  const result = spawnSync('npx', ['--no', bin, ...args], {
+    cwd,
+    encoding: 'utf-8',
+    shell: process.platform === 'win32',
+  });
+  return {
+    status: result.status ?? 1,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+  };
+}
+
+/**
+ * Pure-ish: pick the first markdown runner whose bin is actually installed
+ * under `<cwd>/node_modules/.bin`. Returns `null` when none is — an honest
+ * "this surface has no runner" that the caller reports rather than silently
+ * folding into a generic parse failure.
+ *
+ * The disk probe (rather than "spawn and see") is what makes the failure
+ * *nameable*: `npx --no <missing-bin>` yields only a generic npm error, which
+ * is precisely how the defect hid for months.
+ *
+ * Not exported: it is reachable — and asserted — through {@link runScopedLint},
+ * whose `existsFn` seam drives every resolution branch.
+ *
+ * @param {string} cwd
+ * @param {(p: string) => boolean} [existsFn]  Injected for testing.
+ * @returns {{ bin: string, extraArgs: ReadonlyArray<string> }|null}
+ */
+function resolveMarkdownRunner(cwd, existsFn = existsSync) {
+  for (const candidate of MARKDOWN_RUNNERS) {
+    const base = path.join(cwd, 'node_modules', '.bin', candidate.bin);
+    if (existsFn(base)) return candidate;
+    if (
+      process.platform === 'win32' &&
+      (existsFn(`${base}.cmd`) || existsFn(`${base}.ps1`))
+    ) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+/**
+ * Pure: split changed paths into the file lists each lint runner consumes.
+ *
+ * @param {string[]} changedFiles
+ * @returns {{ code: string[], md: string[] }}
+ */
+export function partitionFilesForLint(changedFiles) {
+  const code = [];
+  const md = [];
+  for (const f of changedFiles) {
+    if (CODE_EXTENSIONS.test(f)) code.push(f);
+    else if (/\.md$/i.test(f)) md.push(f);
+  }
+  return { code, md };
+}
+
+/**
+ * Pure: classify **one** runner's result into a summary.
+ *
+ * Handles the reporter formats composing `npm run lint` here:
+ *   - Biome: `Found N error(s).` / `Found N warning(s).`
+ *   - markdownlint-cli2: a trailing `Summary: N error(s)` line.
+ *
+ * A non-zero exit whose output matches no known reporter format is "could not
+ * classify" → `executionFailed: true`, with `reason` naming what was actually
+ * observed. Biome's empty-scope exit is recognised separately as
+ * `emptyScope` — nothing to lint is not a broken runner.
+ *
+ * @param {{ status?: number, stdout?: string, stderr?: string }} result
+ * @returns {{ errors: number, warnings: number, parsed: boolean, executionFailed: boolean, emptyScope: boolean, reason: string|null }}
+ */
+export function parseLintOutput(result) {
+  const combined = `${result.stdout ?? ''}\n${result.stderr ?? ''}`;
+
+  let errors = 0;
+  let warnings = 0;
+  let parsed = false;
+
+  for (const m of combined.matchAll(/Found\s+(\d+)\s+error/gi)) {
+    errors += Number(m[1]);
+    parsed = true;
+  }
+  for (const m of combined.matchAll(/Found\s+(\d+)\s+warning/gi)) {
+    warnings += Number(m[1]);
+    parsed = true;
+  }
+  const mdSummary = combined.match(/Summary:\s+(\d+)\s+error/i);
+  if (mdSummary) {
+    errors += Number(mdSummary[1]);
+    parsed = true;
+  }
+
+  const failedExit = !parsed && (result.status ?? 0) !== 0;
+  const emptyScope = failedExit && BIOME_EMPTY_SCOPE.test(combined);
+  const executionFailed = failedExit && !emptyScope;
+  const reason = executionFailed
+    ? NPX_UNRESOLVABLE.test(combined)
+      ? DEGRADATION_REASONS.RUNNER_NOT_RESOLVABLE
+      : DEGRADATION_REASONS.UNPARSEABLE_OUTPUT
+    : null;
+
+  return { errors, warnings, parsed, executionFailed, emptyScope, reason };
+}
+
+/**
+ * Pure: merge per-surface summaries into the gate's single summary. Counts add;
+ * `executionFailed` is the OR across surfaces; each failed surface contributes
+ * one degradation record naming itself. Merging *summaries* rather than raw
+ * output is what stops one runner's failure from becoming the other's verdict.
+ *
+ * @param {Array<{ surface: string, summary: ReturnType<typeof parseLintOutput> }>} surfaces
+ */
+function mergeSurfaceSummaries(surfaces) {
+  let errors = 0;
+  let warnings = 0;
+  let parsed = false;
+  let executionFailed = false;
+  const degradations = [];
+
+  for (const { surface, summary } of surfaces) {
+    errors += summary.errors;
+    warnings += summary.warnings;
+    if (summary.parsed) parsed = true;
+    if (summary.executionFailed) {
+      executionFailed = true;
+      degradations.push({
+        surface,
+        reason: summary.reason ?? DEGRADATION_REASONS.UNPARSEABLE_OUTPUT,
+      });
+    }
+  }
+
+  return {
+    errors,
+    warnings,
+    parsed,
+    executionFailed,
+    skipped: false,
+    mode: 'changed-only',
+    degradations,
+  };
+}
+
+/**
+ * Run lint scoped to the changed surface only.
+ *
+ * @param {string[]} changedFiles
+ * @param {string} cwd
+ * @param {typeof spawnLintRunner} [runnerFn]
+ * @param {{ existsFn?: (p: string) => boolean }} [deps]  Test seam for runner resolution.
+ * @returns {{ errors: number, warnings: number, parsed: boolean, skipped: boolean, mode: 'changed-only'|'off', executionFailed: boolean, degradations: Array<{ surface: string, reason: string }> }}
+ */
+export function runScopedLint(
+  changedFiles,
+  cwd,
+  runnerFn = spawnLintRunner,
+  deps = {},
+) {
+  const { existsFn = existsSync } = deps;
+  const { code, md } = partitionFilesForLint(changedFiles);
+  if (code.length === 0 && md.length === 0) {
+    return {
+      errors: 0,
+      warnings: 0,
+      parsed: false,
+      skipped: true,
+      mode: 'changed-only',
+      executionFailed: false,
+      degradations: [],
+    };
+  }
+
+  const surfaces = [];
+  if (code.length > 0) {
+    surfaces.push({
+      surface: 'biome',
+      summary: parseLintOutput(runnerFn('biome', ['lint', ...code], cwd)),
+    });
+  }
+  if (md.length > 0) {
+    const runner = resolveMarkdownRunner(cwd, existsFn);
+    if (runner === null) {
+      surfaces.push({
+        surface: 'markdownlint',
+        summary: {
+          errors: 0,
+          warnings: 0,
+          parsed: false,
+          executionFailed: true,
+          emptyScope: false,
+          reason: DEGRADATION_REASONS.RUNNER_NOT_INSTALLED,
+        },
+      });
+    } else {
+      surfaces.push({
+        surface: runner.bin,
+        summary: parseLintOutput(
+          runnerFn(runner.bin, [...md, ...runner.extraArgs], cwd),
+        ),
+      });
+    }
+  }
+
+  return mergeSurfaceSummaries(surfaces);
+}

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

@@ -21,9 +21,11 @@ import { gitSpawn } from '../git-utils.js';
 import { Logger } from '../Logger.js';
 import { composeRoutedProposals } from './retro-proposals.js';
 import {
+  assessRollupOutcome,
   buildFollowUpsCommentBody,
   gatherRunFrictionSignals,
   resolveFollowUpRepos,
+  summarizeSignalCategories,
 } from './story-follow-ups.js';
 import { upsertStructuredComment } from './ticketing.js';
 
@@ -550,6 +552,7 @@ async function executeFollowUpRollup({
   provider,
   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
@@ -570,7 +573,7 @@ async function executeFollowUpRollup({
     item.title = item.title.replace(/plan-run \d+/, `plan-run ${planRunId}`);
     item.body = item.body.replace(/plan-run \d+/g, `plan-run ${planRunId}`);
   }
-  const graduated = await graduateRetroProposals({
+  const graduated = await graduateFn({
     epicId: primaryId,
     provider,
     config,
@@ -582,6 +585,16 @@ async function executeFollowUpRollup({
     routedProposals: proposals,
     cwd,
   });
+  const categories = summarizeSignalCategories(signals);
+  const proposalCount = proposals.framework.length + proposals.consumer.length;
+  const outcome = assessRollupOutcome({
+    signalCount: signals.length,
+    proposalCount,
+    discardedCount: proposals.discarded.length,
+    filedCount: graduated.filed?.length ?? 0,
+    filingErrors: graduated.errors,
+    filingSkipped: graduated.skipped,
+  });
   if (Number.isInteger(primaryId) && primaryId > 0) {
     const body = buildFollowUpsCommentBody({
       storyId: primaryId,
@@ -591,6 +604,10 @@ async function executeFollowUpRollup({
       // 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})`,
@@ -602,6 +619,34 @@ async function executeFollowUpRollup({
     signalCount: signals.length,
     storyCount: stories.length,
     filed: graduated.filed?.length ?? 0,
+    // 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,
+      source: item.source,
+      storyCount: item.storyCount ?? null,
+      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.
@@ -698,6 +743,9 @@ async function executeSiblingCoherence({ planRunId, stories, provider }) {
  * @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`.
  * @returns {Promise<object>}
  */
 export async function runPlanRunEpilogue({
@@ -708,6 +756,7 @@ export async function runPlanRunEpilogue({
   cwd = process.cwd(),
   git = { gitSpawn },
   selectAuditsFn = selectAudits,
+  graduateFn = graduateRetroProposals,
 } = {}) {
   const plan = planRunEpilogue({ planRunId, stories });
   if (!plan.applicable) {
@@ -741,6 +790,7 @@ export async function runPlanRunEpilogue({
             provider,
             config,
             cwd,
+            graduateFn,
           }),
         );
       } else if (step.kind === 'sibling-coherence') {

package/.agents/scripts/lib/orchestration/single-story-close/gate-log.js

@@ -70,7 +70,17 @@ import { Logger, resolveLevel } from '../../Logger.js';
  */
 export const REPLAY_TAIL_LINES = 200;
 
-/** Basename of the per-Story gate log inside the temp directory. */
+/**
+ * Basename of the per-Story gate log inside the temp directory.
+ *
+ * `closeGateLogPath` in `lib/config/temp-paths.js` spells the same name for the
+ * READER — `deliver-recover.js` uses this file's freshness to tell a live close
+ * from a dead one. Deliberately not shared through an import: this sink needs
+ * the basename alone (it honours a `logDir` override the path helper knows
+ * nothing about), and calling that helper for it would drag tempRoot
+ * resolution — a git spawn and scratch-dir creation — into a filename lookup.
+ * The two spellings are pinned equal by test instead.
+ */
 function logNameFor(storyId) {
   return `close-gates-${storyId ?? 'unknown'}.log`;
 }

package/.agents/scripts/lib/orchestration/single-story-close/phases/code-review.js

@@ -28,8 +28,13 @@
  */
 
 import { parsePrNumberFromUrl } from '../../../github-url.js';
+import { degradationEnvelope } from '../../review-providers/degraded-gates.js';
 import { runStoryReviewCore } from '../../story-close/phases/review-core.js';
 import { postStructuredComment } from '../../ticketing/state.js';
+import {
+  buildOutcomeTally,
+  formatReviewOutcomeLines,
+} from './review-outcome.js';
 
 /**
  * Extract the numeric PR ID from a `gh pr create` URL. The CLI returns a
@@ -62,13 +67,11 @@ export function buildStoryReviewCrossRefBody({
   prNumber,
   commentUrl,
   severity,
+  degradations,
 }) {
-  const tally =
-    `critical:${severity.critical} · high:${severity.high} · ` +
-    `medium:${severity.medium} · suggestion:${severity.suggestion}`;
   return (
     `🔬 Story-scope code review posted on PR [#${prNumber}](${prUrl}): ` +
-    `[view findings](${commentUrl}) — ${tally}.`
+    `[view findings](${commentUrl}) — ${buildOutcomeTally({ severity, degradations })}.`
   );
 }
 
@@ -116,6 +119,7 @@ async function postStoryReviewCrossRef({
       prNumber,
       commentUrl,
       severity,
+      degradations: result.degradations,
     });
     try {
       await postStructuredComment(provider, storyId, 'notification', body);
@@ -174,6 +178,8 @@ async function postStoryReviewCrossRef({
  *   severity?: { critical: number, high: number, medium: number, suggestion: number },
  *   posted?: boolean,
  *   postedCommentId?: number|null,
+ *   degraded?: boolean,
+ *   degradations?: Array<object>,
  *   crossRefPosted?: boolean,
  *   localLensReview?: object,
  * }>}
@@ -222,10 +228,13 @@ export async function runStoryScopeReview({
     medium: 0,
     suggestion: 0,
   };
-  progress(
-    'REVIEW',
-    `Findings — critical:${sev.critical} high:${sev.high} medium:${sev.medium} suggestion:${sev.suggestion}. Posted to PR #${prNumber}: ${result.posted}.`,
-  );
+  const outcome = formatReviewOutcomeLines({
+    severity: sev,
+    degradations: result.degradations,
+    prNumber,
+    posted: result.posted,
+  });
+  for (const line of outcome) progress('REVIEW', line);
 
   const crossRefPosted = await postStoryReviewCrossRef({
     provider,
@@ -242,6 +251,7 @@ export async function runStoryScopeReview({
     severity: sev,
     posted: result.posted,
     postedCommentId: result.postedCommentId ?? null,
+    ...degradationEnvelope(result.degradations),
     crossRefPosted,
     localLensReview: result.localLensReview,
   };

package/.agents/scripts/lib/orchestration/single-story-close/phases/review-outcome.js

@@ -0,0 +1,66 @@
+/**
+ * phases/review-outcome.js — operator-facing rendering of the Story-scope
+ * review outcome (Story #4839).
+ *
+ * The review phase used to report a severity tally and nothing else, which made
+ * "every gate ran and found nothing" and "a gate never ran" render identically.
+ * Both surfaces the operator actually reads — the close progress stream and the
+ * cross-reference comment on the Story — now state the degraded gates
+ * explicitly, and always state them (as `none` when healthy) so an absent line
+ * can never be mistaken for a clean gate.
+ *
+ * A degraded gate is **reported, not blocking**: the canonical `npm run lint`
+ * close-validation gate has already covered this diff before the review phase
+ * runs, so failing the merge on a secondary read of an already-gated surface
+ * would cost delivery without buying coverage. The rationale for that posture
+ * lives with the channel itself in
+ * [`review-providers/degraded-gates.js`](../../review-providers/degraded-gates.js).
+ */
+
+import { summarizeDegradations } from '../../review-providers/degraded-gates.js';
+
+/**
+ * Pure: the tally suffix shared by the progress line and the cross-reference
+ * comment — severity counts plus the degraded-gate state.
+ *
+ * @param {{ severity: { critical: number, high: number, medium: number, suggestion: number }, degradations?: unknown }} args
+ * @returns {string}
+ */
+export function buildOutcomeTally({ severity, degradations }) {
+  return (
+    `critical:${severity.critical} · high:${severity.high} · ` +
+    `medium:${severity.medium} · suggestion:${severity.suggestion} · ` +
+    `degraded gates: ${summarizeDegradations(degradations)}`
+  );
+}
+
+/**
+ * Pure: the progress lines announcing a completed review. Always one line
+ * naming the tally; a second, explicitly-worded line when a gate did not run so
+ * the degradation cannot be skimmed past.
+ *
+ * @param {{
+ *   severity: { critical: number, high: number, medium: number, suggestion: number },
+ *   degradations?: unknown,
+ *   prNumber: number,
+ *   posted: boolean,
+ * }} args
+ * @returns {string[]}
+ */
+export function formatReviewOutcomeLines({
+  severity,
+  degradations,
+  prNumber,
+  posted,
+}) {
+  const tally = buildOutcomeTally({ severity, degradations });
+  const lines = [`Findings — ${tally}. Posted to PR #${prNumber}: ${posted}.`];
+  if (summarizeDegradations(degradations) !== 'none') {
+    lines.push(
+      '⚠️ Review ran DEGRADED — the surface(s) above were not reviewed. The close ' +
+        'is not blocked (the canonical `npm run lint` close gate already covered ' +
+        'this diff), but this review does not vouch for them.',
+    );
+  }
+  return lines;
+}

package/.agents/scripts/lib/orchestration/single-story-close/runner.js

@@ -71,7 +71,7 @@ async function emitTerminal({ terminal, result, config }) {
       },
     });
   }
-  emitTerminalEnvelope(terminal);
+  emitTerminalEnvelope(terminal, { config });
   await emitTerminalFriction({ envelope: terminal, config });
 }
 

package/.agents/scripts/lib/orchestration/story-close/phases/code-review.js

@@ -38,6 +38,7 @@
 
 import { Logger } from '../../../Logger.js';
 import { runCodeReview } from '../../code-review.js';
+import { summarizeDegradations } from '../../review-providers/degraded-gates.js';
 import { emitBlockedCloseResult } from '../emit-blocked.js';
 import { runLocalLensReview } from './local-lens-review.js';
 import { runStoryReviewCore } from './review-core.js';
@@ -86,7 +87,10 @@ function buildCodeReviewBlockedExtra({ storyId, reviewResult }) {
 function formatReviewSummary(reviewResult) {
   const { high, medium, suggestion } = resolveSeverity(reviewResult);
   const posted = reviewResult?.posted ?? false;
-  return `Review complete — high=${high} medium=${medium} suggestion=${suggestion} (posted=${posted}).`;
+  // Story #4839 — `degraded` is always stated: an absent degradation line must
+  // never be the way an operator concludes that every gate ran.
+  const degraded = summarizeDegradations(reviewResult?.degradations);
+  return `Review complete — high=${high} medium=${medium} suggestion=${suggestion} degraded=${degraded} (posted=${posted}).`;
 }
 
 /**