@nanobpm/nano-workforce 0.208.5 → 0.209.1

package/pages/_nav.json

@@ -11,7 +11,18 @@
       { "label": "Convergence", "page": "home" },
       { "label": "Epics", "page": "epic" },
       { "label": "Feature", "page": "feature" },
-      { "label": "Delivery Graphs", "page": "delivery-graphs" },
+      {
+        "label": "Delivery Graphs",
+        "page": "delivery-graphs",
+        "badge": {
+          "source": "app",
+          "table": "delivery_graph_proposals",
+          "filter": [{ "field": "status", "eq": "staged" }],
+          "tone": "ok",
+          "refreshMs": 5000,
+          "hideWhenZero": true
+        }
+      },
       {
         "label": "Tasks",
         "page": "tasks",

package/pages/auto-resolutions.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/board.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/cockpit.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/delivery-graph-detail.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/delivery-graphs.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/epic-detail.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/epic.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/feature.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/home.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/lineage.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/mcp.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/overview.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/tasks.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/pages/velocity.page.json

@@ -35,7 +35,20 @@
           },
           {
             "label": "Delivery Graphs",
-            "page": "delivery-graphs"
+            "page": "delivery-graphs",
+            "badge": {
+              "source": "app",
+              "table": "delivery_graph_proposals",
+              "filter": [
+                {
+                  "field": "status",
+                  "eq": "staged"
+                }
+              ],
+              "tone": "ok",
+              "refreshMs": 5000,
+              "hideWhenZero": true
+            }
           },
           {
             "label": "Tasks",

package/resources/processes/merge-loop.bpmn

@@ -55,6 +55,7 @@
           <nano:extend name="failingChecksList" type="string" optional="true" />
           <nano:extend name="reviewThreads" type="integer" optional="true" />
           <nano:extend name="pendingChecks" type="integer" optional="true" />
+          <nano:extend name="updatePending" type="boolean" optional="true" />
         </nano:shape>
         <nano:shape id="LandedProbeIn" name="Landed probe — input">
           <nano:extend name="prKey" type="string" />
@@ -846,7 +847,7 @@
     <bpmn:sequenceFlow id="f_mw_stall" sourceRef="wait-mergeable-timeout" targetRef="merge-stall-probe" />
     <bpmn:sequenceFlow id="f_msp_gate" sourceRef="merge-stall-probe" targetRef="gw-merge-stall" />
     <bpmn:sequenceFlow id="f_msp_rederive" name="re-derived — route to arm" sourceRef="gw-merge-stall" targetRef="gw-mergeable">
-      <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=mergeStallRounds &lt;= mergeStallMax</bpmn:conditionExpression>
+      <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=mergeStallRounds &lt;= mergeStallMax or mergeState = "ready" or updatePending = true</bpmn:conditionExpression>
     </bpmn:sequenceFlow>
     <bpmn:sequenceFlow id="f_msp_giveup" name="stall budget exhausted" sourceRef="gw-merge-stall" targetRef="merge-esc-conflict" />
     <bpmn:sequenceFlow id="f_m_ready" sourceRef="wait-mergeable" targetRef="gw-mergeable" />

package/scripts/sync-nav.test.ts

@@ -85,3 +85,41 @@ test("issue #306: the badge's user_tasks table is defined by the migrations", ()
     "badge table \"user_tasks\" must be created (TABLE or VIEW) by db/migrations/*.sql",
   );
 });
