@nanobpm/nano-workforce 0.102.0 → 0.102.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.102.1](https://github.com/nanobpm/nano-workforce/compare/v0.102.0...v0.102.1) (2026-08-19)
+
+
+### Bug Fixes
+
+* **merge-loop:** re-attempt merge for stale/transient CI instead of paging a human ([#348](https://github.com/nanobpm/nano-workforce/issues/348)) ([#350](https://github.com/nanobpm/nano-workforce/issues/350)) ([87ce2d6](https://github.com/nanobpm/nano-workforce/commit/87ce2d69e893b4b0f965f481d6c247fb8fcb84e8))
+
 # [0.102.0](https://github.com/nanobpm/nano-workforce/compare/v0.101.1...v0.102.0) (2026-08-19)
 
 

package/SPEC.md

@@ -424,8 +424,30 @@ start ─► wait: deps merged ─► arm merge ─► wait: mergeable ─┬─
   check names ride `appendPrompt`) to green the checks on the branch, then re-arms the
   poller. It repeats while `ciFixRound < ciFixMax`
   (`NANO_PR_MAX_CI_FIX_ROUNDS`, default 3; `0` disables). Only when the budget is
-  exhausted, the agent reports `blocked`, or the branch is in `conflict` does it fall
-  through to the human escalation path.
+  exhausted, the agent reports `blocked` *and the PR is still blocked after a
+  ground-truth reconcile*, or the branch is in `conflict` does it fall through to the
+  human escalation path.
+
+- **Stale / transient checks — re-attempt, don't escalate** (issue #348) — GitHub's CI
+  concurrency **cancels** a superseded workflow run while a newer run on the *identical
+  head SHA* takes over. Both land in the head's `statusCheckRollup` under the same check
+  name — the stale one stamped `CANCELLED`, the live one green. This is a
+  **CI-concurrency-cancellation drift class**, not a code defect, defended at three
+  layers so it never pages a human:
+  - **Derivation (root cause)** — the merge poller's check derivation collapses the
+    rollup to the **newest run per `(headSha, checkName)`** (`latestRunPerCheck`) before
+    classifying, so a `CANCELLED` run superseded by a newer green run is **not** counted
+    as a failing gate. The phantom `blocked` never arises, so `fix-ci` is not even armed.
+  - **Agent verdict** — when `fix-ci` pushes nothing because the failing checks are
+    stale/transient (head already green), it returns `status: "reattempt"` (with
+    `pushed: false`). That routes to `arm-merge` — the merge is simply re-queued from
+    ground truth. The prompt reserves `blocked` for a genuine human decision (a missing
+    secret, an un-fixable failure), never a self-healing PR.
+  - **Reconcile-before-escalate guard** — even a *mislabelled* `blocked` self-heals: a
+    `blocked` verdict with no push (`pushed != true`) reconciles **once** via ground
+    truth (`gw-ci-blocked` → `ci-reconcile`, which re-arms the canonical merge poller and
+    sets `ciBlockedReconciled`), and escalates only if the PR is **still** blocked on the
+    re-derived state.
 
 - **Discovered dependency** — a `senior:fix-ci` or `senior:rebase` agent may find that
   the PR cannot land because **another PR must merge first** (a required linked-issue

package/app/failingChecksSupersede.test.ts

@@ -0,0 +1,93 @@
+// Derivation-layer guard for the CI-concurrency-cancellation drift class (issue #348).
+//
+// GitHub's CI concurrency cancels a superseded workflow run while a newer run on the *identical
+// head SHA* takes over. Both land in the head's `statusCheckRollup` under the same check name — the
+// stale one stamped `CANCELLED`, the live one green. The merge poller's check derivation used to
+// count that stale `CANCELLED` as a failing required check, so a PR whose head is actually green
+// read as `blocked`, armed `senior:fix-ci`, which honestly pushed nothing and (pre-#348) returned
+// `blocked` → a human merge-escalation for a self-healing PR.
+//
+// The fix collapses the rollup to the NEWEST run per check before classifying, so a superseded
+// `CANCELLED` never counts. These are pure unit tests over the exported derivation helpers.
+
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import { allCheckNames, failingCheckNames, latestRunPerCheck } from "./github.ts";
+
+test("a CANCELLED run superseded by a newer green run on the same head does not count as failing", () => {
+  const rollup = [
+    // The superseded run: GitHub CI concurrency cancelled it when a newer run started.
+    { name: "engine-core", conclusion: "CANCELLED", startedAt: "2024-01-01T00:00:00Z", completedAt: "2024-01-01T00:01:00Z" },
+    // The live run on the identical head SHA: green.
+    { name: "engine-core", conclusion: "SUCCESS", startedAt: "2024-01-01T00:02:00Z", completedAt: "2024-01-01T00:05:00Z" },
+  ];
+  assertEquals(failingCheckNames(rollup), [], "the stale CANCELLED must not read as a failing gate");
+});
+
+test("every CANCELLED-superseded required check on one head SHA is dropped (the #348 instance)", () => {
+  // The exact PR #887 evidence: four required checks each with a superseded CANCELLED + a newer
+  // green run on the same head. None must count as failing.
+  const names = ["engine-core", "engine-wasm read-model wasm32 type-check", "processos", "server"];
+  const rollup = names.flatMap((name) => [
+    { name, conclusion: "CANCELLED", startedAt: "2024-01-01T00:00:00Z" },
+    { name, conclusion: "SUCCESS", startedAt: "2024-01-01T00:02:00Z" },
+  ]);
+  assertEquals(failingCheckNames(rollup), [], "no superseded CANCELLED may count as a failing check");
+});
+
+test("a genuine failure on the newest run still counts (no false-negative)", () => {
+  const rollup = [
+    { name: "engine-core", conclusion: "SUCCESS", startedAt: "2024-01-01T00:00:00Z" },
+    // Newest run genuinely failed — this must still be reported.
+    { name: "engine-core", conclusion: "FAILURE", startedAt: "2024-01-01T00:02:00Z" },
+  ];
+  assertEquals(failingCheckNames(rollup), ["engine-core"], "a real failure on the newest run must count");
+});
+
+test("a lone CANCELLED with no superseding run still counts (nothing green replaced it)", () => {
+  const rollup = [{ name: "engine-core", conclusion: "CANCELLED", startedAt: "2024-01-01T00:00:00Z" }];
+  assertEquals(failingCheckNames(rollup), ["engine-core"], "an unsuperseded CANCELLED remains a failing gate");
+});
+
+test("ties (missing timestamps) prefer the non-CANCELLED run so the real result wins", () => {
+  // GitHub sometimes omits run times; a superseded CANCELLED alongside a completed run must not
+  // shadow the real conclusion even when neither carries a timestamp.
+  const cancelledFirst = [
+    { name: "server", conclusion: "CANCELLED" },
+    { name: "server", conclusion: "SUCCESS" },
+  ];
+  const successFirst = [
+    { name: "server", conclusion: "SUCCESS" },
+    { name: "server", conclusion: "CANCELLED" },
+  ];
+  assertEquals(failingCheckNames(cancelledFirst), [], "CANCELLED-first tie resolves to the real (green) result");
+  assertEquals(failingCheckNames(successFirst), [], "success-first tie keeps the real (green) result");
+});
+
+test("latestRunPerCheck keeps exactly one run per check name (newest)", () => {
+  const rollup = [
+    { name: "a", conclusion: "CANCELLED", startedAt: "2024-01-01T00:00:00Z" },
+    { name: "a", conclusion: "SUCCESS", startedAt: "2024-01-01T00:02:00Z" },
+    { name: "b", conclusion: "FAILURE", startedAt: "2024-01-01T00:00:00Z" },
+  ];
+  const latest = latestRunPerCheck(rollup);
+  assertEquals(latest.length, 2, "one run per distinct check name");
+  const a = latest.find((c) => c.name === "a");
+  assert(a && a.conclusion === "SUCCESS", "check `a` resolves to its newest (green) run");
+});
+
+test("allCheckNames dedupes superseded reruns to a single name", () => {
+  const rollup = [
+    { name: "engine-core", conclusion: "CANCELLED", startedAt: "2024-01-01T00:00:00Z" },
+    { name: "engine-core", conclusion: "SUCCESS", startedAt: "2024-01-01T00:02:00Z" },
+  ];
+  assertEquals(allCheckNames(rollup), ["engine-core"], "a superseded rerun must not double-list the check name");
+});
+
+test("legacy StatusContext (state + context) supersession is handled by createdAt", () => {
+  const rollup = [
+    { context: "ci/legacy", state: "ERROR", createdAt: "2024-01-01T00:00:00Z" },
+    { context: "ci/legacy", state: "SUCCESS", createdAt: "2024-01-01T00:02:00Z" },
+  ];
+  assertEquals(failingCheckNames(rollup), [], "a superseded legacy status context is not a failing gate");
+});

package/app/github.ts

@@ -521,17 +521,78 @@ interface RollupEntry {
   name?: string;
   context?: string;
   workflowName?: string;
+  /** CheckRun timestamps (GraphQL `statusCheckRollup`). A superseded run and the newer run that
+   * replaced it carry the same check name but different times, so they order the runs of one check.
+   * StatusContext carries `createdAt` instead. All are ISO-8601 or absent. */
+  startedAt?: string;
+  completedAt?: string;
+  createdAt?: string;
 }
+
+/** The canonical identity of a check across its reruns: its name (CheckRun) or context
+ * (StatusContext), falling back to its `workflowName` and finally the sentinel `"check"` when
+ * neither is present. GitHub CI concurrency can leave several runs of the SAME check on one head
+ * commit — a superseded run plus the newer run that replaced it — so this is what we group by. */
+function checkKey(c: RollupEntry): string {
+  return c.name || c.context || c.workflowName || "check";
+}
+
+/** A run's ordering timestamp (newest wins): its completion, else its start, else its creation.
+ * `0` when none is present (the shape carries no time) so a timed run always outranks an untimed
+ * one. */
+function runOrder(c: RollupEntry): number {
+  const t = c.completedAt || c.startedAt || c.createdAt;
+  if (!t) return 0;
+  const ms = Date.parse(t);
+  return Number.isNaN(ms) ? 0 : ms;
+}
+
+/** True when a run's conclusion is `CANCELLED` — the state GitHub CI concurrency stamps on a run it
+ * supersedes with a newer run on the identical head SHA (a stale/transient cancellation, not a code
+ * defect). */
+function isCancelled(c: RollupEntry): boolean {
+  return (c.conclusion || c.state || "").toUpperCase() === "CANCELLED";
+}
+
+/** Collapse a head's rollup to the **newest run per check**. GitHub's CI-concurrency cancellation
+ * (issue #348) leaves BOTH a superseded run (stamped `CANCELLED`) and the newer run that replaced
+ * it on the *same head SHA*, under the same check name. Counting the stale `CANCELLED` as a failure
+ * escalates a self-healing PR whose head is actually green. The rollup is already scoped to the head
+ * commit, so grouping by check name and keeping the newest run per name yields one ground-truth
+ * conclusion per `(headSha, checkName)`. Ties (equal/absent timestamps) prefer a non-`CANCELLED`
+ * run, so a superseded cancellation never shadows the real result even when GitHub omits times. */
+export function latestRunPerCheck(rollup: RollupEntry[]): RollupEntry[] {
+  const newest = new Map<string, RollupEntry>();
+  for (const c of rollup) {
+    const key = checkKey(c);
+    const prev = newest.get(key);
+    if (prev === undefined) {
+      newest.set(key, c);
+      continue;
+    }
+    const dt = runOrder(c) - runOrder(prev);
+    if (dt > 0) {
+      newest.set(key, c);
+    } else if (dt === 0 && isCancelled(prev) && !isCancelled(c)) {
+      // Same/unknown time: a CANCELLED run is the superseded one — the real result wins.
+      newest.set(key, c);
+    }
+  }
+  return [...newest.values()];
+}
+
 /** Names of the checks whose result is a hard failure (as opposed to pending/success). Covers
  * both the CheckRun shape (`conclusion` + `name`/`workflowName`) and the legacy StatusContext
  * shape (`state` + `context`). The names are what the CI-fix agent is handed so it knows which
- * gates to make green; `failingChecks` (the count) is derived from this list. */
-function failingCheckNames(rollup: RollupEntry[]): string[] {
+ * gates to make green; `failingChecks` (the count) is derived from this list. Derivation is over the
+ * **newest run per check** (`latestRunPerCheck`) so a `CANCELLED` run superseded by a newer green
+ * run on the identical head SHA is not counted as a failing gate (issue #348). */
+export function failingCheckNames(rollup: RollupEntry[]): string[] {
   const bad = new Set(["FAILURE", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "STARTUP_FAILURE", "ERROR"]);
   const names: string[] = [];
-  for (const c of rollup) {
+  for (const c of latestRunPerCheck(rollup)) {
     const v = (c.conclusion || c.state || "").toUpperCase();
-    if (bad.has(v)) names.push(c.name || c.context || c.workflowName || "check");
+    if (bad.has(v)) names.push(checkKey(c));
   }
   return names;
 }
@@ -539,10 +600,11 @@ function failingCheckNames(rollup: RollupEntry[]): string[] {
 /** Names of every head check present, regardless of state. Covers both the CheckRun shape
  * (`name`/`workflowName`) and the legacy StatusContext shape (`context`). Used to test whether a
  * repo's *required* checks are present on the head — so an unrelated always-on check (e.g.
- * Mergify's "Merge Queue") doesn't masquerade as the required CI run having already happened. */
-function allCheckNames(rollup: RollupEntry[]): string[] {
+ * Mergify's "Merge Queue") doesn't masquerade as the required CI run having already happened.
+ * Deduped to the newest run per check so a superseded rerun doesn't list a check name twice. */
+export function allCheckNames(rollup: RollupEntry[]): string[] {
   const names: string[] = [];
-  for (const c of rollup) {
+  for (const c of latestRunPerCheck(rollup)) {
     const name = c.name || c.context || c.workflowName;
     if (name) names.push(name);
   }

package/app/mergeCiReattempt.test.ts

@@ -0,0 +1,138 @@
+// Structural regression guard for the CI-concurrency-cancellation drift class (issue #348).
+//
+// The merge loop escalated a human whenever `senior:fix-ci` returned `blocked` — even when the
+// failing required checks were STALE/TRANSIENT (CANCELLED runs superseded by a newer green run on
+// the identical head SHA) and the agent honestly pushed nothing. The `fix-ci` prompt actively
+// funnelled that self-healing case into `blocked`, and `blocked` routed straight to the merge
+// escalation user task. A phantom-blocked, self-healing merge paged a human.
+//
+// The fix adds a first-class re-attempt path and a reconcile-before-escalate guard:
+//
+//   1. `status = "reattempt"` (a first-class fix-ci verdict for stale/transient checks) routes to
+//      `arm-merge`, re-queuing the merge from ground truth — no human, and declared explicitly
+//      beside the `f_ci_reconcile` empty-status default rather than relying on the fall-through.
+//   2. A `blocked` verdict with no push (`pushed != true`) reconciles ONCE via ground truth
+//      (`gw-ci-blocked` → `ci-reconcile` → re-arm the poller) and escalates only if it is STILL
+//      blocked — so even a mislabelled `blocked` self-heals.
+//
+// Pure text assertions over the committed BPMN (no engine), matching the repo's lightweight
+// model-guard style (see mergeEscalationQuestion.test.ts, mergeRebaseArm.test.ts).
+
+import { test } from "node:test";
+import { assert, assertStringIncludes } from "#test-assert";
+import { readFileSync } from "node:fs";
+
+const bpmn = readFileSync("resources/processes/merge-loop.bpmn", "utf8");
+// Collapse whitespace so attribute-order / line-wrapping churn doesn't make the assertions brittle.
+const flat = bpmn.replace(/\s+/g, " ");
+
+function flowElement(id: string): string | null {
+  const re = new RegExp(
+    `<bpmn:sequenceFlow\\b[^>]*?\\bid="${id}"[^>]*?(?:/>|>(?:(?!<bpmn:sequenceFlow\\b).)*?</bpmn:sequenceFlow>)`,
+  );
+  const m = flat.match(re);
+  return m ? m[0] : null;
+}
+
+function flowHasId(id: string, source: string, target: string): boolean {
+  const el = flowElement(id);
+  if (!el) return false;
+  return el.includes(`sourceRef="${source}"`) && el.includes(`targetRef="${target}"`);
+}
+
+function serviceTask(id: string): string | null {
+  const m = flat.match(new RegExp(`<bpmn:serviceTask\\b[^>]*\\bid="${id}"[\\s\\S]*?</bpmn:serviceTask>`));
+  return m ? m[0].replace(/&#34;/g, '"').replace(/&amp;/g, "&").replace(/&#10;/g, "\n") : null;
+}
+
+test("a first-class `reattempt` verdict re-attempts the merge (arm-merge), not escalation", () => {
+  // gw-ci-result must carry an explicit `status = "reattempt"` arm to arm-merge, declared beside
+  // (not folded into) the empty-status `f_ci_reconcile` default.
+  const gw = flat.match(/<bpmn:exclusiveGateway\b[^>]*\bid="gw-ci-result"[\s\S]*?<\/bpmn:exclusiveGateway>/);
+  assert(gw, "gw-ci-result gateway must exist");
+  assertStringIncludes(gw![0], "f_ci_reattempt", "gw-ci-result must declare the reattempt outgoing arm");
+
+  const reattempt = flowElement("f_ci_reattempt");
+  assert(reattempt, "f_ci_reattempt flow missing");
+  assert(
+    flowHasId("f_ci_reattempt", "gw-ci-result", "arm-merge"),
+    "a reattempt verdict must re-arm the merge poller (arm-merge), never escalate",
+  );
+  assertStringIncludes(reattempt!, 'status = "reattempt"', "the reattempt arm must be gated on status = reattempt");
+  // It must be an EXPLICIT labelled flow, not the empty-status default.
+  assert(!/default="f_ci_reattempt"/.test(flat), "reattempt must be an explicit arm, not the gateway default");
+});
+
+test("a fix-ci `reattempt` result does NOT create a merge escalation", () => {
+  // No flow originating from the reattempt classification may reach the merge-escalation task.
+  assert(
+    !flowHasId("f_ci_reattempt", "gw-ci-result", "merge-esc-attempt"),
+    "reattempt must never route to merge-esc-attempt",
+  );
+});
+
+test("a blocked-with-no-push verdict reconciles once from ground truth before escalating", () => {
+  // The `blocked` arm no longer flows straight into the escalation: it passes through gw-ci-blocked.
+  assert(
+    flowHasId("f_ci_blocked", "gw-ci-result", "gw-ci-blocked"),
+    "a blocked verdict must route through gw-ci-blocked, not straight to merge-esc-attempt",
+  );
+
+  const gw = flat.match(/<bpmn:exclusiveGateway\b[^>]*\bid="gw-ci-blocked"[^>]*>/);
+  assert(gw, "gw-ci-blocked gateway must exist");
+  // Default is escalate (still blocked), so a missing/true reconcile flag never wedges.
+  assertStringIncludes(gw![0], 'default="f_cib_esc"', "gw-ci-blocked must default to escalation");
+
+  // The reconcile-once arm: pushed nothing AND not yet reconciled → re-derive via ci-reconcile.
+  const recon = flowElement("f_cib_recon");
+  assert(recon, "f_cib_recon flow missing");
+  assert(flowHasId("f_cib_recon", "gw-ci-blocked", "ci-reconcile"), "reconcile arm must target ci-reconcile");
+  assertStringIncludes(recon!, "pushed != true", "reconcile only when the agent pushed nothing");
+  assertStringIncludes(recon!, "ciBlockedReconciled != true", "reconcile at most once");
+
+  // The escalate arm (default): still blocked → the human merge escalation.
+  assert(flowHasId("f_cib_esc", "gw-ci-blocked", "merge-esc-attempt"), "the still-blocked arm must escalate");
+  assert(
+    !/conditionExpression/.test(flowElement("f_cib_esc") ?? ""),
+    "f_cib_esc is the default arm and must not carry a conditionExpression",
+  );
+});
+
+test("ci-reconcile re-arms the canonical merge poller and marks the reconcile as spent", () => {
+  const el = serviceTask("ci-reconcile");
+  assert(el, "ci-reconcile service task must exist");
+  // Reuses the canonical arm-merge worker — one poller implementation, no second poller pass.
+  assertStringIncludes(el!, 'type="pr.arm-merge"', "ci-reconcile must reuse the canonical pr.arm-merge worker");
+  // Marks the reconcile spent so the SECOND blocked (still blocked after re-derivation) escalates.
+  const outs = el!.match(/<zeebe:output\b[^>]*\/>/g) ?? [];
+  assert(
+    outs.some((t) => t.includes('target="ciBlockedReconciled"') && t.includes('source="=true"')),
+    "ci-reconcile must set ciBlockedReconciled = true so a still-blocked PR escalates on the next pass",
+  );
+  // Re-derivation flows back through the mergeable wait (re-runs the ground-truth mergeable gate).
+  assert(flowHasId("f_cib_armed", "ci-reconcile", "wait-mergeable"), "ci-reconcile must re-enter wait-mergeable");
+});
+
+test("arm-merge clears the reconcile flag each loop so a fresh block episode gets its own reconcile", () => {
+  const el = serviceTask("arm-merge");
+  assert(el, "arm-merge service task must exist");
+  const outs = el!.match(/<zeebe:output\b[^>]*\/>/g) ?? [];
+  assert(
+    outs.some((t) => t.includes('target="ciBlockedReconciled"') && t.includes('source="=null"')),
+    "arm-merge must reset ciBlockedReconciled each loop so a later, unrelated block still reconciles once",
+  );
+});
+
+test("regression: a stale/transient fix-ci result can no longer page a human", () => {
+  // The old wedge: `status = "blocked"` flowing directly into merge-esc-attempt. The blocked
+  // verdict now routes through gw-ci-blocked (reconcile-before-escalate), never straight to the
+  // escalation.
+  assert(
+    !flowHasId("f_ci_blocked", "gw-ci-result", "merge-esc-attempt"),
+    "the blocked verdict must not route directly into merge-esc-attempt (the #348 phantom escalation)",
+  );
+  // The blocked arm targets the reconcile gateway; the reattempt arm re-arms the poller. Neither
+  // gw-ci-result arm may target the escalation directly.
+  assertStringIncludes(flowElement("f_ci_blocked") ?? "", 'targetRef="gw-ci-blocked"');
+  assertStringIncludes(flowElement("f_ci_reattempt") ?? "", 'targetRef="arm-merge"');
+});

package/app/mergeRebaseArm.test.ts

@@ -118,11 +118,14 @@ test("ci-fix result: a missing/ambiguous status reconciles from ground truth, no
     flowHasId("f_ci_reconcile", "gw-ci-result", "arm-merge"),
     "f_ci_reconcile must default gw-ci-result → arm-merge (reconcile)",
   );
-  // Escalation reserved for the agent's explicit `blocked` verdict.
+  // Escalation reserved for the agent's explicit `blocked` verdict — but now via a
+  // reconcile-before-escalate guard (issue #348): a `blocked` with no push reconciles once from
+  // ground truth, and only a still-blocked PR reaches the human escalation.
   const ciBlocked = flat.match(/<bpmn:sequenceFlow[^>]*id="f_ci_blocked"[\s\S]*?<\/bpmn:sequenceFlow>/);
   assert(ciBlocked, "f_ci_blocked flow missing");
   assertStringIncludes(ciBlocked![0], 'status = "blocked"');
-  assert(hasFlow("gw-ci-result", "merge-esc-attempt"), "gw-ci-result → merge-esc-attempt (blocked) missing");
+  assert(hasFlow("gw-ci-result", "gw-ci-blocked"), "blocked verdict must pass through gw-ci-blocked (reconcile-before-escalate)");
+  assert(hasFlow("gw-ci-blocked", "merge-esc-attempt"), "gw-ci-blocked → merge-esc-attempt (still blocked) missing");
 });
 
 test("regression: the conflict verdict passes through the rebase actor, not straight to escalation", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.102.0",
+  "version": "0.102.1",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",

package/resources/processes/merge-loop.bpmn

@@ -61,6 +61,7 @@
           <nano:extend name="summary" type="string" optional="true" />
           <nano:extend name="question" type="string" optional="true" />
           <nano:extend name="dependsOn" type="string" optional="true" />
+          <nano:extend name="pushed" type="boolean" optional="true" />
         </nano:shape>
         <nano:shape id="RebaseIn" name="Rebase — input">
           <nano:extend name="prKey" type="string" />
@@ -98,11 +99,13 @@
         </zeebe:properties>
         <zeebe:ioMapping>
           <zeebe:output source="=null" target="status" />
+          <zeebe:output source="=null" target="ciBlockedReconciled" />
         </zeebe:ioMapping>
       </bpmn:extensionElements>
       <bpmn:incoming>f_m_deps</bpmn:incoming>
       <bpmn:incoming>f_m_answer</bpmn:incoming>
       <bpmn:incoming>f_ci_fixed</bpmn:incoming>
+      <bpmn:incoming>f_ci_reattempt</bpmn:incoming>
       <bpmn:incoming>f_reb_rebased</bpmn:incoming>
       <bpmn:incoming>f_m_evicted</bpmn:incoming>
       <bpmn:incoming>f_m_escReenter</bpmn:incoming>
@@ -111,6 +114,7 @@
     </bpmn:serviceTask>
     <bpmn:intermediateCatchEvent id="wait-mergeable" name="Wait: mergeable">
       <bpmn:incoming>f_m_arm</bpmn:incoming>
+      <bpmn:incoming>f_cib_armed</bpmn:incoming>
       <bpmn:outgoing>f_m_ready</bpmn:outgoing>
       <bpmn:messageEventDefinition id="med_mergeReady" messageRef="Message_mergeReady" />
     </bpmn:intermediateCatchEvent>
@@ -213,7 +217,7 @@
         </zeebe:ioMapping>
       </bpmn:extensionElements>
       <bpmn:incoming>f_m_gBlocked</bpmn:incoming>
-      <bpmn:incoming>f_ci_blocked</bpmn:incoming>
+      <bpmn:incoming>f_cib_esc</bpmn:incoming>
       <bpmn:incoming>f_reb_blocked</bpmn:incoming>
       <bpmn:incoming>f_ci_sla</bpmn:incoming>
       <bpmn:incoming>f_mr_giveup</bpmn:incoming>
@@ -284,9 +288,29 @@
       <bpmn:incoming>f_ci_done</bpmn:incoming>
       <bpmn:outgoing>f_ci_fixed</bpmn:outgoing>
       <bpmn:outgoing>f_ci_wait</bpmn:outgoing>
+      <bpmn:outgoing>f_ci_reattempt</bpmn:outgoing>
       <bpmn:outgoing>f_ci_blocked</bpmn:outgoing>
       <bpmn:outgoing>f_ci_reconcile</bpmn:outgoing>
     </bpmn:exclusiveGateway>
+    <bpmn:exclusiveGateway id="gw-ci-blocked" name="reconcile then escalate?" default="f_cib_esc">
+      <bpmn:incoming>f_ci_blocked</bpmn:incoming>
+      <bpmn:outgoing>f_cib_recon</bpmn:outgoing>
+      <bpmn:outgoing>f_cib_esc</bpmn:outgoing>
+    </bpmn:exclusiveGateway>
+    <bpmn:serviceTask id="ci-reconcile" name="Reconcile blocked from ground truth">
+      <bpmn:extensionElements>
+        <zeebe:taskDefinition type="pr.arm-merge" />
+        <zeebe:properties>
+          <zeebe:property name="io.nanobpm.dataEnvelope.in" value="MergeArmIn" />
+        </zeebe:properties>
+        <zeebe:ioMapping>
+          <zeebe:output source="=null" target="status" />
+          <zeebe:output source="=true" target="ciBlockedReconciled" />
+        </zeebe:ioMapping>
+      </bpmn:extensionElements>
+      <bpmn:incoming>f_cib_recon</bpmn:incoming>
+      <bpmn:outgoing>f_cib_armed</bpmn:outgoing>
+    </bpmn:serviceTask>
     <bpmn:exclusiveGateway id="gw-rebase" name="auto-rebase?" default="f_reb_giveup">
       <bpmn:incoming>f_m_mRebase</bpmn:incoming>
       <bpmn:outgoing>f_reb_go</bpmn:outgoing>
@@ -356,9 +380,17 @@
     <bpmn:sequenceFlow id="f_ci_fixed" name="fixed" sourceRef="gw-ci-result" targetRef="arm-merge">
       <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=status = "fixed"</bpmn:conditionExpression>
     </bpmn:sequenceFlow>
-    <bpmn:sequenceFlow id="f_ci_blocked" name="could not fix" sourceRef="gw-ci-result" targetRef="merge-esc-attempt">
+    <bpmn:sequenceFlow id="f_ci_blocked" name="could not fix" sourceRef="gw-ci-result" targetRef="gw-ci-blocked">
       <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=status = "blocked"</bpmn:conditionExpression>
     </bpmn:sequenceFlow>
+    <bpmn:sequenceFlow id="f_ci_reattempt" name="stale/transient checks — re-attempt" sourceRef="gw-ci-result" targetRef="arm-merge">
+      <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=status = "reattempt"</bpmn:conditionExpression>
+    </bpmn:sequenceFlow>
+    <bpmn:sequenceFlow id="f_cib_recon" name="pushed nothing — reconcile once" sourceRef="gw-ci-blocked" targetRef="ci-reconcile">
+      <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=pushed != true and ciBlockedReconciled != true</bpmn:conditionExpression>
+    </bpmn:sequenceFlow>
+    <bpmn:sequenceFlow id="f_cib_esc" name="still blocked — escalate" sourceRef="gw-ci-blocked" targetRef="merge-esc-attempt" />
+    <bpmn:sequenceFlow id="f_cib_armed" sourceRef="ci-reconcile" targetRef="wait-mergeable" />
     <bpmn:sequenceFlow id="f_ci_reconcile" name="no verdict — reconcile from ground truth" sourceRef="gw-ci-result" targetRef="arm-merge" />
     <bpmn:sequenceFlow id="f_ci_wait" name="waits on another PR" sourceRef="gw-ci-result" targetRef="record-merge-dep">
       <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=status = "waiting-on-pr"</bpmn:conditionExpression>
@@ -433,7 +465,7 @@
       <bpmndi:BPMNShape id="BPMNShape_wait-mergeable" bpmnElement="wait-mergeable">
         <dc:Bounds x="552" y="102" width="36" height="36" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="535" y="143" width="70" height="28" />
+          <dc:Bounds x="535" y="69" width="70" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_gw-mergeable" bpmnElement="gw-mergeable" isMarkerVisible="true">
@@ -454,7 +486,7 @@
       <bpmndi:BPMNShape id="BPMNShape_gw-merge-retry" bpmnElement="gw-merge-retry" isMarkerVisible="true">
         <dc:Bounds x="1263" y="1375" width="50" height="50" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1344" y="1410" width="88" height="28" />
+          <dc:Bounds x="1224" y="1470" width="88" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_eg-landed" bpmnElement="eg-landed" isMarkerVisible="true">
@@ -472,16 +504,16 @@
       <bpmndi:BPMNShape id="BPMNShape_wait-evicted" bpmnElement="wait-evicted">
         <dc:Bounds x="1470" y="422" width="36" height="36" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1444" y="375" width="88" height="42" />
+          <dc:Bounds x="1344" y="483" width="88" height="42" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_mark-merged" bpmnElement="mark-merged">
         <dc:Bounds x="1638" y="80" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_MergeEnd" bpmnElement="MergeEnd">
-        <dc:Bounds x="1870" y="102" width="36" height="36" />
+        <dc:Bounds x="1845" y="102" width="36" height="36" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1863" y="143" width="50" height="14" />
+          <dc:Bounds x="1838" y="83" width="50" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_MergeAbandoned" bpmnElement="MergeAbandoned">
@@ -491,27 +523,27 @@
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_merge-esc-conflict" bpmnElement="merge-esc-conflict">
-        <dc:Bounds x="1238" y="1840" width="100" height="80" />
+        <dc:Bounds x="1238" y="2000" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_merge-esc-attempt" bpmnElement="merge-esc-attempt">
-        <dc:Bounds x="1438" y="1360" width="100" height="80" />
+        <dc:Bounds x="1638" y="1360" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_gw-merge-escalated" bpmnElement="gw-merge-escalated" isMarkerVisible="true">
-        <dc:Bounds x="1663" y="1375" width="50" height="50" />
+        <dc:Bounds x="1838" y="1375" width="50" height="50" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1651" y="1342" width="74" height="28" />
+          <dc:Bounds x="1826" y="1470" width="74" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_wait-merge-answer" bpmnElement="wait-merge-answer">
-        <dc:Bounds x="1838" y="1360" width="100" height="80" />
+        <dc:Bounds x="1988" y="1360" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_record-merge-answer" bpmnElement="record-merge-answer">
-        <dc:Bounds x="2038" y="1360" width="100" height="80" />
+        <dc:Bounds x="2188" y="1360" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_gw-ci-fix" bpmnElement="gw-ci-fix" isMarkerVisible="true">
-        <dc:Bounds x="863" y="1855" width="50" height="50" />
+        <dc:Bounds x="863" y="2015" width="50" height="50" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="769" y="1873" width="89" height="14" />
+          <dc:Bounds x="769" y="2033" width="89" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_fix-ci" bpmnElement="fix-ci">
@@ -523,6 +555,15 @@
           <dc:Bounds x="1225" y="790" width="46" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="BPMNShape_gw-ci-blocked" bpmnElement="gw-ci-blocked" isMarkerVisible="true">
+        <dc:Bounds x="1463" y="735" width="50" height="50" />
+        <bpmndi:BPMNLabel>
+          <dc:Bounds x="1455" y="810" width="67" height="42" />
+        </bpmndi:BPMNLabel>
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="BPMNShape_ci-reconcile" bpmnElement="ci-reconcile">
+        <dc:Bounds x="1638" y="560" width="100" height="80" />
+      </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_gw-rebase" bpmnElement="gw-rebase" isMarkerVisible="true">
         <dc:Bounds x="863" y="255" width="50" height="50" />
         <bpmndi:BPMNLabel>
@@ -589,13 +630,21 @@
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_done" bpmnElement="f_m_done">
         <di:waypoint x="1738" y="120" />
-        <di:waypoint x="1870" y="120" />
+        <di:waypoint x="1845" y="120" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_ci_giveup" bpmnElement="f_ci_giveup">
-        <di:waypoint x="913" y="1880" />
-        <di:waypoint x="1238" y="1880" />
+        <di:waypoint x="913" y="2040" />
+        <di:waypoint x="1238" y="2040" />
+        <bpmndi:BPMNLabel>
+          <dc:Bounds x="1032" y="2007" width="67" height="28" />
+        </bpmndi:BPMNLabel>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_f_cib_esc" bpmnElement="f_cib_esc">
+        <di:waypoint x="1513" y="760" />
+        <di:waypoint x="1688" y="760" />
+        <di:waypoint x="1688" y="1360" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1032" y="1847" width="67" height="28" />
+          <dc:Bounds x="1569" y="765" width="64" height="42" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_ci_reconcile" bpmnElement="f_ci_reconcile">
@@ -612,11 +661,11 @@
         <di:waypoint x="933" y="280" />
         <di:waypoint x="933" y="305" />
         <di:waypoint x="1326" y="305" />
-        <di:waypoint x="1326" y="1820" />
-        <di:waypoint x="1288" y="1820" />
-        <di:waypoint x="1288" y="1840" />
+        <di:waypoint x="1326" y="1980" />
+        <di:waypoint x="1288" y="1980" />
+        <di:waypoint x="1288" y="2000" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1331" y="1566" width="67" height="28" />
+          <dc:Bounds x="1331" y="1646" width="67" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_reb_reconcile" bpmnElement="f_reb_reconcile">
@@ -630,9 +679,9 @@
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_mr_giveup" bpmnElement="f_mr_giveup">
         <di:waypoint x="1313" y="1400" />
-        <di:waypoint x="1438" y="1400" />
+        <di:waypoint x="1638" y="1400" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1332" y="1367" width="67" height="28" />
+          <dc:Bounds x="1432" y="1367" width="67" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_eg_landed" bpmnElement="f_eg_landed">
@@ -645,30 +694,30 @@
         <di:waypoint x="1688" y="160" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_escC" bpmnElement="f_m_escC">
-        <di:waypoint x="1338" y="1880" />
-        <di:waypoint x="1888" y="1880" />
-        <di:waypoint x="1888" y="1440" />
+        <di:waypoint x="1338" y="2040" />
+        <di:waypoint x="2038" y="2040" />
+        <di:waypoint x="2038" y="1440" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_escA" bpmnElement="f_m_escA">
-        <di:waypoint x="1538" y="1400" />
-        <di:waypoint x="1663" y="1400" />
+        <di:waypoint x="1738" y="1400" />
+        <di:waypoint x="1838" y="1400" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_escReenter" bpmnElement="f_m_escReenter">
-        <di:waypoint x="1688" y="1425" />
-        <di:waypoint x="1688" y="1460" />
+        <di:waypoint x="1863" y="1425" />
+        <di:waypoint x="1863" y="1460" />
         <di:waypoint x="402" y="1460" />
         <di:waypoint x="402" y="160" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1008" y="1465" width="74" height="42" />
+          <dc:Bounds x="1096" y="1465" width="74" height="42" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_answerRecord" bpmnElement="f_m_answerRecord">
-        <di:waypoint x="1938" y="1400" />
-        <di:waypoint x="2038" y="1400" />
+        <di:waypoint x="2088" y="1400" />
+        <di:waypoint x="2188" y="1400" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_answer" bpmnElement="f_m_answer">
-        <di:waypoint x="2088" y="1440" />
-        <di:waypoint x="2088" y="1460" />
+        <di:waypoint x="2238" y="1440" />
+        <di:waypoint x="2238" y="1460" />
         <di:waypoint x="402" y="1460" />
         <di:waypoint x="402" y="160" />
       </bpmndi:BPMNEdge>
@@ -678,9 +727,9 @@
         <di:waypoint x="1333" y="318" />
         <di:waypoint x="1333" y="1340" />
         <di:waypoint x="863" y="1340" />
-        <di:waypoint x="863" y="1835" />
-        <di:waypoint x="888" y="1835" />
-        <di:waypoint x="888" y="1855" />
+        <di:waypoint x="863" y="1995" />
+        <di:waypoint x="888" y="1995" />
+        <di:waypoint x="888" y="2015" />
         <bpmndi:BPMNLabel>
           <dc:Bounds x="1011" y="1293" width="60" height="42" />
         </bpmndi:BPMNLabel>
@@ -699,64 +748,62 @@
         <di:waypoint x="1326" y="318" />
         <di:waypoint x="1326" y="1340" />
         <di:waypoint x="1218" y="1340" />
-        <di:waypoint x="1218" y="1860" />
-        <di:waypoint x="1238" y="1860" />
+        <di:waypoint x="1218" y="2020" />
+        <di:waypoint x="1238" y="2020" />
         <bpmndi:BPMNLabel>
           <dc:Bounds x="1236" y="862" width="85" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_ci_go" bpmnElement="f_ci_go">
-        <di:waypoint x="888" y="1905" />
-        <di:waypoint x="888" y="1925" />
-        <di:waypoint x="2158" y="1925" />
-        <di:waypoint x="2158" y="715" />
+        <di:waypoint x="888" y="2065" />
+        <di:waypoint x="888" y="2085" />
+        <di:waypoint x="2308" y="2085" />
+        <di:waypoint x="2308" y="715" />
         <di:waypoint x="1018" y="715" />
         <di:waypoint x="1018" y="740" />
         <di:waypoint x="1038" y="740" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="2163" y="1306" width="49" height="28" />
+          <dc:Bounds x="2313" y="1386" width="49" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
-      <bpmndi:BPMNEdge id="BPMNEdge_f_ci_blocked" bpmnElement="f_ci_blocked">
-        <di:waypoint x="1313" y="760" />
-        <di:waypoint x="1418" y="760" />
-        <di:waypoint x="1418" y="1400" />
-        <di:waypoint x="1438" y="1400" />
+      <bpmndi:BPMNEdge id="BPMNEdge_f_cib_recon" bpmnElement="f_cib_recon">
+        <di:waypoint x="1488" y="735" />
+        <di:waypoint x="1488" y="600" />
+        <di:waypoint x="1638" y="600" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1423" y="1013" width="89" height="14" />
+          <dc:Bounds x="1513" y="460" width="67" height="56" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_ci_wait" bpmnElement="f_ci_wait">
         <di:waypoint x="1313" y="760" />
-        <di:waypoint x="1488" y="760" />
-        <di:waypoint x="1488" y="880" />
+        <di:waypoint x="1418" y="760" />
+        <di:waypoint x="1418" y="920" />
+        <di:waypoint x="1438" y="920" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1416" y="727" width="75" height="28" />
+          <dc:Bounds x="1338" y="826" width="75" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_reb_go" bpmnElement="f_reb_go">
         <di:waypoint x="913" y="280" />
         <di:waypoint x="933" y="280" />
         <di:waypoint x="933" y="305" />
-        <di:waypoint x="1733" y="305" />
-        <di:waypoint x="1733" y="1820" />
-        <di:waypoint x="1250" y="1820" />
-        <di:waypoint x="1250" y="1355" />
-        <di:waypoint x="1358" y="1355" />
-        <di:waypoint x="1358" y="1035" />
-        <di:waypoint x="1018" y="1035" />
+        <di:waypoint x="1443" y="305" />
+        <di:waypoint x="1443" y="805" />
+        <di:waypoint x="1558" y="805" />
+        <di:waypoint x="1558" y="980" />
+        <di:waypoint x="1018" y="980" />
         <di:waypoint x="1018" y="1060" />
         <di:waypoint x="1038" y="1060" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1255" y="1574" width="49" height="28" />
+          <dc:Bounds x="1448" y="561" width="49" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_reb_blocked" bpmnElement="f_reb_blocked">
         <di:waypoint x="1313" y="1080" />
-        <di:waypoint x="1488" y="1080" />
-        <di:waypoint x="1488" y="1360" />
+        <di:waypoint x="1688" y="1080" />
+        <di:waypoint x="1688" y="1360" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1429" y="1047" width="64" height="28" />
+          <dc:Bounds x="1469" y="1047" width="64" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_reb_wait" bpmnElement="f_reb_wait">
@@ -778,15 +825,15 @@
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_gRetry" bpmnElement="f_m_gRetry">
         <di:waypoint x="1088" y="95" />
         <di:waypoint x="1088" y="75" />
-        <di:waypoint x="1926" y="75" />
-        <di:waypoint x="1926" y="318" />
-        <di:waypoint x="1643" y="318" />
-        <di:waypoint x="1643" y="1445" />
+        <di:waypoint x="1901" y="75" />
+        <di:waypoint x="1901" y="145" />
+        <di:waypoint x="1825" y="145" />
+        <di:waypoint x="1825" y="1445" />
         <di:waypoint x="1263" y="1445" />
         <di:waypoint x="1288" y="1445" />
         <di:waypoint x="1288" y="1425" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1746" y="285" width="78" height="28" />
+          <dc:Bounds x="1414" y="1412" width="78" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_eg_evicted" bpmnElement="f_eg_evicted">
@@ -797,13 +844,15 @@
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_gBlocked" bpmnElement="f_m_gBlocked">
         <di:waypoint x="1088" y="95" />
         <di:waypoint x="1088" y="75" />
-        <di:waypoint x="1926" y="75" />
-        <di:waypoint x="1926" y="980" />
-        <di:waypoint x="1418" y="980" />
-        <di:waypoint x="1418" y="1380" />
-        <di:waypoint x="1438" y="1380" />
+        <di:waypoint x="1901" y="75" />
+        <di:waypoint x="1901" y="145" />
+        <di:waypoint x="1825" y="145" />
+        <di:waypoint x="1825" y="1445" />
+        <di:waypoint x="1618" y="1445" />
+        <di:waypoint x="1618" y="1420" />
+        <di:waypoint x="1638" y="1420" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1931" y="642" width="53" height="14" />
+          <dc:Bounds x="1837" y="153" width="53" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_gAbandoned" bpmnElement="f_m_gAbandoned">
@@ -822,20 +871,27 @@
         <di:waypoint x="1138" y="760" />
         <di:waypoint x="1263" y="760" />
       </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_f_ci_blocked" bpmnElement="f_ci_blocked">
+        <di:waypoint x="1313" y="760" />
+        <di:waypoint x="1463" y="760" />
+        <bpmndi:BPMNLabel>
+          <dc:Bounds x="1341" y="738" width="89" height="14" />
+        </bpmndi:BPMNLabel>
+      </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_reb_done" bpmnElement="f_reb_done">
         <di:waypoint x="1138" y="1080" />
         <di:waypoint x="1263" y="1080" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_m_escWait" bpmnElement="f_m_escWait">
-        <di:waypoint x="1713" y="1400" />
-        <di:waypoint x="1838" y="1400" />
+        <di:waypoint x="1888" y="1400" />
+        <di:waypoint x="1988" y="1400" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_reb_sla" bpmnElement="f_reb_sla">
         <di:waypoint x="1088" y="1138" />
         <di:waypoint x="1088" y="1158" />
         <di:waypoint x="1218" y="1158" />
-        <di:waypoint x="1218" y="1880" />
-        <di:waypoint x="1238" y="1880" />
+        <di:waypoint x="1218" y="2040" />
+        <di:waypoint x="1238" y="2040" />
         <bpmndi:BPMNLabel>
           <dc:Bounds x="1118" y="1125" width="70" height="28" />
         </bpmndi:BPMNLabel>
@@ -845,12 +901,15 @@
         <di:waypoint x="1088" y="838" />
         <di:waypoint x="1018" y="838" />
         <di:waypoint x="1018" y="700" />
-        <di:waypoint x="1558" y="700" />
-        <di:waypoint x="1558" y="980" />
-        <di:waypoint x="1526" y="980" />
-        <di:waypoint x="1526" y="1360" />
+        <di:waypoint x="1358" y="700" />
+        <di:waypoint x="1358" y="540" />
+        <di:waypoint x="1758" y="540" />
+        <di:waypoint x="1758" y="1980" />
+        <di:waypoint x="1618" y="1980" />
+        <di:waypoint x="1618" y="1400" />
+        <di:waypoint x="1638" y="1400" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1233" y="667" width="70" height="28" />
+          <dc:Bounds x="1363" y="606" width="70" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_ci_fixed" bpmnElement="f_ci_fixed">
@@ -859,9 +918,24 @@
         <di:waypoint x="402" y="840" />
         <di:waypoint x="402" y="160" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="826" y="848" width="39" height="14" />
+          <dc:Bounds x="906" y="818" width="39" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_f_ci_reattempt" bpmnElement="f_ci_reattempt">
+        <di:waypoint x="1288" y="785" />
+        <di:waypoint x="1288" y="840" />
+        <di:waypoint x="402" y="840" />
+        <di:waypoint x="402" y="160" />
+        <bpmndi:BPMNLabel>
+          <dc:Bounds x="801" y="845" width="88" height="42" />
+        </bpmndi:BPMNLabel>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_f_cib_armed" bpmnElement="f_cib_armed">
+        <di:waypoint x="1688" y="640" />
+        <di:waypoint x="1688" y="660" />
+        <di:waypoint x="570" y="660" />
+        <di:waypoint x="570" y="138" />
+      </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_f_reb_rebased" bpmnElement="f_reb_rebased">
         <di:waypoint x="1288" y="1105" />
         <di:waypoint x="1288" y="1160" />

package/resources/prompts/fix-ci.md

@@ -75,15 +75,30 @@ Return a structured result:
   first, as `owner/repo#N` refs (or PR URLs), separated by commas or spaces. The
   process records the dependency and automatically re-attempts the merge once every
   named PR has landed.
+- `status: "reattempt"` — you pushed **no** commit because there was **nothing to fix
+  on the branch**: the failing required checks are **stale / transient** — e.g.
+  `CANCELLED` runs superseded by a newer run on the *identical head SHA* (GitHub CI
+  concurrency), a newer run on the same SHA that is already green, or an infrastructure
+  blip — and the PR's head is actually mergeable. This is **not** a defect and **not** a
+  human decision: the merge should simply be **re-queued from ground truth**. Set
+  `pushed: false` and say in `summary` why the checks are stale (which runs, on which
+  SHA). The process re-arms the merge poller, which re-derives mergeability and merges
+  when the head is green — **no human is pulled in**. Prefer this over `blocked` for
+  every "nothing was wrong / the failure was transient / the head already looks green"
+  case.
 - `status: "blocked"` — you could **not** fix it and it genuinely needs a human
   **decision** (a secret, an upstream change, or a judgement call). Set `question` to a
   concise, specific description of what is blocking and what a human must decide.
-  Reserve this for a real decision — if the PR is merely waiting on another PR, use
-  `waiting-on-pr` instead so no human is pulled in.
+  Reserve this for a **real** human decision — if the PR is merely waiting on another PR
+  use `waiting-on-pr`, and if the failing checks are stale/transient with nothing to fix
+  use `reattempt`. `blocked` **pages a human**, so never use it for a self-healing PR.
 
-Never report `fixed` unless you actually pushed a change. If nothing was wrong on
-the branch (the failure was transient infrastructure), say so in `summary` and
-return `blocked` so a human can decide whether to just retry the merge.
+Report whether you pushed via `pushed` (`true` after you commit + push a fix, `false`
+when you changed nothing). Never report `fixed` unless you actually pushed a change. If
+nothing was wrong on the branch (the failure was transient infrastructure / stale
+cancelled checks and the head is green), return **`reattempt`** (with `pushed: false`)
+so the merge is simply re-attempted from ground truth — do **not** return `blocked`,
+which would needlessly page a human.
 
 ### How to return it (the wire mechanism)
 
@@ -98,11 +113,13 @@ machine-readable result one of two ways:
 
    ```sh
    # pushed a fix you believe turns the failing checks green:
-   printf '%s' '{"status":"fixed","summary":"Fixed the flaky timeout in auth.test.ts and pushed"}' > "$AGENT_RESULT_FILE"
+   printf '%s' '{"status":"fixed","pushed":true,"summary":"Fixed the flaky timeout in auth.test.ts and pushed"}' > "$AGENT_RESULT_FILE"
+   # nothing to fix — the failing checks are stale/transient (CANCELLED superseded on the same head SHA, head already green); just re-attempt the merge:
+   printf '%s' '{"status":"reattempt","pushed":false,"summary":"Failing checks are CANCELLED runs superseded by a green run on the same head SHA — nothing to fix, re-queue the merge"}' > "$AGENT_RESULT_FILE"
    # ordering constraint — must wait for another PR to land first:
-   printf '%s' '{"status":"waiting-on-pr","summary":"Blocked by the linked-issue gate","dependsOn":"owner/repo#123"}' > "$AGENT_RESULT_FILE"
+   printf '%s' '{"status":"waiting-on-pr","pushed":false,"summary":"Blocked by the linked-issue gate","dependsOn":"owner/repo#123"}' > "$AGENT_RESULT_FILE"
    # genuinely stuck — a human must decide:
-   printf '%s' '{"status":"blocked","summary":"CI needs an NPM_TOKEN secret I cannot set","question":"Add the NPM_TOKEN repo secret, then answer to rerun."}' > "$AGENT_RESULT_FILE"
+   printf '%s' '{"status":"blocked","pushed":false,"summary":"CI needs an NPM_TOKEN secret I cannot set","question":"Add the NPM_TOKEN repo secret, then answer to rerun."}' > "$AGENT_RESULT_FILE"
    ```
 
    Write this file **once**, at the very end, with your final result. Keep it a flat
@@ -125,7 +142,10 @@ a non-zero exit means a genuine crash and the job is retried.
 **Emitting a machine-readable result is your mandatory final step — never exit
 silently.** It is the last thing you do on every path out of this job (including after
 a push, or when you conclude nothing can be fixed). If you are ever unsure which status
-applies, return **`blocked`** with a `summary` and a concrete `question` rather than
-leaving without a result — a missing result is treated as an unclassified merge
-escalation that pulls in a human and stalls the merge, so relying on that default
-wastes the attempt.
+applies but the PR's **head looks green / the failure was transient** (stale or
+cancelled checks, an infra blip), return **`reattempt`** (with `pushed: false`) so the
+merge is simply re-attempted from ground truth — do **not** default to `blocked`, which
+pages a human. Reserve `blocked` for a genuine human decision with a concrete
+`question`. A missing result is treated by the process as *no verdict* and reconciled
+from ground truth (it re-arms the merge poller), which is slower and drops your explicit
+classification — emit `reattempt` explicitly rather than relying on that fall-through.