mandrel 2.31.0 → 2.33.0

package/.agents/scripts/lib/orchestration/resolve-stories.js

@@ -182,9 +182,16 @@ export function storyFootprintPaths(body, id, warn) {
 }
 
 /**
- * Build the DAG nodes. `dependsOn` is the union the adjacency builder already
- * computes (body-parsed `blocked by #N` + explicit fields), plus any native
- * edges threaded in via `nativeEdges`. `files` is a plain `string[]`.
+ * Build the DAG nodes. `dependsOn` is the **union of the two declared-edge
+ * channels**: the Story body's `---` footer (`blocked by #N`) and the native
+ * GitHub `blocked_by` relations threaded in via `nativeEdges`. `files` is a
+ * plain `string[]`.
+ *
+ * The body channel is footer-scoped and strict (`parseBlockedBy`, Story
+ * #5046) — a `blocked by #123` mention in prose no longer mints a dispatch
+ * gate. Only `{ id, dependsOn }` is handed to the adjacency builder, never the
+ * body: the edge set is decided here, once, so the builder's own body parse
+ * cannot re-derive a different one behind this function's back.
  *
  * @param {object[]} stories
  * @param {Map<number, number[]>} [nativeEdges]
@@ -193,7 +200,7 @@ export function storyFootprintPaths(body, id, warn) {
  */
 export function storiesToDag(stories, nativeEdges = new Map(), warn) {
   const withNative = stories.map((s) => ({
-    ...s,
+    id: s.id,
     dependsOn: [
       ...new Set([
         ...parseBlockedBy(s.body ?? ''),
@@ -222,28 +229,39 @@ export function storiesToDag(stories, nativeEdges = new Map(), warn) {
  * matching no Story, foreign to the set, never satisfiable, and (because
  * foreign edges are real gates) a silent permanent wedge.
  *
- * Cross-repo blockers are rejected rather than matched: another repo's #4530
- * is not this repo's #4530, and treating it as one could satisfy a gate that
- * is still open.
+ * A cross-repo blocker is **dropped with a loud warning**, never matched:
+ * another repo's #4530 is not this repo's #4530, and treating it as one could
+ * satisfy a gate that is still open. It used to throw, which failed the WHOLE
+ * resolution — one Story's unsupported edge took every sibling down with it
+ * (Story #5046). The degrade is now scoped to the Story carrying the edge:
+ * its siblings resolve normally, and the operator is told, by number, which
+ * Story lost which edge.
  *
  * @param {unknown} data Parsed API response.
- * @param {{ owner: string, repo: string, issueNumber: number }} ctx
+ * @param {{ owner: string, repo: string, issueNumber: number, warn?: (msg: string) => void }} ctx
  * @returns {number[]}
  */
-export function nativeBlockedByNumbers(data, { owner, repo, issueNumber }) {
+export function nativeBlockedByNumbers(
+  data,
+  { owner, repo, issueNumber, warn },
+) {
   if (!Array.isArray(data)) return [];
   const out = [];
   for (const item of data) {
     const repoUrl = item?.repository_url ?? item?.repository?.url ?? null;
-    if (typeof repoUrl === 'string' && repoUrl.length > 0) {
-      const expected = `/repos/${owner}/${repo}`;
-      if (!repoUrl.endsWith(expected)) {
-        throw new Error(
-          `[resolve-stories] #${issueNumber} is blocked by an issue in another repository ` +
-            `(${repoUrl}). Cross-repo dependency edges are not supported — its number cannot ` +
-            `be matched against this repo's Stories without risking a false match.`,
-        );
-      }
+    if (
+      typeof repoUrl === 'string' &&
+      repoUrl.length > 0 &&
+      !repoUrl.endsWith(`/repos/${owner}/${repo}`)
+    ) {
+      warn?.(
+        `[resolve-stories] #${issueNumber} declares a native blocked_by edge on an issue in ` +
+          `another repository (${repoUrl}). Cross-repo edges are not supported — its number ` +
+          `cannot be matched against this repo's Stories without risking a false match, so the ` +
+          `edge is DROPPED for #${issueNumber} only. Its siblings resolve normally; re-declare ` +
+          `the ordering in this repo if #${issueNumber} must wait.`,
+      );
+      continue;
     }
     const number = Number(item?.number);
     if (Number.isInteger(number) && number > 0) out.push(number);
@@ -252,17 +270,33 @@ export function nativeBlockedByNumbers(data, { owner, repo, issueNumber }) {
 }
 
 /**
- * Read an issue's native `blocked_by` edges as issue numbers.
+ * Read an issue's native `blocked_by` edges as issue numbers, **paginated to
+ * exhaustion**.
+ *
+ * The read used to take the first page only, so a Story with more than a
+ * page of blockers silently lost every edge past the boundary — the exact
+ * failure this function's fail-loud contract exists to prevent, arriving
+ * through the one door that never raised (Story #5046). `paginate` is
+ * injected (the CLI passes `paginateRest`) so the lib layer stays free of a
+ * provider import and the page walk stays testable without a live round-trip.
  *
- * **Fails loud**, deliberately inverting the write path's non-fatal contract.
- * A dropped write-side edge is cosmetic (the ordering still lives in the
- * `blocked by #N` body footer); a dropped READ-side edge silently removes a
- * dispatch gate, so a 403 (dependencies API disabled, or a token without the
- * scope) would erase every native edge at once and co-dispatch the whole run
- * against unlanded blockers. A 404 means "no dependencies on this issue" and
- * is a legitimate empty result.
+ * **Fails loud on every non-OK read**, deliberately inverting the write path's
+ * non-fatal contract. A dropped write-side edge is cosmetic (the ordering
+ * still lives in the `blocked by #N` body footer); a dropped READ-side edge
+ * silently removes a dispatch gate, so one failure would erase every native
+ * edge at once and co-dispatch the run against unlanded blockers.
  *
- * @param {{ gh: object, owner: string, repo: string, issueNumber: number, parseJson: Function }} opts
+ * **A 404 is not an empty result.** It used to be treated as "this issue has
+ * no dependencies", which is how GitHub answers an issue that genuinely has
+ * none — but it is *also* how GitHub answers a token that cannot see the
+ * dependencies API at all. Reading the second as the first erases every
+ * native edge in the run under a mis-scoped token, silently, with a clean
+ * exit code. An issue with no dependencies returns `200 []`, so the empty
+ * case needs no 404 escape hatch and the ambiguity resolves loud.
+ *
+ * @param {{ gh: object, owner: string, repo: string, issueNumber: number,
+ *   paginate: (gh: object, endpoint: string, opts?: object) => Promise<unknown[]>,
+ *   warn?: (msg: string) => void }} opts
  * @returns {Promise<number[]>}
  */
 export async function readNativeBlockedBy({
@@ -270,27 +304,30 @@ export async function readNativeBlockedBy({
   owner,
   repo,
   issueNumber,
-  parseJson,
+  paginate,
+  warn,
 }) {
-  let result;
+  const endpoint = `/repos/${owner}/${repo}/issues/${issueNumber}/dependencies/blocked_by`;
+  let items;
   try {
-    result = await gh.api({
-      method: 'GET',
-      endpoint: `/repos/${owner}/${repo}/issues/${issueNumber}/dependencies/blocked_by`,
+    items = await paginate(gh, endpoint, {
+      label: `[resolve-stories] blocked_by #${issueNumber}`,
     });
   } catch (err) {
     const detail = String(err?.message ?? err);
-    if (/404|not found/i.test(detail)) return [];
     throw new Error(
       `[resolve-stories] Could not read native blocked_by edges for #${issueNumber}: ${detail}. ` +
         `Refusing to continue: a dropped dependency edge would silently remove a dispatch gate ` +
-        `and co-dispatch this Story against an unlanded blocker.`,
+        `and co-dispatch this Story against an unlanded blocker. A 404 here is NOT "no ` +
+        `dependencies" (that answers 200 with an empty list) — check the token's scopes and ` +
+        `that the dependencies API is enabled for ${owner}/${repo}.`,
     );
   }
-  return nativeBlockedByNumbers(parseJson(result), {
+  return nativeBlockedByNumbers(items, {
     owner,
     repo,
     issueNumber,
+    warn,
   });
 }
 
@@ -301,9 +338,6 @@ export async function readNativeBlockedBy({
  * @param {Map<number, number[]>} nativeEdges
  * @param {number[]} foreignDone Ids outside the set already satisfied.
  * @param {(msg: string) => void} [warn]
- * @param {object} [injectedRules] Test seam forwarded to the shape
- *   derivation — skips the `audit-rules.json` disk read. Production callers
- *   omit it (the real manifest, memoized per process, is the default).
  * @returns {{ kind: string, stories: object[], dag: object[], done: number[] }}
  */
 export function buildStoriesEnvelope({
@@ -311,8 +345,6 @@ export function buildStoriesEnvelope({
   nativeEdges = new Map(),
   foreignDone = [],
   warn,
-  config,
-  injectedRules,
 }) {
   const sorted = [...stories].sort((a, b) => a.id - b.id);
   const inSetDone = sorted.filter(isSatisfiedBlocker).map((s) => s.id);
@@ -324,8 +356,8 @@ export function buildStoriesEnvelope({
     // acceptance-critic sub-agent boots) or `subagent` (the conservative
     // default). Model-side fan-out only; close gates are untouched.
     //
-    // `storyCount` is the premise that decides it, and it is this call site's
-    // load-bearing argument: `inline` names the router's ONE session, so it is
+    // `storyCount` is the ONLY premise that decides it, and it is this call
+    // site's whole argument: `inline` names the router's ONE session, so it is
     // granted only to a run resolving exactly ONE Story, which has no
     // concurrent sibling to share that session with. Passing the resolved set
     // size here is therefore what makes the envelope self-consistent with the
@@ -336,19 +368,14 @@ export function buildStoriesEnvelope({
     // a caller reads for a given `--ids` list never changes as siblings land
     // mid-run. The `route::lite` label is a human-visible hint only, never the
     // control signal.
-    stories: sorted.map(({ id, title, body, url, labels, state }) => ({
+    stories: sorted.map(({ id, title, url, labels, state }) => ({
       id,
       title,
       url,
       labels,
       state,
-      dispatchMode: resolveStoryDispatchMode({
-        body,
-        labels,
-        config,
-        storyCount: sorted.length,
-        injectedRules,
-      }).mode,
+      dispatchMode: resolveStoryDispatchMode({ storyCount: sorted.length })
+        .mode,
     })),
     dag: storiesToDag(sorted, nativeEdges, warn),
     done: [...new Set([...inSetDone, ...foreignDone])].sort((a, b) => a - b),

package/.agents/scripts/lib/orchestration/review-providers/codex.js

@@ -19,7 +19,7 @@
  * `provider: native` explicitly; the probe is the only thing that
  * routes between "configured backend present" and "configured backend
  * missing". The adapter never consults a GitHub provider — the
- * orchestrator owns posting/upserting and the lifecycle bus.
+ * orchestrator owns posting and upserting.
  *
  * @typedef {import('./types.js').Finding} Finding
  * @typedef {import('./types.js').ReviewInput} ReviewInput

package/.agents/scripts/lib/orchestration/review-providers/mi-exemptions.js

@@ -0,0 +1,130 @@
+/**
+ * review-providers/mi-exemptions.js — the maintainability gate's exemption list,
+ * as the native review provider reads it.
+ *
+ * `delivery.quality.gates.maintainability.ignoreGlobs` is the one declared
+ * answer to "which files is the maintainability index meaningless for" —
+ * declarative schema blobs, generated code, vendored trees. Every other MI
+ * consumer already honours it: the baseline writer excludes those files
+ * (`update-maintainability-baseline.js`), so the `check-baselines.js` ratchet
+ * and the pre-merge MI advisory never see them either.
+ *
+ * `review-providers/native.js` did not, and the split produced a live
+ * contradiction on Story #5007 / PR #5022: the ratchet PASSED while the review
+ * lens raised a **critical blocker** on three exempted
+ * `config-settings-schema*.js` modules in the same close run. Because a critical
+ * finding halts `single-story-close.js` before auto-merge, the only way to land
+ * legitimate work was to merge the PR by hand. A gate that must be
+ * hand-bypassed to ship is not a gate.
+ *
+ * This module is that reconciliation, kept separate from the provider so the
+ * exemption concern has one home and the provider keeps one reason to change.
+ */
+
+import { getQuality } from '../../config/quality.js';
+import { resolveConfig } from '../../config-resolver.js';
+import { isIgnoredByGlobs } from '../../maintainability-utils.js';
+
+/**
+ * Read `delivery.quality.gates.maintainability.ignoreGlobs` so a review's
+ * maintainability dimension scores the same file set the ratchet does.
+ *
+ * Best-effort and total. A config that cannot be resolved yields `[]`, which
+ * scores every changed JS file. That direction is deliberate: degrading to
+ * "score everything" can only produce an advisory the operator must read,
+ * whereas degrading to "score nothing" would silently retire the dimension.
+ *
+ * @param {{ resolveConfigFn?: typeof resolveConfig, getQualityFn?: typeof getQuality }} [deps]
+ * @returns {string[]} minimatch patterns; `[]` when unset or unresolvable.
+ */
+export function resolveMaintainabilityIgnoreGlobs({
+  resolveConfigFn = resolveConfig,
+  getQualityFn = getQuality,
+} = {}) {
+  try {
+    const globs = getQualityFn(resolveConfigFn())?.maintainability?.ignoreGlobs;
+    return Array.isArray(globs) ? globs.slice() : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Pure: split a changed-file list into the set to score and the set the
+ * maintainability gate exempts.
+ *
+ * Matching funnels through `maintainability-utils.js#isIgnoredByGlobs` — the
+ * declared single source of truth for how the MI scorer decides a file is
+ * ignored — so an exempted file is excluded here by exactly the same rule that
+ * kept it out of the baseline. Re-implementing the match with a local
+ * `minimatch` call is what let the two surfaces disagree in the first place.
+ *
+ * Module-local: {@link scopeMaintainabilityFiles} is the single door, and its
+ * `scored` / `ignored` split is where this behaviour is observable.
+ *
+ * @param {string[]} files
+ * @param {string[]} ignoreGlobs
+ * @param {string} cwd root for repo-relative glob resolution
+ * @returns {{ scored: string[], ignored: string[] }}
+ */
+function partitionByIgnoreGlobs(files, ignoreGlobs, cwd) {
+  if (!Array.isArray(ignoreGlobs) || ignoreGlobs.length === 0) {
+    return { scored: files, ignored: [] };
+  }
+  const scored = [];
+  const ignored = [];
+  for (const relPath of files) {
+    if (isIgnoredByGlobs(relPath, ignoreGlobs, cwd)) ignored.push(relPath);
+    else scored.push(relPath);
+  }
+  return { scored, ignored };
+}
+
+/**
+ * Render the operator-facing notice naming the files the gate exempted, or
+ * `null` when nothing was exempted so the caller can `if` past the log call.
+ *
+ * The notice exists because silence is ambiguous: an operator reading a review
+ * that says nothing about three changed schema modules cannot tell "scored and
+ * healthy" from "never scored".
+ *
+ * Module-local: reached through {@link scopeMaintainabilityFiles}'s `notice`.
+ *
+ * @param {string[]|undefined} ignoredFiles
+ * @returns {string|null}
+ */
+function formatExemptionNotice(ignoredFiles) {
+  const files = Array.isArray(ignoredFiles) ? ignoredFiles : [];
+  if (files.length === 0) return null;
+  return (
+    `[native-review] Maintainability: ${files.length} changed file(s) exempt via ` +
+    `delivery.quality.gates.maintainability.ignoreGlobs — not scored: ${files.join(', ')}.`
+  );
+}
+
+/**
+ * Resolve the exemption list and split a review's changed-file set into the
+ * paths whose maintainability should be scored and the paths the gate exempts.
+ *
+ * This is the one door the native provider uses: it keeps the resolve → match →
+ * report sequence here rather than spread across the provider, so the provider
+ * carries no knowledge of how an exemption is decided.
+ *
+ * @param {string[]} changedFiles
+ * @param {{
+ *   cwd: string,
+ *   resolveIgnoreGlobsFn?: typeof resolveMaintainabilityIgnoreGlobs,
+ * }} opts
+ * @returns {{ scored: string[], ignored: string[], notice: string|null }}
+ */
+export function scopeMaintainabilityFiles(
+  changedFiles,
+  { cwd, resolveIgnoreGlobsFn = resolveMaintainabilityIgnoreGlobs } = {},
+) {
+  const { scored, ignored } = partitionByIgnoreGlobs(
+    changedFiles,
+    resolveIgnoreGlobsFn(),
+    cwd,
+  );
+  return { scored, ignored, notice: formatExemptionNotice(ignored) };
+}

package/.agents/scripts/lib/orchestration/review-providers/native.js

@@ -7,14 +7,24 @@
  *
  *   1. Diffs `headRef` against `baseRef` to enumerate changed files.
  *   2. Runs scoped lint (biome + markdownlint) over the changed surface.
- *   3. Computes per-file maintainability reports for changed JS files.
+ *   3. Computes per-file maintainability reports for changed JS files, minus
+ *      the files the maintainability gate exempts (see below).
  *   4. Maps each signal to a `Finding` with a `severity` ∈ {critical, high,
  *      medium, suggestion}.
  *
- * The adapter does NOT post to GitHub, does NOT render a markdown body,
- * and does NOT consult the lifecycle bus. Those concerns belong to
- * `runCodeReview()` (which calls the renderer + the structured-comment
- * upserter) and the listener chain.
+ * **The maintainability dimension honours the gate's exemption list**, read via
+ * [`mi-exemptions.js`](mi-exemptions.js) — see that module for why this
+ * provider disagreeing with the ratchet was a live delivery blocker. Exempted
+ * files are named on the log rather than silently dropped.
+ *
+ * The lint dimension is deliberately NOT filtered through the same list:
+ * lint carries its own exclusion surface (biome's `files.includes`,
+ * `.markdownlintignore`), and a quality-gate ignore glob makes no claim about
+ * whether a file should parse or format cleanly.
+ *
+ * The adapter does NOT post to GitHub and does NOT render a markdown body.
+ * Those concerns belong to `runCodeReview()`, which calls the renderer + the
+ * structured-comment upserter.
  *
  * Construction is intentionally zero-arg so the factory can instantiate
  * it without threading config through every call. Per-invocation config
@@ -53,6 +63,10 @@ import {
 } from '../../observability/runtime-friction.js';
 import { PROJECT_ROOT } from '../../project-root.js';
 import { transpileIfNeeded } from '../../transpile.js';
+import {
+  resolveMaintainabilityIgnoreGlobs,
+  scopeMaintainabilityFiles,
+} from './mi-exemptions.js';
 import {
   parseLintOutput,
   partitionFilesForLint,
@@ -389,16 +403,6 @@ export function buildLintFindings(lintSummary) {
   return findings;
 }
 
-function _emptyResults() {
-  return {
-    totalFiles: 0,
-    jsFiles: 0,
-    maintainability: [],
-    criticalFindings: [],
-    mediumFindings: [],
-  };
-}
-
 async function runLintPhase({
   scopeLint,
   changedFiles,
@@ -467,6 +471,7 @@ function buildLintDegradations(lintSummary) {
  *   analyzeChangedFilesFn?: typeof analyzeChangedFiles,
  *   buildLintFindingsFn?: typeof buildLintFindings,
  *   emitToolDegradationFn?: typeof emitRuntimeFriction,
+ *   resolveIgnoreGlobsFn?: typeof resolveMaintainabilityIgnoreGlobs,
  *   logger?: { info?: Function, warn?: Function, error?: Function },
  *   scopeLint?: 'changed-only'|'off',
  * }} [deps]
@@ -479,6 +484,10 @@ export function createNativeProvider(deps = {}) {
     analyzeChangedFilesFn = analyzeChangedFiles,
     buildLintFindingsFn = buildLintFindings,
     emitToolDegradationFn = emitRuntimeFriction,
+    // The maintainability-gate exemption seam. The resolution itself — gate-key
+    // read and fail-open — is unit-tested in `mi-exemptions.js`; this dep is
+    // here so a provider test can pin the WIRING without a config on disk.
+    resolveIgnoreGlobsFn = resolveMaintainabilityIgnoreGlobs,
     logger,
     scopeLint = 'changed-only',
   } = deps;
@@ -551,7 +560,12 @@ export function createNativeProvider(deps = {}) {
       logger?.info?.(
         `[native-review] Analyzing ${changedFiles.length} changed file(s)...`,
       );
-      const results = await analyzeChangedFilesFn(changedFiles, {
+      const mi = scopeMaintainabilityFiles(changedFiles, {
+        cwd: PROJECT_ROOT,
+        resolveIgnoreGlobsFn,
+      });
+      if (mi.notice) logger?.info?.(mi.notice);
+      const results = await analyzeChangedFilesFn(mi.scored, {
         headRef,
         gitSpawnFn,
       });

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

@@ -21,7 +21,7 @@
  * the caller raises that to a thrown error so auto-merge is not enabled.
  *
  * Delegates the `runCodeReview` invocation to `runStoryReviewCore`
- * (exported from `story-close/phases/code-review.js`) so the close path
+ * (exported from `story-close/phases/review-core.js`) so the close path
  * 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).

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

@@ -96,6 +96,7 @@ import {
   readPrMergeState as defaultReadPrMergeState,
 } from '../../../single-story/confirm-merge.js';
 import { pollUntil } from '../../../util/poll-loop.js';
+import { applyBehindUpdate } from '../../behind-recovery.js';
 import {
   emitMergeFlipFailed as defaultEmitMergeFlipFailed,
   MERGED_FLIP_FAILED_BLOCK_CLASS,
@@ -635,7 +636,15 @@ async function blockOnUnlanded({
 /**
  * Bring a BEHIND PR up to date, bounded by `updateAttempts`. Best-effort:
  * a failed update is not itself a terminal — the next poll re-reads the
- * real state and lets the normal classification decide.
+ * real state and lets the normal classification decide, which is why a
+ * failed attempt still counts against the wait's tick.
+ *
+ * The BEHIND / budget / did-it-land decision itself lives in the shared
+ * {@link applyBehindUpdate} (Story #5006) — the CI-watch loop in
+ * `lib/orchestration/pr-watch.js` runs the same one. This wrapper supplies
+ * the merge wait's probe source, its `gh` facade (bounded by
+ * {@link withGhTimeout}, so a wedged child cannot strand an unattended
+ * async-mode wait), and its operator wording.
  *
  * @returns {Promise<boolean>} whether an update was actually attempted.
  */
@@ -648,31 +657,33 @@ async function maybeUpdateBehindPr({
   ghTimeoutMs = MERGE_WAIT_GH_TIMEOUT_MS,
   progress,
 }) {
-  if (probe.mergeStateStatus !== 'BEHIND') return false;
-  if (updatesUsed >= updateAttempts) {
-    progress?.(
-      'CONFIRM',
-      `⚠️ PR #${prNumber} is BEHIND but the update budget (${updateAttempts}) is spent — not updating again.`,
-    );
-    return false;
-  }
-  try {
-    await withGhTimeout(
-      (gh ?? defaultGh).pr.updateBranch(prNumber),
-      ghTimeoutMs,
-      `gh pr update-branch ${prNumber}`,
-    );
-    progress?.(
-      'CONFIRM',
-      `⏫ PR #${prNumber} was BEHIND its base — updated (attempt ${updatesUsed + 1}/${updateAttempts}).`,
-    );
-  } catch (err) {
-    progress?.(
-      'CONFIRM',
-      `⚠️ gh pr update-branch failed (continuing): ${err?.message ?? err}`,
-    );
-  }
-  return true;
+  const recovery = await applyBehindUpdate({
+    mergeStateStatus: probe.mergeStateStatus,
+    updatesUsed,
+    maxUpdates: updateAttempts,
+    updateBranch: () =>
+      withGhTimeout(
+        (gh ?? defaultGh).pr.updateBranch(prNumber),
+        ghTimeoutMs,
+        `gh pr update-branch ${prNumber}`,
+      ),
+    onBudgetSpent: () =>
+      progress?.(
+        'CONFIRM',
+        `⚠️ PR #${prNumber} is BEHIND but the update budget (${updateAttempts}) is spent — not updating again.`,
+      ),
+    onUpdated: () =>
+      progress?.(
+        'CONFIRM',
+        `⏫ PR #${prNumber} was BEHIND its base — updated (attempt ${updatesUsed + 1}/${updateAttempts}).`,
+      ),
+    onUpdateFailed: (detail) =>
+      progress?.(
+        'CONFIRM',
+        `⚠️ gh pr update-branch failed (continuing): ${detail}`,
+      ),
+  });
+  return recovery.attempted;
 }
 
 /**