mandrel 2.0.0 → 2.2.0

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

@@ -131,30 +131,342 @@ export function planRunEpilogue({ planRunId, stories } = {}) {
   };
 }
 
-async function listChangedFiles(cwd, baseRef = 'origin/main') {
+/**
+ * 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.
+ * @type {number}
+ */
+const BASE_SCAN_LIMIT = 500;
+
+/** ASCII unit separator — cannot occur in a git commit subject. */
+const FIELD_SEP = '\x1f';
+
+/**
+ * Read the base ref's first-parent history as `{ sha, parents, subject }`
+ * records, newest-first.
+ *
+ * @param {object} args
+ * @param {string} args.cwd
+ * @param {string} args.baseRef
+ * @param {number} args.scanLimit
+ * @param {{ gitSpawn: Function }} args.git
+ * @returns {{ ok: true, commits: Array<{sha: string, parents: string[], subject: string}> }
+ *          | { ok: false, reason: string }}
+ */
+function readFirstParentHistory({ cwd, baseRef, scanLimit, git }) {
+  let result;
+  try {
+    result = git.gitSpawn(
+      cwd,
+      'log',
+      '--first-parent',
+      baseRef,
+      `--max-count=${scanLimit}`,
+      `--format=%H${FIELD_SEP}%P${FIELD_SEP}%s`,
+    );
+  } catch (err) {
+    return {
+      ok: false,
+      reason: `\`git log ${baseRef}\` could not be spawned: ${err?.message ?? String(err)}`,
+    };
+  }
+  if (result?.status !== 0) {
+    const detail =
+      String(result?.stderr ?? '').split('\n')[0] || 'unknown error';
+    return {
+      ok: false,
+      reason: `\`git log ${baseRef}\` failed (is \`${baseRef}\` fetched?): ${detail}`,
+    };
+  }
+  const commits = String(result.stdout ?? '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [sha, parents, ...rest] = line.split(FIELD_SEP);
+      return {
+        sha,
+        parents: parents ? parents.split(' ').filter(Boolean) : [],
+        subject: rest.join(FIELD_SEP),
+      };
+    });
+  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.
+ *
+ * @param {string} subject
+ * @returns {number[]} Marker ids, right-to-left (PR number first).
+ */
+function trailingMarkerIds(subject) {
+  const ids = [];
+  let rest = typeof subject === 'string' ? subject.trimEnd() : '';
+  for (;;) {
+    const match = TRAILING_MARKER_RE.exec(rest);
+    if (!match) return ids;
+    ids.push(Number(match[1]));
+    rest = rest.slice(0, match.index).trimEnd();
+  }
+}
+
+/**
+ * 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.
+ *
+ * @param {object} args
+ * @param {Array<string|number>} args.stories - Story ids in the run.
+ * @param {string} args.cwd
+ * @param {string} [args.baseRef] - Remote-tracking base ref, e.g. `origin/main`.
+ * @param {number} [args.scanLimit]
+ * @param {{ gitSpawn: Function }} [args.git]
+ * @returns {{ resolved: true, baseSha: string, mergeSha: string, storyId: number, baseRef: string }
+ *          | { resolved: false, reason: string, baseRef: string }}
+ */
+export function resolveRunBaseSha({
+  stories,
+  cwd,
+  baseRef = 'origin/main',
+  scanLimit = BASE_SCAN_LIMIT,
+  git = { gitSpawn },
+} = {}) {
+  const ids = (Array.isArray(stories) ? stories : [])
+    .map(Number)
+    .filter((n) => Number.isInteger(n) && n > 0);
+  if (ids.length === 0) {
+    return {
+      resolved: false,
+      baseRef,
+      reason:
+        'the run carries no numeric Story ids to match landed merges against',
+    };
+  }
+
+  const history = readFirstParentHistory({ cwd, baseRef, scanLimit, git });
+  if (!history.ok) {
+    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.
+  const wanted = new Set(ids);
+  for (let i = history.commits.length - 1; i >= 0; i -= 1) {
+    const commit = history.commits[i];
+    const hit = trailingMarkerIds(commit.subject).find((id) => wanted.has(id));
+    if (hit === undefined) continue;
+    const baseSha = commit.parents[0];
+    if (!baseSha) {
+      return {
+        resolved: false,
+        baseRef,
+        reason: `the earliest landed merge for the run (${commit.sha}, Story #${hit}) is a root commit — it has no first parent to use as the pre-run base`,
+      };
+    }
+    return {
+      resolved: true,
+      baseRef,
+      baseSha,
+      mergeSha: commit.sha,
+      storyId: hit,
+    };
+  }
+
+  return {
+    resolved: false,
+    baseRef,
+    reason: `no landed squash-merge carrying a \`(#<storyId>)\` marker for ${ids
+      .map((id) => `#${id}`)
+      .join(
+        ', ',
+      )} was found in the last ${scanLimit} first-parent commits of \`${baseRef}\` — has the run landed?`,
+  };
+}
+
+/**
+ * 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 }) {
+  const range = `${baseSha}...${headRef}`;
+  let result;
   try {
-    const result = gitSpawn(cwd, 'diff', '--name-only', `${baseRef}...HEAD`);
-    if (result.status !== 0) return [];
-    return String(result.stdout ?? '')
+    result = git.gitSpawn(cwd, 'diff', '--name-only', range);
+  } catch (err) {
+    return {
+      ok: false,
+      reason: `\`git diff ${range}\` could not be spawned: ${err?.message ?? String(err)}`,
+    };
+  }
+  if (result?.status !== 0) {
+    const detail =
+      String(result?.stderr ?? '').split('\n')[0] || 'unknown error';
+    return { ok: false, reason: `\`git diff ${range}\` failed: ${detail}` };
+  }
+  return {
+    ok: true,
+    files: String(result.stdout ?? '')
       .split('\n')
       .map((line) => line.trim())
-      .filter(Boolean);
-  } catch {
-    return [];
+      .filter(Boolean),
+  };
+}
+
+/**
+ * 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".
+ *
+ * @returns {{ resolved: boolean, changedFiles: string[], baseSha: string|null,
+ *             mergeSha: string|null, baseRef: string, reason: string|null }}
+ */
+function resolveCombinedDiff({ stories, cwd, baseRef, git }) {
+  const base = resolveRunBaseSha({ stories, cwd, baseRef, git });
+  if (!base.resolved) {
+    return {
+      resolved: false,
+      changedFiles: [],
+      baseSha: null,
+      mergeSha: null,
+      baseRef,
+      reason: base.reason,
+    };
+  }
+  const diff = listChangedFiles({
+    cwd,
+    baseSha: base.baseSha,
+    headRef: baseRef,
+    git,
+  });
+  if (!diff.ok) {
+    return {
+      resolved: false,
+      changedFiles: [],
+      baseSha: base.baseSha,
+      mergeSha: base.mergeSha,
+      baseRef,
+      reason: diff.reason,
+    };
   }
+  return {
+    resolved: true,
+    changedFiles: diff.files,
+    baseSha: base.baseSha,
+    mergeSha: base.mergeSha,
+    baseRef,
+    reason: null,
+  };
+}
+
+/**
+ * The diff line of the roster comment. An unresolved base MUST read as a
+ * loud failure, never as `Changed files considered: 0`.
+ *
+ * @param {ReturnType<typeof resolveCombinedDiff>} diff
+ * @returns {string[]}
+ */
+function renderDiffLines(diff) {
+  if (!diff.resolved) {
+    return [
+      '> ⚠️ **Combined landed diff unavailable — this is NOT "zero files changed".**',
+      `> The pre-run base sha could not be resolved: ${diff.reason}`,
+      '> Walk the lenses below against the run diff determined by hand.',
+      '> Lens selection was **keyword-only**: with no change set, no lens',
+      '> `filePatterns` trigger could fire, so the roster below reflects the',
+      "> primary Story's prose rather than what the run touched. Treat it as a",
+      '> starting point, not a roster.',
+    ];
+  }
+  return [
+    `Combined landed diff \`${diff.baseSha}...${diff.baseRef}\` — ` +
+      `**${diff.changedFiles.length}** changed file(s).`,
+  ];
+}
+
+/**
+ * @param {object} config
+ * @returns {string} the remote-tracking base ref, e.g. `origin/main`.
+ */
+function resolveBaseRef(config) {
+  const baseBranch = config?.project?.baseBranch;
+  const branch =
+    typeof baseBranch === 'string' && baseBranch.trim() !== ''
+      ? baseBranch.trim()
+      : 'main';
+  return `origin/${branch}`;
 }
 
-async function executeAuditRoster({ planRunId, stories, cwd, provider }) {
+async function executeAuditRoster({
+  planRunId,
+  stories,
+  cwd,
+  provider,
+  config,
+  git,
+  selectAuditsFn,
+}) {
   const primaryId = Number(stories[0]);
-  const changedFiles = await listChangedFiles(cwd);
+  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 selectAudits({
+    const selected = await selectAuditsFn({
       ticketId: primaryId,
       gate: 'gate3',
       provider,
-      baseBranch: 'main',
-      headRef: 'HEAD',
+      changedFiles: diff.resolved ? diff.changedFiles : [],
     });
     selectedAudits = Array.isArray(selected?.selectedAudits)
       ? selected.selectedAudits
@@ -162,14 +474,20 @@ async function executeAuditRoster({ planRunId, stories, cwd, provider }) {
         ? selected
         : [];
   }
+  if (!diff.resolved) {
+    Logger.warn(
+      `[run-epilogue] plan-run ${planRunId}: combined landed diff unavailable — ${diff.reason}`,
+    );
+  }
   const body = [
     '### plan-run-audit-roster',
     '',
     `Cross-Story audit roster for plan-run \`${planRunId}\`.`,
     '',
-    `Changed files considered: ${changedFiles.length}.`,
+    ...renderDiffLines(diff),
     '',
-    '**Selected lenses** (host MUST walk each against the combined landed diff):',
+    `**Selected lenses** (host MUST walk each against the combined landed diff) — ` +
+      `grounding: \`${lensGrounding}\`:`,
     ...(selectedAudits.length > 0
       ? selectedAudits.map((lens) => `- \`${lens}\``)
       : ['- _(none — docs-only or no matching change-set lenses)_']),
@@ -179,7 +497,15 @@ async function executeAuditRoster({ planRunId, stories, cwd, provider }) {
       {
         planRunId,
         stories: stories.map(Number),
-        changedFiles,
+        baseResolution: {
+          resolved: diff.resolved,
+          baseRef: diff.baseRef,
+          baseSha: diff.baseSha,
+          mergeSha: diff.mergeSha,
+          reason: diff.reason,
+        },
+        changedFiles: diff.resolved ? diff.changedFiles : null,
+        lensGrounding,
         selectedAudits,
       },
       null,
@@ -198,7 +524,23 @@ async function executeAuditRoster({ planRunId, stories, cwd, provider }) {
   return {
     kind: 'audit-roster',
     selectedAudits,
-    changedFileCount: changedFiles.length,
+    // 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.
+    lensGrounding,
+    // `null` — not `0` — when unresolved: a zero count must only ever mean
+    // "the run genuinely changed nothing".
+    changedFileCount: diff.resolved ? diff.changedFiles.length : null,
+    changedFiles: diff.resolved ? diff.changedFiles : null,
+    baseResolution: {
+      resolved: diff.resolved,
+      baseRef: diff.baseRef,
+      baseSha: diff.baseSha,
+      mergeSha: diff.mergeSha,
+      reason: diff.reason,
+    },
   };
 }
 
@@ -259,6 +601,10 @@ async function executeFollowUpRollup({
       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,
     }).replace(
       `from Story #${primaryId}`,
       `from plan-run \`${planRunId}\` (primary Story #${primaryId})`,
@@ -268,7 +614,12 @@ async function executeFollowUpRollup({
   return {
     kind: 'follow-up-rollup',
     signalCount: signals.length,
+    storyCount: stories.length,
     filed: graduated.filed?.length ?? 0,
+    // 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,
   };
 }
 
@@ -359,6 +710,8 @@ 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.
  * @returns {Promise<object>}
  */
 export async function runPlanRunEpilogue({
@@ -367,6 +720,8 @@ export async function runPlanRunEpilogue({
   provider,
   config,
   cwd = process.cwd(),
+  git = { gitSpawn },
+  selectAuditsFn = selectAudits,
 } = {}) {
   const plan = planRunEpilogue({ planRunId, stories });
   if (!plan.applicable) {
@@ -387,6 +742,9 @@ export async function runPlanRunEpilogue({
             stories: plan.stories,
             cwd,
             provider,
+            config,
+            git,
+            selectAuditsFn,
           }),
         );
       } else if (step.kind === 'follow-up-rollup') {

package/.agents/scripts/lib/orchestration/single-story-close/phases/auto-merge.js

@@ -28,6 +28,30 @@
 import { gh as defaultGh } from '../../../gh-exec.js';
 import { resolveAutoMergeArmCwd } from '../../auto-merge-cwd.js';
 
+/**
+ * Arm reasons that mean **the operator deliberately owns the merge** — the PR
+ * was never armed because it was asked not to be, not because arming failed.
+ *
+ * The distinction is load-bearing: an un-armed-by-request PR has nothing for
+ * close to land, so `resolveWaitForMerge` (`./options.js`) resolves
+ * `waitForMerge` to `false` for these reasons and the Story rests at
+ * `agent::closing` for the human. Every *other* falsy arm outcome
+ * (`pr-number-unparseable`, an `enableAutoMerge` failure) is a genuine fault
+ * and still routes through the merge-unlanded block path.
+ */
+const OPERATOR_MERGE_ARM_REASONS = Object.freeze([
+  'disabled-by-flag',
+  'disabled-by-policy-strict',
+]);
+
+/**
+ * @param {string|null|undefined} reason
+ * @returns {boolean}
+ */
+export function isOperatorMergeReason(reason) {
+  return OPERATOR_MERGE_ARM_REASONS.includes(reason);
+}
+
 /**
  * Enable GitHub native auto-merge on the PR. Non-fatal.
  *

package/.agents/scripts/lib/orchestration/single-story-close/phases/base-sync.js

@@ -18,7 +18,11 @@
 import { syncBranchFromBase } from '../../../git/sync-from-base.js';
 import { Logger } from '../../../Logger.js';
 import { AGENT_LABELS } from '../../../label-constants.js';
-import { upsertStructuredComment } from '../../ticketing/state.js';
+import {
+  STATE_LABELS,
+  transitionTicketState,
+  upsertStructuredComment,
+} from '../../ticketing.js';
 
 /**
  * Orchestrate the pre-push base-sync step: run `syncBranchFromBase`
@@ -76,7 +80,7 @@ export async function runBaseSyncPhase({
           : syncResult.stderr
             ? `: ${syncResult.stderr.slice(0, 200)}`
             : '') +
-        `. Story transitioned to ${AGENT_LABELS.BLOCKED}; resolve in ${syncCwd} and re-run \`/single-story-deliver\`.`,
+        `. Story transitioned to ${AGENT_LABELS.BLOCKED}; resolve in ${syncCwd} and re-run \`/deliver ${storyId}\`.`,
     );
   }
   progress('SYNC', `✅ Synced from origin/${baseBranch} (${syncResult.kind}).`);
@@ -126,13 +130,11 @@ export async function handleSyncFailure({
     );
   }
 
+  // Story #4539 — the canonical mutator, not a direct label write: a bare
+  // `provider.updateTicket` skips the Projects v2 column sync (Story
+  // #2548) and strands the board on the Story's prior status.
   try {
-    await provider.updateTicket(storyId, {
-      labels: {
-        add: [AGENT_LABELS.BLOCKED],
-        remove: [AGENT_LABELS.EXECUTING, AGENT_LABELS.READY, AGENT_LABELS.DONE],
-      },
-    });
+    await transitionTicketState(provider, storyId, STATE_LABELS.BLOCKED, {});
     progress('SYNC', `🚧 Flipped Story #${storyId} → ${AGENT_LABELS.BLOCKED}.`);
   } catch (err) {
     Logger.warn?.(
@@ -164,7 +166,7 @@ export function buildSyncFailureCommentBody({
   const lines = [
     `### ${heading}`,
     '',
-    '`/single-story-deliver` close-validation passed, but the pre-push',
+    '`/deliver` close-validation passed, but the pre-push',
     `sync against \`origin/${baseBranch}\` could not complete. The Story has`,
     `been transitioned to \`agent::blocked\`. To resume:`,
     '',

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

@@ -8,7 +8,7 @@
  *
  * Standalone evidence keyspace (Story #4250). Standalone Stories have no
  * parent Epic, so they cannot scope a `validation-evidence.json` under a
- * `temp/epic-<id>/` tree. Rather than feed a null `epicId` into the
+ * `temp/run-<id>/` tree. Rather than feed a null `epicId` into the
  * Epic-keyed path (which structurally disabled the evidence cache and
  * forced every re-run — base-sync conflict, review remediation, baseline
  * absorb — to re-execute ALL gates including the coverage suite), the
@@ -45,7 +45,7 @@ import { runScopedFormatAutofix as defaultRunScopedFormatAutofix } from '../../s
  *
  * Gates are built from the canonical resolved config (`buildDefaultGates`
  * reads `project.commands` and `delivery.quality.gates.crap.enabled`); the
- * `baseBranch` is forwarded as the gate `epicBranch` so the format gate's
+ * `baseBranch` is forwarded as the gate `baseBranch` so the format gate's
  * changed-file scope anchors on it. `standalone: true` routes the evidence
  * cache to the storyId-anchored keyspace.
  *
@@ -92,7 +92,7 @@ export async function runCloseValidationPhase({
         cwd,
         worktreePath,
         storyId,
-        epicBranch: baseBranch,
+        baseBranch,
         storyBranch,
         config,
         logger: Logger,
@@ -127,7 +127,7 @@ export async function runCloseValidationPhase({
     worktreePath,
     gates: buildDefaultGates({
       config,
-      epicBranch: baseBranch,
+      baseBranch,
       cwd: worktreePath || cwd,
       log: (m) => Logger.info(m),
     }),

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

@@ -22,13 +22,13 @@
  *
  * Delegates the `runCodeReview` invocation to `runStoryReviewCore`
  * (exported from `story-close/phases/code-review.js`) so the close path
- * shares a single invocation pattern (Story #3653). When `planningRisk`
- * is omitted, loads it from the Story's `story-plan-state` checkpoint.
+ * shares a single invocation pattern (Story #3653). Review depth needs no
+ * input here: it is derived from this Story's own diff inside `runCodeReview`
+ * (Story #4542).
  */
 
 import { parsePrNumberFromUrl } from '../../../github-url.js';
-import { runStoryReviewCore } from '../../story-close/phases/code-review.js';
-import { resolveStoryPlanningRisk } from '../../story-plan-state.js';
+import { runStoryReviewCore } from '../../story-close/phases/review-core.js';
 import { postStructuredComment } from '../../ticketing/state.js';
 
 /**
@@ -78,7 +78,6 @@ async function invokeStoryReviewCore({
   baseBranch,
   prNumber,
   provider,
-  planningRisk,
   runCodeReviewFn,
   runLocalLensReviewFn,
   progress,
@@ -89,11 +88,6 @@ async function invokeStoryReviewCore({
     headRef: storyBranch,
     commentTargetId: prNumber,
     provider,
-    planningRisk: await resolveStoryPlanningRisk({
-      provider,
-      storyId,
-      planningRisk,
-    }),
     progress,
     progressTag: 'REVIEW',
     runCodeReviewFn,
@@ -167,7 +161,6 @@ async function postStoryReviewCrossRef({
  *   prUrl: string,
  *   prNumber: number|null,
  *   provider: object,
- *   planningRisk?: object|null, // omit to load from story-plan-state
  *   runCodeReviewFn: Function,
  *   runLocalLensReviewFn?: Function,
  *   progress: (tag: string, msg: string) => void,
@@ -190,7 +183,6 @@ export async function runStoryScopeReview({
   prUrl,
   prNumber,
   provider,
-  planningRisk,
   runCodeReviewFn,
   runLocalLensReviewFn,
   progress,
@@ -214,7 +206,6 @@ export async function runStoryScopeReview({
     baseBranch,
     prNumber,
     provider,
-    planningRisk,
     runCodeReviewFn,
     runLocalLensReviewFn,
     progress,