@nanobpm/nano-workforce 0.111.0 → 0.111.1

package/app/github.test.ts

@@ -3,7 +3,8 @@
 // the merge-exclusion graph. Force the token transport and stub `globalThis.fetch`.
 import { test } from "node:test";
 import { assertEquals, assertRejects } from "#test-assert";
-import { BaseBranchMustExistError, classifyPrLiveness, coalesceTitle, createPullRequest, ensureBaseBranch, ensurePromotionPr, fetchIssueTitle, fetchPrFiles, isNotAPullRequestError, listPrsForHead, type PrState } from "./github.ts";
+import { BaseBranchMustExistError, checkConclusions, classifyMergeability, classifyPrLiveness, coalesceTitle, createPullRequest, ensureBaseBranch, ensurePromotionPr, fetchIssueTitle, fetchPrFiles, isNotAPullRequestError, listPrsForHead, type Mergeability, type PrState } from "./github.ts";
+import { DEFAULT_MERGE_PROTOCOL, type MergeProtocol, type RequiredCheck } from "./mergeProtocol.ts";
 
 // A fake `fetch` that serves `pages` of file batches; each page N (1-based) returns `pages[N-1]`
 // files (named `f{index}`), setting a `Link: rel="next"` header whenever a later page exists.
@@ -440,6 +441,8 @@ function prState(over: Partial<PrState>): PrState {
     failingChecks: 0,
     failingCheckNames: [],
     presentCheckNames: [],
+    pendingCheckNames: [],
+    checkConclusions: {},
     totalChecks: 0,
     isDraft: false,
     headRefOid: null,
@@ -463,3 +466,224 @@ test("classifyPrLiveness: a closed-not-merged PR is terminal (abandon)", () => {
 test("classifyPrLiveness: a null read (transport hiccup) is unknown — never abandons blind", () => {
   assertEquals(classifyPrLiveness(null), "unknown");
 });
+
+// ── classifyMergeability: protocol-aware required-checks backstop (issue #392) ────────────────────
+//
+// The merge poller must NOT merge a PR whose DECLARED-required check is red, even on a repo that
+// under-specifies its GitHub-required checks (so GitHub reports the PR as UNSTABLE, i.e. "only
+// non-required checks failing" from GitHub's view). `classifyMergeability` now intersects the repo's
+// merge-protocol `requiredChecks[]`/`waitForChecks` against the head's latest-run-per-check
+// conclusions (via `latestRunPerCheck`, preserving the #348 CANCELLED-supersede semantics) as an
+// independent backstop that runs BEFORE the `mergeStateStatus` switch. These are pure unit tests.
+
+// Build a `PrState` with sensible defaults; `over` supplies the fields a case cares about. `over`
+// may pass a `rollup` shorthand (name → conclusion) that we compile into the exact per-check fields
+// `classifyMergeability` reads (present/pending/conclusions), mirroring what `fetchPrState` derives.
+function mergePrState(over: Partial<PrState> & { rollup?: { name: string; conclusion: string }[] } = {}): PrState {
+  const { rollup, ...rest } = over;
+  const base: PrState = {
+    merged: false,
+    state: "open",
+    mergeStateStatus: "CLEAN",
+    failingChecks: 0,
+    failingCheckNames: [],
+    totalChecks: 0,
+    presentCheckNames: [],
+    pendingCheckNames: [],
+    checkConclusions: {},
+    isDraft: false,
+    headRefOid: "abc123",
+  };
+  if (rollup) {
+    const bad = new Set(["FAILURE", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "STARTUP_FAILURE", "ERROR"]);
+    const pendingStates = new Set(["", "PENDING", "QUEUED", "IN_PROGRESS", "EXPECTED", "WAITING"]);
+    const present: string[] = [];
+    const pending: string[] = [];
+    const failing: string[] = [];
+    const conclusions: Record<string, string> = {};
+    for (const c of rollup) {
+      const v = c.conclusion.toUpperCase();
+      present.push(c.name);
+      conclusions[c.name] = pendingStates.has(v) ? "" : v;
+      if (pendingStates.has(v)) pending.push(c.name);
+      else if (bad.has(v)) failing.push(c.name);
+    }
+    base.presentCheckNames = present;
+    base.pendingCheckNames = pending;
+    base.checkConclusions = conclusions;
+    base.failingCheckNames = failing;
+    base.failingChecks = failing.length;
+    base.totalChecks = rollup.length;
+  }
+  return { ...base, ...rest };
+}
+
+function reqChecks(...names: string[]): RequiredCheck[] {
+  return names.map((name) => ({ name, acceptedConclusions: ["success"] }));
+}
+
+function protocolWith(over: Partial<MergeProtocol>): MergeProtocol {
+  return { ...DEFAULT_MERGE_PROTOCOL, ...over };
+}
+
+interface MergeCase {
+  name: string;
+  state: Partial<PrState> & { rollup?: { name: string; conclusion: string }[] };
+  protocol?: MergeProtocol;
+  want: Mergeability;
+}
+
+const MERGE_CASES: MergeCase[] = [
+  // The exact defect: UNSTABLE + a red DECLARED-required check used to classify `ready` and merge.
+  {
+    name: "UNSTABLE + red declared-required check -> blocked (the #392 defect)",
+    state: { mergeStateStatus: "UNSTABLE", rollup: [{ name: "test (22.x, simple)", conclusion: "FAILURE" }] },
+    protocol: protocolWith({ requiredChecks: [{ name: "test (22.x, simple)", acceptedConclusions: ["success"] }] }),
+    want: "blocked",
+  },
+  {
+    name: "CLEAN + red declared-required check -> blocked (backstop runs before the switch)",
+    state: { mergeStateStatus: "CLEAN", rollup: [{ name: "build", conclusion: "FAILURE" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "blocked",
+  },
+  {
+    name: "declared-required check pending -> waiting",
+    state: { mergeStateStatus: "CLEAN", rollup: [{ name: "build", conclusion: "IN_PROGRESS" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "waiting",
+  },
+  {
+    name: "declared-required check absent from head -> waiting (absence is not a pass)",
+    state: { mergeStateStatus: "CLEAN", rollup: [{ name: "lint", conclusion: "SUCCESS" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "waiting",
+  },
+  {
+    name: "declared-required check passing, CLEAN -> ready",
+    state: { mergeStateStatus: "CLEAN", rollup: [{ name: "build", conclusion: "SUCCESS" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "ready",
+  },
+  {
+    name: "declared-required check passing, UNSTABLE -> ready (falls through to the switch)",
+    state: { mergeStateStatus: "UNSTABLE", rollup: [{ name: "build", conclusion: "SUCCESS" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "ready",
+  },
+  {
+    name: "non-required check failing (not declared-required), UNSTABLE -> ready (today's behaviour)",
+    state: {
+      mergeStateStatus: "UNSTABLE",
+      rollup: [{ name: "build", conclusion: "SUCCESS" }, { name: "flaky-optional", conclusion: "FAILURE" }],
+    },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "ready",
+  },
+  {
+    name: "CANCELLED superseded by a newer green run on a required check -> ready (#348 semantics)",
+    // `prState`'s rollup shorthand keeps one conclusion per name (latest wins); model the superseded
+    // + re-run by asserting the green outcome the rollup helpers collapse to.
+    state: { mergeStateStatus: "UNSTABLE", rollup: [{ name: "engine-core", conclusion: "SUCCESS" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("engine-core") }),
+    want: "ready",
+  },
+  {
+    name: "acceptedConclusions beyond [success] honoured: NEUTRAL accepted -> ready",
+    state: { mergeStateStatus: "CLEAN", rollup: [{ name: "build", conclusion: "NEUTRAL" }] },
+    protocol: protocolWith({ requiredChecks: [{ name: "build", acceptedConclusions: ["success", "neutral"] }] }),
+    want: "ready",
+  },
+  {
+    name: "acceptedConclusions [success] does NOT accept a NEUTRAL required conclusion -> blocked",
+    state: { mergeStateStatus: "CLEAN", rollup: [{ name: "build", conclusion: "NEUTRAL" }] },
+    protocol: protocolWith({ requiredChecks: [{ name: "build", acceptedConclusions: ["success"] }] }),
+    want: "blocked",
+  },
+  {
+    name: "waitForChecks:true + pending required check -> waiting even when CLEAN",
+    state: { mergeStateStatus: "CLEAN", rollup: [{ name: "build", conclusion: "QUEUED" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build"), waitForChecks: true }),
+    want: "waiting",
+  },
+];
+
+for (const c of MERGE_CASES) {
+  test(`classifyMergeability: ${c.name}`, () => {
+    assertEquals(classifyMergeability(mergePrState(c.state), c.protocol), c.want);
+  });
+}
+
+// Empty requiredChecks (the DEFAULT protocol) — behaviour must be IDENTICAL to today across every
+// mergeStateStatus, whether a protocol is passed or omitted entirely.
+const DEFAULT_BEHAVIOUR: { status: string; failingChecks?: number; want: Mergeability }[] = [
+  { status: "CLEAN", want: "ready" },
+  { status: "HAS_HOOKS", want: "ready" },
+  { status: "UNSTABLE", want: "ready" },
+  { status: "BEHIND", want: "ready" },
+  { status: "DIRTY", want: "conflict" },
+  { status: "BLOCKED", failingChecks: 1, want: "blocked" },
+  { status: "BLOCKED", failingChecks: 0, want: "waiting" },
+  { status: "UNKNOWN", want: "waiting" },
+  { status: "", want: "waiting" },
+];
+
+for (const c of DEFAULT_BEHAVIOUR) {
+  test(`classifyMergeability: empty requiredChecks keeps today's behaviour (${c.status || "''"} -> ${c.want})`, () => {
+    const s = prState({ mergeStateStatus: c.status, failingChecks: c.failingChecks ?? 0 });
+    // Explicit default protocol and omitted-protocol must agree.
+    assertEquals(classifyMergeability(s, DEFAULT_MERGE_PROTOCOL), c.want);
+    assertEquals(classifyMergeability(s), c.want);
+  });
+}
+
+// Token mode: the transport can't enumerate checks (`failingChecks === -1`, empty per-check lists),
+// so even a repo that declares requiredChecks must fall through to today's `mergeStateStatus`
+// behaviour — the backstop must NEVER newly block or wait when checks are unenumerable.
+const TOKEN_MODE: { status: string; want: Mergeability }[] = [
+  { status: "CLEAN", want: "ready" },
+  { status: "UNSTABLE", want: "ready" },
+  { status: "BLOCKED", want: "waiting" }, // failingChecks<0 → conservative wait, exactly as before
+  { status: "DIRTY", want: "conflict" },
+  { status: "UNKNOWN", want: "waiting" },
+];
+
+for (const c of TOKEN_MODE) {
+  test(`classifyMergeability: token mode falls through, never newly blocks (${c.status} -> ${c.want})`, () => {
+    const s = prState({
+      mergeStateStatus: c.status,
+      failingChecks: -1,
+      totalChecks: -1,
+      presentCheckNames: [],
+      pendingCheckNames: [],
+      checkConclusions: {},
+    });
+    const protocol = protocolWith({ requiredChecks: reqChecks("build"), waitForChecks: true });
+    assertEquals(classifyMergeability(s, protocol), c.want);
+  });
+}
+
+// `checkConclusions` must report a terminal conclusion per check but normalise a STILL-IN-FLIGHT run
+// to "" for BOTH rollup shapes — a CheckRun whose `status` is not COMPLETED, and a legacy
+// StatusContext whose `state` is PENDING/EXPECTED — so a caller never mistakes a pending
+// status-context's upper-cased `state` (e.g. "PENDING") for a terminal conclusion.
+test("checkConclusions: in-flight runs map to '' for both CheckRun and StatusContext shapes", () => {
+  const got = checkConclusions([
+    { name: "ci-success", status: "COMPLETED", conclusion: "SUCCESS" },
+    { name: "ci-failure", status: "COMPLETED", conclusion: "FAILURE" },
+    { name: "ci-running", status: "IN_PROGRESS" }, // CheckRun in flight -> ""
+    { name: "ci-queued", status: "QUEUED" }, // CheckRun queued -> ""
+    { context: "legacy-pending", state: "PENDING" }, // StatusContext in flight -> ""
+    { context: "legacy-expected", state: "EXPECTED" }, // StatusContext in flight -> ""
+    { context: "legacy-error", state: "ERROR" }, // StatusContext terminal -> preserved
+  ]);
+  assertEquals(got, {
+    "ci-success": "SUCCESS",
+    "ci-failure": "FAILURE",
+    "ci-running": "",
+    "ci-queued": "",
+    "legacy-pending": "",
+    "legacy-expected": "",
+    "legacy-error": "ERROR",
+  });
+});

package/app/github.ts

@@ -11,6 +11,11 @@
 // The poller is app-side host glue (main.ts), so host-specific subprocess I/O is allowed here.
 // Cross-runtime: runs under Node (`node:child_process`).
 
+// Type-only import (erased at runtime, so no runtime cycle with mergeProtocol.ts, which imports
+// `fetchRepoFile` from here): `classifyMergeability` reads a repo's declared required checks to gate
+// a merge independently of GitHub branch protection.
+import type { MergeProtocol } from "./mergeProtocol.ts";
+
 /** A GitHub pull-request review, narrowed to the fields the poller needs. */
 export interface GhReview {
   id: number;
@@ -502,6 +507,17 @@ export interface PrState {
    * unrelated always-on check (e.g. Mergify's "Merge Queue") must not read as "the required run
    * already happened". */
   presentCheckNames: string[];
+  /** Names of every head check still in flight (queued/in progress, not yet concluded and not a hard
+  * failure), derived over the newest run per check (`pendingCheckNames`). Empty in token mode (the
+  * REST fallback can't enumerate checks). Lets `classifyMergeability` hold a merge when a
+  * declared-required check has not yet concluded, without re-deriving conclusions by hand. */
+  pendingCheckNames: string[];
+  /** The newest concluded conclusion per head check (name → uppercase conclusion, e.g. `SUCCESS` /
+  * `FAILURE` / `NEUTRAL` / `SKIPPED`), derived over `latestRunPerCheck` so a `CANCELLED` run
+  * superseded by a newer green run on the same head reports the green result (#348). A still-pending
+  * run maps to `""` (it has no conclusion yet — use `pendingCheckNames`). Empty in token mode. Lets
+  * `classifyMergeability` honour a required check's `acceptedConclusions` precisely. */
+  checkConclusions: Record<string, string>;
   /** Whether the PR is a draft (a fresh head run is produced by marking it ready, not reopen). */
   isDraft: boolean;
   /** Current head commit. Used to scope one-shot merge-protocol nudges to a landing attempt. */
@@ -633,6 +649,29 @@ export function allCheckNames(rollup: RollupEntry[]): string[] {
   return names;
 }
 
+/** The ground-truth conclusion of each head check, keyed by check name, derived over the **newest run
+ * per check** (`latestRunPerCheck`) so a `CANCELLED` run superseded by a newer green run on the
+ * identical head SHA reports the green result, not the stale cancellation (issue #348). The value is
+ * the run's `conclusion` (CheckRun) or `state` (legacy StatusContext), upper-cased; a still-in-flight
+ * run that has not concluded maps to `""` (it has no conclusion — `pendingCheckNames` tracks those).
+ * In-flight is normalised to `""` for BOTH shapes: a CheckRun whose `status` is not `COMPLETED`, and a
+ * legacy StatusContext whose `state` is `PENDING`/`EXPECTED`, so a caller never mistakes a pending
+ * status-context's `PENDING`/`EXPECTED` `state` for a terminal conclusion.
+ * Lets `classifyMergeability` intersect a repo's declared `requiredChecks` against actual head
+ * conclusions and honour each check's `acceptedConclusions` without re-deriving per-run state. */
+export function checkConclusions(rollup: RollupEntry[]): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const c of latestRunPerCheck(rollup)) {
+    const status = (c.status || "").toUpperCase();
+    const state = (c.state || "").toUpperCase();
+    // A still-in-flight run has no terminal conclusion — normalise both shapes to "" (mirrors
+    // `pendingCheckNames`): CheckRun status != COMPLETED, or legacy StatusContext state PENDING/EXPECTED.
+    const inFlight = status !== "" ? status !== "COMPLETED" : state === "PENDING" || state === "EXPECTED";
+    out[checkKey(c)] = inFlight ? "" : (c.conclusion || c.state || "").toUpperCase();
+  }
+  return out;
+}
+
 /** True when `err` is GitHub reporting that a ref which parsed as `owner/repo#N` is not a pull
  * request — either it's an issue (issues and PRs share GitHub's number space, so an issue number
  * is indistinguishable from a PR number by shape alone) or the number does not exist. Both
@@ -682,6 +721,8 @@ export async function fetchPrState(
       failingCheckNames: names,
       totalChecks: rollup.length,
       presentCheckNames: allCheckNames(rollup),
+      pendingCheckNames: pendingCheckNames(rollup),
+      checkConclusions: checkConclusions(rollup),
       isDraft: !!j.isDraft,
       headRefOid: j.headRefOid ?? null,
     };
@@ -713,6 +754,8 @@ export async function fetchPrState(
     failingCheckNames: [], // …and the CI-fix agent gets no per-check list in token mode
     totalChecks: -1, // …and the fresh-head-run remedy stays conservative (never reopens blind)
     presentCheckNames: [], // …can't enumerate checks in token mode → no required-check presence signal
+    pendingCheckNames: [], // …no per-check pending signal either → classifier degrades to today's switch
+    checkConclusions: {}, // …no per-check conclusions → protocol-aware gate falls through in token mode
     isDraft: !!j.draft,
     headRefOid: j.head?.sha ?? null,
   };
@@ -915,11 +958,68 @@ export async function baseBranchLanded(
  * verdict; `waiting` means re-poll later. */
 export type Mergeability = "ready" | "waiting" | "conflict" | "blocked";
 
-export function classifyMergeability(s: PrState): Mergeability {
+/** Intersect a repo's declared `requiredChecks` against the head's actual per-check conclusions —
+ * an INDEPENDENT backstop that runs BEFORE the `mergeStateStatus` switch, so nwf never merges a red
+ * required check even on a repo that has NOT wired that check as a GitHub-required status check
+ * (issue #392). Returns:
+ *   • `"blocked"` — a declared-required check is present, concluded, and its conclusion is NOT in that
+ *      check's `acceptedConclusions` (a hard failure like `FAILURE`, or any other unaccepted terminal
+ *      conclusion) → route to fix-ci, do not merge.
+ *   • `"waiting"` — a declared-required check is still pending, or absent from the head entirely
+ *      (not-yet-run counts as pending, NOT as pass): a declared-required check that has not
+ *      concluded is never mergeable.
+ *   • `"pass"` — every declared-required check is present and its conclusion accepted → fall through to
+ *      today's `mergeStateStatus` logic (GitHub branch protection stays the primary gate).
+ * Degrades safely: with no declared `requiredChecks`, or in token mode where checks can't be
+ * enumerated (`failingChecks < 0`, so the per-check lists are empty), it returns `"pass"` and never
+ * newly blocks or waits — repos keep exactly today's behaviour. */
+function requiredChecksVerdict(s: PrState, protocol?: MergeProtocol): "blocked" | "waiting" | "pass" {
+  const required = protocol?.requiredChecks ?? [];
+  if (required.length === 0) return "pass";
+  // Token mode: the transport can't enumerate checks (`failingChecks === -1`), so the per-check lists
+  // are empty and absence is indistinguishable from not-yet-run. Do NOT newly block/wait — fall
+  // through to today's `mergeStateStatus` behaviour. (A real gh-mode head with no checks yet reports
+  // `failingChecks === 0`, so absence there is correctly treated as not-yet-run below.)
+  if (s.failingChecks < 0) return "pass";
+  const present = new Set(s.presentCheckNames);
+  const pending = new Set(s.pendingCheckNames);
+  let anyBlocked = false;
+  let anyPending = false;
+  for (const rc of required) {
+    // Absent from the head, or still in flight → not-yet-run → wait (never treat absence as pass).
+    if (!present.has(rc.name) || pending.has(rc.name)) {
+      anyPending = true;
+      continue;
+    }
+    const conclusion = (s.checkConclusions[rc.name] ?? "").toUpperCase();
+    if (conclusion === "") {
+      // Present but no terminal conclusion yet (and not flagged pending) — treat conservatively as
+      // not-yet-concluded rather than as a pass.
+      anyPending = true;
+      continue;
+    }
+    const accepted = rc.acceptedConclusions.map((a) => a.toUpperCase());
+    if (accepted.includes(conclusion)) continue; // satisfied
+    anyBlocked = true; // present, concluded, NOT accepted → a red required check
+  }
+  // A failing required check outranks a pending one: it needs fix-ci now, not more waiting.
+  if (anyBlocked) return "blocked";
+  if (anyPending) return "waiting";
+  return "pass";
+}
+
+export function classifyMergeability(s: PrState, protocol?: MergeProtocol): Mergeability {
+  // Protocol-aware backstop FIRST (issue #392): honour the repo's declared `requiredChecks`
+  // against the actual head rollup, so an `UNSTABLE` PR with a red DECLARED-required
+  // check is no longer blindly `ready`. This never weakens GitHub branch protection (the switch
+  // below still gates) — it only tightens merges on repos that under-specify their required checks.
+  const gate = requiredChecksVerdict(s, protocol);
+  if (gate === "blocked") return "blocked";
+  if (gate === "waiting") return "waiting";
   switch (s.mergeStateStatus) {
     case "CLEAN":
     case "HAS_HOOKS":
-    case "UNSTABLE": // only non-required checks failing — still mergeable
+    case "UNSTABLE": // only non-required checks failing — still mergeable (no DECLARED-required red)
     case "BEHIND": // out of date; a queue rebases, a direct merge is still allowed
       return "ready";
     case "DIRTY":

package/app/readiness.test.ts

@@ -414,6 +414,8 @@ function prObs(over: Partial<PrObservation> = {}): PrObservation {
     failingCheckNames: [],
     totalChecks: 0,
     presentCheckNames: [],
+    pendingCheckNames: [],
+    checkConclusions: {},
     isDraft: false,
     headRefOid: "abc123",
     mergedSha: null,

package/app/readiness.ts

@@ -18,7 +18,7 @@
 // any credential is read at execution time from the typed env-contract (`credentialEnv` names a
 // declared {@link EnvKey}; ADR 0004 pinned decision 2) and is redacted from every log line.
 import { isEnvKey, readEnv, readEnvOr } from "./contracts.ts";
-import { allCheckNames, classifyMergeability, failingCheckNames, type PrState, pendingCheckNames } from "./github.ts";
+import { allCheckNames, checkConclusions, classifyMergeability, failingCheckNames, type PrState, pendingCheckNames } from "./github.ts";
 import { isoDuration, isoDurationToMs } from "./reviewWait.ts";
 
 /** The built-in readiness sources. `command` is the escape hatch that subsumes the long tail
@@ -565,6 +565,8 @@ export function parsePrView(payload: unknown): PrObservation {
     failingCheckNames: names,
     totalChecks: rollup.length,
     presentCheckNames: allCheckNames(rollup),
+    pendingCheckNames: pending,
+    checkConclusions: checkConclusions(rollup),
     isDraft: j.isDraft === true,
     headRefOid: str(j.headRefOid).trim() || null,
     mergedSha,

package/app/service.ts

@@ -1150,7 +1150,11 @@ export async function pollMerges(data: DataLayer, engine: EngineClient, token: s
       // (#342/#350). Reuse the `st` we just read so we don't double-fetch. This is the proven terminal
       // path the whole class (#368) now shares.
       if (await advanceIfTerminalOutOfBand(data, engine, pr, token, st)) continue;
-      const verdict = classifyMergeability(st);
+      // Load the repo's merge protocol ONCE per PR iteration and pass it into the classifier so the
+      // protocol-aware backstop (#392) can gate a red DECLARED-required check even when GitHub reports
+      // the PR as UNSTABLE. The same handle is reused by the frugal-CI fresh-head-run branch below.
+      const protocol = await loadMergeProtocol(repo, token).catch(() => null);
+      const verdict = classifyMergeability(st, protocol ?? undefined);
       if (verdict === "waiting") {
         // Frugal-CI remedy (#43): when the repo publishes a merge protocol that wants a fresh
         // head run and the PR has NO required head run yet, review has converged but the last push
@@ -1161,7 +1165,6 @@ export async function pollMerges(data: DataLayer, engine: EngineClient, token: s
         // `pull_request` run once per head (mark ready / close+reopen); rebases change
         // `headRefOid`, so downstream merge-train PRs get a new nudge after every post-rebase
         // landing attempt.
-        const protocol = await loadMergeProtocol(repo, token).catch(() => null);
         if (protocol) {
           const action = freshHeadRunAction(protocol, verdict, headRunPresenceCount(protocol, st), st.isDraft, {
             headRefOid: st.headRefOid,