+
+test("the Delivery Graphs nav item carries the staged-proposals-awaiting-approval badge", () => {
+  const canon = JSON.parse(readFileSync(`${ROOT}pages/_nav.json`, "utf8"));
+  const items = canon?.props?.items ?? [];
+  const dg = items.find((i: Json) => i?.page === "delivery-graphs");
+  assert(dg, "canonical nav has no Delivery Graphs item");
+  const badge = dg.badge;
+  assert(badge, "Delivery Graphs nav item must declare a live count badge");
+  // Counts ONLY proposals awaiting approval (status = staged) — dropping the filter
+  // would count approved/rejected proposals too; the drift check alone can't catch that.
+  assert(badge.source === "app", "badge.source must be \"app\"");
+  assert(
+    badge.table === "delivery_graph_proposals",
+    "badge.table must be \"delivery_graph_proposals\"",
+  );
+  assert(
+    stable(badge.filter) === stable([{ field: "status", eq: "staged" }]),
+    "badge.filter must be exactly [{ field: \"status\", eq: \"staged\" }]",
+  );
+  assert(badge.tone === "ok", "badge.tone must be \"ok\" (green)");
+  assert(badge.refreshMs === 5000, "badge.refreshMs must be 5000");
+  assert(badge.hideWhenZero === true, "badge.hideWhenZero must be true");
+
+  let sql = "";
+  for (const e of readdirSync(`${ROOT}db/migrations`, { withFileTypes: true })) {
+    if (e.isFile() && e.name.endsWith(".sql")) {
+      sql += readFileSync(`${ROOT}db/migrations/${e.name}`, "utf8");
+    }
+  }
+  assert(
+    /CREATE\s+(?:TABLE|VIEW)\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?delivery_graph_proposals["`]?/i.test(sql),
+    "badge table \"delivery_graph_proposals\" must be created by db/migrations/*.sql",
+  );
+  assert(
+    /delivery_graph_proposals[\s\S]*?\bstatus\b/i.test(sql),
+    "delivery_graph_proposals must have a status column",
+  );
+});

package/workers/merge-stall-probe/worker.test.ts

@@ -0,0 +1,119 @@
+// pr.merge-stall-probe — issue #951: the probe must re-read PR state before the merge loop can
+// escalate. A PR that already MERGED (a human queued it while the loop waited) must surface `ready`
+// so `gw-merge-stall` routes it to `attempt-merge` (whose already-merged short-circuit ends the loop
+// as merged) instead of exhausting the stall budget into a "merge-blocked" escalation.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import type { PrState } from "../../app/github.ts";
+import { DEFAULT_MERGE_PROTOCOL, type MergeProtocol } from "../../app/mergeProtocol.ts";
+import { noopLog } from "../../test/log.ts";
+import { makeHandler } from "./worker.ts";
+
+function state(over: Partial<PrState>): PrState {
+  return {
+    merged: false,
+    state: "open",
+    mergeStateStatus: "BLOCKED",
+    failingChecks: 0,
+    failingCheckNames: [],
+    presentCheckNames: ["build", "Mergify Merge Queue"],
+    pendingCheckNames: [],
+    checkConclusions: { build: "SUCCESS", "Mergify Merge Queue": "NEUTRAL" },
+    totalChecks: 2,
+    isDraft: false,
+    headRefOid: "abc",
+    mergeQueueEntry: null,
+    unresolvedThreads: 0,
+    ...over,
+  };
+}
+
+const MERGIFY: MergeProtocol = {
+  ...DEFAULT_MERGE_PROTOCOL,
+  land: { method: "mergify-queue", comment: "@mergifyio queue" },
+  requiredChecks: [{ name: "build", acceptedConclusions: ["success"] }],
+};
+
+async function run(st: PrState, protocol: MergeProtocol | null, isUpdatePending = false): Promise<Record<string, unknown>> {
+  const handler = makeHandler({
+    readState: () => Promise.resolve(st),
+    readProtocol: () => Promise.resolve(protocol),
+    isUpdatePending: () => isUpdatePending,
+  });
+  const job: any = { variables: { prKey: "o/r#1", repo: "o/r", prNumber: 1 } };
+  const app: any = { log: noopLog() };
+  return (await handler(job, app)) as Record<string, unknown>;
+}
+
+async function runNullRead(isUpdatePending = false): Promise<Record<string, unknown>> {
+  const handler = makeHandler({
+    readState: () => Promise.reject(new Error("GitHub unreachable")),
+    readProtocol: () => Promise.resolve(null),
+    isUpdatePending: () => isUpdatePending,
+  });
+  const job: any = { variables: { prKey: "o/r#1", repo: "o/r", prNumber: 1 } };
+  const app: any = { log: noopLog() };
+  return (await handler(job, app)) as Record<string, unknown>;
+}
+
+test("merge-stall-probe: a PR already MERGED surfaces `ready` (never an escalation) (#951)", async () => {
+  const out = await run(state({ merged: true, state: "merged", mergeStateStatus: "UNKNOWN" }), MERGIFY);
+  assertEquals(out.mergeState, "ready");
+});
+
+test("merge-stall-probe: a CLOSED PR surfaces `ready` so attempt-merge abandons it (#951)", async () => {
+  const out = await run(state({ state: "closed", mergeStateStatus: "UNKNOWN" }), null);
+  assertEquals(out.mergeState, "ready");
+});
+
+test("merge-stall-probe: green PR awaiting `@mergifyio queue` is `ready`, not a review stall (#951)", async () => {
+  const out = await run(state({}), MERGIFY);
+  assertEquals(out.mergeState, "ready");
+});
+
+test("merge-stall-probe: BLOCKED gh-merge PR with green checks still waits (#951)", async () => {
+  const out = await run(state({}), { ...MERGIFY, land: { method: "gh-merge" } });
+  assertEquals(out.mergeState, "waiting");
+});
+
+// Issue #951 review: while an accepted (async) update-branch still exposes the old head, the probe
+// must NOT classify that head's stale check failures as `blocked` (which starts fix-ci / escalates).
+// It defers to `waiting` (bounded re-poll) until the head moves or the remedy's window lapses.
+test("merge-stall-probe: a blocked verdict on a pending-update old head defers to waiting (#951)", async () => {
+  const blocked = state({ failingChecks: 1, failingCheckNames: ["build"], checkConclusions: { build: "FAILURE" } });
+  // Sanity: without a pending update this IS blocked (would route to fix-ci).
+  assertEquals((await run(blocked, MERGIFY, false)).mergeState, "blocked");
+  // With the update still pending on this head, the probe holds remediation.
+  const held = await run(blocked, MERGIFY, true);
+  assertEquals(held.mergeState, "waiting");
+  // The hold is surfaced so gw-merge-stall re-polls past the stall cap (only for this hold).
+  assertEquals(held.updatePending, true);
+  assertEquals((await run(blocked, MERGIFY, false)).updatePending, false);
+});
+
+test("merge-stall-probe: a non-blocked verdict is never downgraded by a pending update (#951)", async () => {
+  // A ready PR stays ready even if (spuriously) an update is pending — the hold only masks `blocked`.
+  const out = await run(state({}), MERGIFY, true);
+  assertEquals(out.mergeState, "ready");
+});
+
+// PR #953 review: a probe that emits `updatePending: true` is followed (next re-poll) by a read that
+// does NOT recompute the hold — a failed/null state read, or a terminal (merged/closed) liveness
+// short-circuit. Those paths must explicitly clear the flag: an omitted field would leave the stale
+// `true` standing, and `gw-merge-stall` would keep bypassing the stall cap on it even after the
+// remedy's bounded hold expired — a GitHub outage would turn the bounded hold into an indefinite
+// re-poll.
+test("merge-stall-probe: a failed/null state read clears updatePending (no stale cap bypass) (#953)", async () => {
+  const out = await runNullRead(true);
+  assertEquals(out.mergeState, "waiting");
+  assertEquals(out.updatePending, false);
+});
+
+test("merge-stall-probe: a terminal (merged/closed) read clears updatePending (#953)", async () => {
+  const merged = await run(state({ merged: true, state: "merged", mergeStateStatus: "UNKNOWN" }), MERGIFY, true);
+  assertEquals(merged.mergeState, "ready");
+  assertEquals(merged.updatePending, false);
+  const closed = await run(state({ state: "closed", mergeStateStatus: "UNKNOWN" }), null, true);
+  assertEquals(closed.mergeState, "ready");
+  assertEquals(closed.updatePending, false);
+});

package/workers/merge-stall-probe/worker.ts

@@ -17,8 +17,9 @@
 // (incremented by this task's output mapping, capped by `mergeStallMax`) stops the probe from
 // re-arming forever: once exhausted, `gw-merge-stall` routes to human escalation instead.
 import type { AppJobHandler } from "@nanobpm/urban";
-import { classifyMergeability, fetchPrState } from "../../app/github.ts";
-import { loadMergeProtocol } from "../../app/mergeProtocol.ts";
+import { isBehindBaseUpdatePending } from "../../app/behindBaseRemedy.ts";
+import { classifyMergeability, classifyPrLiveness, fetchPrState, type PrState } from "../../app/github.ts";
+import { loadMergeProtocol, type MergeProtocol } from "../../app/mergeProtocol.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
 
 // Input typed off the model data envelope (`MergeStallProbeIn` in merge-loop.bpmn) — ADR 0040.
@@ -43,7 +44,25 @@ interface Out extends Record<string, unknown> {
   pendingChecks: number;
 }
 
-const handler: AppJobHandler<In, Out> = async (job, app) => {
+/** Injectable GitHub readers (tests stub them); the default export binds the real ones. */
+export interface StallProbeDeps {
+  readState: (repo: string, prNumber: number, token: string) => Promise<PrState | null>;
+  readProtocol: (repo: string, token: string) => Promise<MergeProtocol | null>;
+  /** Issue #951 review: is an accepted (async) update-branch still holding this head? While it is,
+   * the old head's stale check failures must NOT classify as `blocked` (which would start fix-ci /
+   * escalate) — the branch update is in flight and will move the head. Bounded by the remedy's own
+   * window, so a never-applied update stops holding. */
+  isUpdatePending: (repo: string, prNumber: number, headOid: string) => boolean;
+}
+
+const realDeps: StallProbeDeps = {
+  readState: (repo, prNumber, token) => fetchPrState(repo, prNumber, token, { withReviewThreads: true }),
+  readProtocol: (repo, token) => loadMergeProtocol(repo, token),
+  isUpdatePending: (repo, prNumber, headOid) => isBehindBaseUpdatePending(repo, prNumber, headOid),
+};
+
+export function makeHandler(deps: StallProbeDeps): AppJobHandler<In, Out> {
+  return async (job, app) => {
   const { repo, prNumber } = job.variables;
   const token = process.env.GITHUB_TOKEN ?? "";
 
@@ -57,12 +76,50 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   // classified by its real cause (issue #921) — unresolved review threads surface as the
   // `review-threads` verdict and route to their own arm instead of re-polling until the budget
   // exhausts into the misleading "mergeability never settled" escalation.
-  const st = await fetchPrState(repo, prNumber, token, { withReviewThreads: true }).catch(() => null);
+  const st = await deps.readState(repo, prNumber, token).catch(() => null);
   if (st === null) {
-    return { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: -1, pendingChecks: 0 };
+    // Explicitly clear `updatePending` (PR #953 review): a failed/null read returns `waiting`
+    // WITHOUT recomputing the hold, and an omitted field would leave any earlier `true` standing —
+    // `gw-merge-stall` would then keep bypassing the stall cap on the stale flag even after the
+    // remedy's bounded hold expired. Returning `false` keeps a GitHub outage from turning the
+    // bounded hold into an indefinite re-poll.
+    return { mergeState: "waiting", updatePending: false, failingChecks: 0, failingChecksList: "", reviewThreads: -1, pendingChecks: 0 };
+  }
+  // Issue #951: re-read PR liveness BEFORE any verdict. A PR that already MERGED (e.g. a human
+  // queued it while the loop waited) or was CLOSED must never reach an escalation: surface `ready`,
+  // which `gw-merge-stall` always routes (even past the stall budget) to `attempt-merge`, whose
+  // already-merged / closed short-circuits finish the loop as merged / abandoned.
+  const liveness = classifyPrLiveness(st);
+  if (liveness === "merged" || liveness === "closed") {
+    app.log.info("merge-stall-probe: PR already terminal — routing to attempt-merge short-circuit", {
+      prKey: job.variables.prKey,
+      liveness,
+    });
+    // `updatePending: false` here too: a terminal PR short-circuits the merge, so a stale hold
+    // from an earlier round must not survive into `gw-merge-stall`'s bypass-cap condition.
+    return { mergeState: "ready", updatePending: false, failingChecks: 0, failingChecksList: "", reviewThreads: 0, pendingChecks: 0 };
+  }
+  const protocol = await deps.readProtocol(repo, token).catch(() => null);
+  let mergeState = classifyMergeability(st, protocol ?? undefined);
+
+  // Issue #951 review: a `blocked` verdict on the OLD head while an accepted update-branch is still
+  // pending is a stale-read, not a real block — the poller's behind-base remedy is holding that head
+  // (no fix-ci on its stale failures) until GitHub applies the update and the head moves. Mirroring
+  // that hold here, the probe downgrades the verdict to `waiting` so `gw-mergeable` routes to the
+  // bounded re-poll (`wait-mergeable-repoll`) instead of dispatching fix-ci / escalating against a
+  // head that is about to change. The hold shares the remedy's bounded window, so a never-applied
+  // update stops holding and the next probe judges the (still-red) head afresh.
+  // `updatePending` is surfaced so `gw-merge-stall` keeps re-polling inside the remedy's bounded hold
+  // window even once `mergeStallMax` is spent (an ordinary `waiting` still respects the stall cap).
+  let updatePending = false;
+  if (mergeState === "blocked" && st.headRefOid && deps.isUpdatePending(repo, prNumber, st.headRefOid)) {
+    updatePending = true;
+    app.log.info("merge-stall-probe: behind-base update pending — deferring remediation until the head moves", {
+      prKey: job.variables.prKey,
+      head: st.headRefOid,
+    });
+    mergeState = "waiting";
   }
-  const protocol = await loadMergeProtocol(repo, token).catch(() => null);
-  const mergeState = classifyMergeability(st, protocol ?? undefined);
 
   app.log.info("merge-stall-probe: poller stalled — re-derived mergeability", {
     prKey: job.variables.prKey,
@@ -72,6 +129,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
 
   return {
     mergeState,
+    updatePending,
     // Carried for the CI-fix arm (mergeState "blocked" = a failed required check), mirroring the
     // poller's `merge-ready` payload so fix-ci knows which gates to green.
     failingChecks: st.failingChecks,
@@ -79,6 +137,9 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     reviewThreads: st.unresolvedThreads,
     pendingChecks: st.pendingCheckNames.length,
   };
-};
+  };
+}
+
+const handler: AppJobHandler<In, Out> = makeHandler(realDeps);
 
 export default handler;