@nanobpm/nano-workforce 0.206.1 → 0.206.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.206.2](https://github.com/nanobpm/nano-workforce/compare/v0.206.1...v0.206.2) (2026-11-09)
+
+### Bug Fixes
+
+* **merge:** let a DIRTY state outrank absent required checks so a conflicting PR reaches the rebase arm ([#930](https://github.com/nanobpm/nano-workforce/issues/930)) ([71984d5](https://github.com/nanobpm/nano-workforce/commit/71984d5d607151b2c3690a12d6b05537b24c3ece)), closes [#392](https://github.com/nanobpm/nano-workforce/issues/392) [nanobpm/nano-bpm#1444](https://github.com/nanobpm/nano-bpm/issues/1444) [#929](https://github.com/nanobpm/nano-workforce/issues/929)
+
 ## [0.206.1](https://github.com/nanobpm/nano-workforce/compare/v0.206.0...v0.206.1) (2026-11-08)
 
 ### Bug Fixes

package/app/github.test.ts

@@ -719,6 +719,49 @@ const MERGE_CASES: MergeCase[] = [
     protocol: protocolWith({ requiredChecks: reqChecks("build"), waitForChecks: true }),
     want: "waiting",
   },
+  // ── DIRTY outranks an ABSENT/PENDING required check (issue #929) ─────────────────────────────
+  // GitHub does not run `pull_request` workflows on a PR with merge conflicts, so a DIRTY head
+  // reports its declared-required checks as ABSENT (or skipped). Mapping that absence to `waiting`
+  // deadlocks the merge loop: the checks can never arrive until the conflict is resolved, and the
+  // conflict is never routed to the rebase arm because the checks read as "not yet run". The
+  // conflict is ground truth whose remedy (a rebase) is also exactly what re-triggers CI, so DIRTY
+  // outranks absence — but NOT a red declared-required check, which still routes to fix-ci.
+  {
+    name: "DIRTY + declared-required check ABSENT -> conflict, not waiting (the #929 deadlock)",
+    state: { mergeStateStatus: "DIRTY", rollup: [{ name: "summary", conclusion: "SKIPPED" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("typecheck + test (Node)", "whole-repo invariants") }),
+    want: "conflict",
+  },
+  {
+    name: "DIRTY + no check runs at all -> conflict (absence is a consequence of the conflict)",
+    state: { mergeStateStatus: "DIRTY" },
+    protocol: protocolWith({ requiredChecks: reqChecks("build"), waitForChecks: true }),
+    want: "conflict",
+  },
+  {
+    name: "DIRTY + declared-required check PENDING -> conflict (rebase, then CI re-runs on the new head)",
+    state: { mergeStateStatus: "DIRTY", rollup: [{ name: "build", conclusion: "QUEUED" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "conflict",
+  },
+  {
+    name: "DIRTY + declared-required check present-but-unconcluded -> conflict",
+    state: { mergeStateStatus: "DIRTY", rollup: [{ name: "build", conclusion: "IN_PROGRESS" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "conflict",
+  },
+  {
+    name: "DIRTY + RED declared-required check -> blocked (a red check still outranks the conflict)",
+    state: { mergeStateStatus: "DIRTY", rollup: [{ name: "build", conclusion: "FAILURE" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "blocked",
+  },
+  {
+    name: "DIRTY + green declared-required checks -> conflict (unchanged pre-#929 behaviour)",
+    state: { mergeStateStatus: "DIRTY", rollup: [{ name: "build", conclusion: "SUCCESS" }] },
+    protocol: protocolWith({ requiredChecks: reqChecks("build") }),
+    want: "conflict",
+  },
 ];
 
 for (const c of MERGE_CASES) {

package/app/github.ts

@@ -1621,7 +1621,6 @@ export function classifyMergeability(s: PrState, protocol?: MergeProtocol): Merg
   // settled-thread routing below.
   const gate = requiredChecksVerdict(s, protocol);
   if (gate === "blocked") return "blocked";
-  if (gate === "waiting") return "waiting";
   // A GitHub-identified merge conflict (`mergeStateStatus: "DIRTY"`) is ground truth whose remedy is
   // a rebase, dispatched off the `conflict` verdict. It outranks the thread gate below (PR #922
   // review, thread 1): a FAILED thread probe (`THREAD_PROBE_FAILED`) returning `waiting` here would
@@ -1630,7 +1629,18 @@ export function classifyMergeability(s: PrState, protocol?: MergeProtocol): Merg
   // round that cannot clear it. Surface the conflict first; the threads are re-triaged once the
   // rebased head is re-read. (A red declared-required check still outranks even this — see the
   // backstop above — so a conflicting PR with failing CI routes to fix-ci, not a doomed rebase.)
+  //
+  // DIRTY also outranks a `waiting` required-checks verdict (issue #929): GitHub does NOT run
+  // `pull_request` workflows on a PR with merge conflicts, so a conflicting head reports its
+  // declared-required checks as ABSENT (or skipped) — and `requiredChecksVerdict` maps absence to
+  // `waiting`. Evaluated in the old order that deadlocked the merge loop: the checks can never
+  // arrive until the conflict is resolved, and the conflict was never routed to the rebase arm
+  // because the absent checks read as "not yet run". The absence is a CONSEQUENCE of the conflict,
+  // and the conflict's remedy (a rebase) is exactly what re-triggers CI on the new head — so the
+  // conflict owns the verdict. Only a RED declared-required check (`blocked`, handled above) may
+  // still outrank DIRTY.
   if (s.mergeStateStatus === "DIRTY") return "conflict";
+  if (gate === "waiting") return "waiting";
   // The merge-stage thread gate (issue #921, PR #922 review): a read that opted into the
   // review-threads probe and found ≥1 open thread (`unresolvedThreads > 0`) is NEVER merge-ready,
   // whatever `mergeStateStatus` says. A repo without branch-protection

package/app/mergeLoopBehaviour.test.ts

@@ -498,7 +498,9 @@ test("the 'waiting' re-poll is bounded — exhausting mergeStallMax escalates to
   const engine = await boot({
     vars: { mergeStallMax: 0 },
     responses: {
-      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "" },
+      // The probe always emits the full tri-state (a failed read reports reviewThreads: -1) — the
+      // escalation wording reads it, so the test payload must carry it.
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: -1, pendingChecks: 0 },
     },
   });
   await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
@@ -509,6 +511,186 @@ test("the 'waiting' re-poll is bounded — exhausting mergeStallMax escalates to
   assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("wait-mergeable-repoll", "merge-stall-probe", "merge-esc-conflict");
 });
 
+// ---------------------------------------------------------------------------
+// #929 — a DIRTY PR whose required checks are ABSENT (GitHub skips pull_request
+// workflows on a conflicting head) must route to the rebase arm, never to the
+// misleading "all checks green … needs approval" escalation.
+// ---------------------------------------------------------------------------
+
+test("a DIRTY PR with absent required checks reaches SP_rebase via the stall probe (#929)", async () => {
+  // The incident (nanobpm/nano-bpm#1444): REST reported mergeable=false/dirty and every
+  // declared-required check was ABSENT (GitHub skips CI on a conflicting head), yet the loop
+  // escalated "needs approval" twice and never dispatched the rebase. With the classifier fix,
+  // the stall probe re-derives `conflict` and the token reaches the rebase agent.
+  const engine = await boot({
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "conflict", failingChecks: 0, failingChecksList: "", reviewThreads: 0, pendingChecks: 0 },
+      "senior:rebase": { status: "rebased" },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  // The poller's pre-fix verdict was `waiting` (absent required checks outranked DIRTY), so the
+  // instance is parked on the mergeable wait when the stall timer fires.
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  assertThatInstance(engine, byProcessId("merge-loop"))
+    .isActive()
+    .hasActiveElement("wait-mergeable")
+    .hasCompletedElements("merge-stall-probe", "rebase") // the rebase agent ran — SP_rebase was reached
+    .hasVariable("rebaseRound", 1);
+  assert(!completedElementIds(engine).has("merge-esc-conflict"), "a DIRTY PR must rebase, not escalate 'needs approval'");
+  const openTasks = await engine.searchUserTasks({});
+  assert(!openTasks.some((t) => t.elementId === "wait-merge-answer"), "no human escalation on the rebase path");
+});
+
+test("a stall escalation on a DIRTY PR never claims 'all checks green' — it names the conflict (#929)", async () => {
+  // The pre-fix escalation built "all checks green (none failing, none pending)" from
+  // `failingChecks = 0 and pendingChecks = 0` — but on a DIRTY head those zeros mean GitHub
+  // SKIPPED the required checks, not that they passed. The approval wording must stay gated on a
+  // PROBED-and-clear thread count; a DIRTY PR (whose `conflict` verdict is only reachable via the
+  // rebase arm) that still lands here keeps the conservative wording instead of the false claim.
+  const engine = await boot({
+    vars: { mergeStallMax: 0, rebaseMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "conflict", failingChecks: 0, failingChecksList: "", reviewThreads: -1, pendingChecks: 0 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("merge-stall-probe", "merge-esc-conflict");
+  const q = String(escalation(engine).question ?? "");
+  assert(!q.includes("all checks green"), "absent/unprobed checks must never read as 'all checks green'");
+  assert(!q.includes("required review approval"), "a conflict must never read as a review-approval wait");
+  assertStringIncludes(q, "merge conflict", "the conflict escalation must name the conflict");
+  // PR #930 review: the verdict alone does not establish that the required checks are ABSENT —
+  // a conflicting head can carry successful required checks, and a failed read reports the same
+  // zeros — so the escalation may only note that GitHub MAY not have run them, never assert it.
+  assert(!q.includes("absent, NOT green"), "the verdict alone never establishes that the required checks are absent");
+  assertStringIncludes(q, "may not have run", "the escalation notes the check-skip caveat without asserting it");
+});
+
+test("a conflict-verdict escalation with GREEN required checks still names only the conflict (#930 review)", async () => {
+  // The mirror case the review called out: `conflict` with every required check successful. The
+  // escalation must not claim the checks are absent or not-green — only the conflict is known.
+  const engine = await boot({
+    vars: { mergeStallMax: 0, rebaseMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "conflict", failingChecks: 0, failingChecksList: "", reviewThreads: 0, pendingChecks: 0 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  const q = String(escalation(engine).question ?? "");
+  assertStringIncludes(q, "merge conflict", "the conflict escalation must name the conflict");
+  assert(!q.includes("NOT green"), "green required checks must never be described as not-green");
+  assert(!q.includes("all checks green"), "the escalation asserts the conflict, not the check state either way");
+});
+
+test("a stalled 'waiting' with clear threads and zero checks never asserts the required checks ran (#930 review)", async () => {
+  // `waiting` + reviewThreads>0 + failing=0/pending=0 is ambiguous: the required checks may be
+  // absent (never ran on a conflicting head) rather than green. The escalation must float both
+  // candidates — a conflict whose checks never ran, or a review-approval requirement — and send
+  // the human to the PR, never assert "no failing or pending checks" as if the rollup were green.
+  const engine = await boot({
+    vars: { mergeStallMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: 0, pendingChecks: 0 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("merge-stall-probe", "merge-esc-conflict");
+  const q = String(escalation(engine).question ?? "");
+  assert(!q.includes("all checks green"), "zero counts with clear threads must never claim green checks");
+  assert(!q.includes("NO failing or pending checks"), "zero counts do not establish that the required checks ran");
+  assert(!q.includes("required review approval is outstanding"), "an ambiguous read must never assert a verified review-approval blocker");
+  assertStringIncludes(q, "not verified", "the approval blocker must be floated, not asserted");
+  assertStringIncludes(q, "may never have run", "the escalation must allow that the required checks never ran");
+});
+
+test("a stalled 'waiting' with unresolved threads reports their count and asks to resolve them (#930 review)", async () => {
+  // Absent required checks can yield `waiting` before the thread gate runs; the verified unresolved
+  // threads must be surfaced, since resolving a conflict or approving does not clear them.
+  const engine = await boot({
+    vars: { mergeStallMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: 2, pendingChecks: 0 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  const q = String(escalation(engine).question ?? "");
+  assertStringIncludes(q, "2 unresolved review thread(s)", "the verified thread count must be reported");
+  assertStringIncludes(q, "Resolve those conversations", "the operator must be asked to resolve the threads");
+  assertStringIncludes(q, "may never have run", "the check state stays unverified");
+  assert(!q.includes("all checks green"), "never claim green checks");
+});
+
+test("a stall escalation after a FAILED GitHub read says the state could not be read — never a confirmed conflict (#930 review)", async () => {
+  // The stall probe's catch maps a failed read to `waiting`, reviewThreads -1, zero checks — the
+  // exact payload the pre-fix wording read as a confirmed conflict. The escalation must report an
+  // unreadable state and nothing more specific.
+  const engine = await boot({
+    vars: { mergeStallMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: -1, pendingChecks: 0 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  const q = String(escalation(engine).question ?? "");
+  assertStringIncludes(q, "could not be fully read", "a failed read must be named as such");
+  assert(!q.includes("CONFLICTING"), "a failed read must never assert a confirmed conflict");
+  assert(!q.includes("required review approval"), "a failed read must never assert a review-approval blocker");
+});
+
+test("a stall give-up with no remediation attempted never claims a remediation budget was exhausted (#930 review)", async () => {
+  for (const mergeState of ["conflict", "blocked"]) {
+    const engine = await boot({
+      vars: { mergeStallMax: 0 },
+      responses: {
+        "pr.merge-stall-probe": { mergeState, failingChecks: mergeState === "blocked" ? 1 : 0, failingChecksList: mergeState === "blocked" ? "ci" : "", reviewThreads: 0, pendingChecks: 0 },
+      },
+    });
+    await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+    await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+    const q = String(escalation(engine).question ?? "");
+    if (q === "") continue; // routed to a remediation agent rather than the direct give-up
+    assert(!/budget|exhausted/.test(q), `${mergeState}: the escalation must not claim an exhausted budget: ${q}`);
+  }
+});
+
+test("answering 'retry' on a DIRTY PR's escalation re-arms the poller, which re-derives conflict and rebases (#929)", async () => {
+  // The incident's second half: a human answered "retry" and the loop re-classified the same way
+  // and escalated again — the rebase was never reached. Post-fix the retry re-arms the poller; the
+  // next verdict for the still-DIRTY PR is `conflict`, which dispatches the rebase agent.
+  const engine = await boot({
+    vars: { mergeStallMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: -1, pendingChecks: 0 },
+      "senior:rebase": { status: "rebased" },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  // The human replies "retry" — the answer reconciles then re-arms the poller.
+  await engine.completeUserTask(await mergeAnswerTaskKey(engine), { answer: "retry" });
+  assertThatInstance(engine, byProcessId("merge-loop")).isActive().hasActiveElement("wait-mergeable");
+  // The re-armed poller now classifies the DIRTY PR as `conflict` (absent required checks no
+  // longer outrank DIRTY) and the rebase agent is dispatched.
+  await engine.publishMessage({ name: "merge-ready", correlationKey: "pr-1", variables: { mergeState: "conflict" } });
+  assertThatInstance(engine, byProcessId("merge-loop"))
+    .isActive()
+    .hasActiveElement("wait-mergeable")
+    .hasCompletedElements("record-merge-answer", "rebase")
+    .hasVariable("rebaseRound", 1);
+});
+
 test("an unclassified verdict routes to auto-rebase (DEFAULT), not to a human (#774)", async () => {
   // The DEFAULT arm is a last-resort self-heal, not a page: an unexpected/garbage `mergeState` routes
   // to the bounded rebase agent (which reconciles from ground truth), never straight to a human.
@@ -637,7 +819,7 @@ test("the 'never settled' question is reserved for a genuinely unreadable/unsett
   const engine = await boot({
     vars: { mergeStallMax: 0 },
     responses: {
-      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: -1 },
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: -1, pendingChecks: 0 },
     },
   });
   await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
@@ -645,8 +827,8 @@ test("the 'never settled' question is reserved for a genuinely unreadable/unsett
   await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
   assertStringIncludes(
     String(escalation(engine).question ?? ""),
-    "never settled",
-    "a genuinely unsettled/unreadable mergeability keeps the original message",
+    "could not be fully read",
+    "a genuinely unsettled/unreadable mergeability names the unreadable state",
   );
 });
 
@@ -871,6 +1053,31 @@ test("a conflict runs the bounded rebase agent and a rebased result re-arms the
     .hasVariable("rebaseRound", 1); // the rebase counter advanced across the sub-process boundary
 });
 
+test("a rebase agent cannot spoof the escalation verdict by returning mergeState (#930 self-review)", async () => {
+  // The agent's result keys are hoisted into process scope, and `mergeState` now selects the
+  // shared merge-esc-conflict wording. A rebase agent that returns a bogus `mergeState:"ready"`
+  // must NOT be able to rewrite a "could not resolve the conflict" escalation into a
+  // green-checks/approval message: the trusted `end_reb_blocked` end event re-stamps the verdict.
+  const engine = await boot({ responses: { "senior:rebase": { status: "blocked", mergeState: "ready" } } });
+  await driveToRebase(engine);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("merge-esc-attempt");
+  assertStringIncludes(String(escalation(engine).question ?? ""), "rebase agent could not resolve", "the question must name the conflict trigger, not the spoofed verdict");
+  assertThatInstance(engine, byProcessId("merge-loop")).hasVariable("mergeState", "conflict");
+});
+
+test("a fix-ci agent cannot spoof the escalation verdict by returning mergeState (#930 self-review)", async () => {
+  // Same guard on the CI-fix side: a fix-ci agent that exhausts its budget after returning a bogus
+  // `mergeState` must still escalate with the CI-fix wording — `end_ci_esc` re-stamps the verdict.
+  const engine = await boot({ responses: { "senior:fix-ci": { status: "blocked", pushed: true, mergeState: "ready" } } });
+  await driveToCiFix(engine);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("merge-esc-attempt");
+  const q = String(escalation(engine).question ?? "");
+  assertStringIncludes(q, "could not make the required checks green", "the question must name the CI-fix failure, not the spoofed verdict");
+  assertThatInstance(engine, byProcessId("merge-loop")).hasVariable("mergeState", "blocked");
+});
+
 test("a rebase that cannot resolve escalates with a conflict question", async () => {
   const engine = await boot({ responses: { "senior:rebase": { status: "blocked" } } });
   await driveToRebase(engine);
@@ -967,6 +1174,10 @@ test("the rebase agent SLA interrupts the sub-process and escalates as not-merge
   assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("merge-esc-conflict");
   // #879 regression: the trusted rebase SLA arm must deliver its job-type marker to the shared sink.
   assertEquals(escalation(engine).agentSlaJobType, "senior:rebase", "the rebase SLA arm must reach the recorder with its job-type marker");
+  // The SLA escalation must never surface the stale `conflict` verdict's wording — the recorder's
+  // SLA builder (keyed on the trusted marker) owns the question, not the verdict FEEL.
+  const q = String(escalation(engine).question ?? "");
+  assert(!q.includes("CONFLICTING") && !q.includes("merge conflict with the base branch"), "an SLA escalation must not read as a verdict escalation");
 });
 
 test("a non-SLA escalation carrying a spoofed agentSlaJobType is scrubbed before the recorder (#879 fail-closed)", async () => {

package/build-info.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.206.1",
-  "gitSha": "973c161d8b279db21915601647c5e8c43f3cac2f",
-  "gitTag": "v0.206.1",
-  "builtAt": "2026-11-08T20:26:54.809Z"
+  "version": "0.206.2",
+  "gitSha": "71984d5d607151b2c3690a12d6b05537b24c3ece",
+  "gitTag": "v0.206.2",
+  "builtAt": "2026-11-09T11:18:01.340Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.206.1",
+  "version": "0.206.2",
   "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

@@ -115,6 +115,9 @@
           <zeebe:output source="=null" target="status" />
           <zeebe:output source="=null" target="ciBlockedReconciled" />
           <zeebe:output source="=null" target="agentSlaJobType" />
+          <zeebe:output source="=null" target="reviewThreads" />
+          <zeebe:output source="=null" target="failingChecks" />
+          <zeebe:output source="=null" target="pendingChecks" />
         </zeebe:ioMapping>
       </bpmn:extensionElements>
       <bpmn:incoming>f_m_deps</bpmn:incoming>
@@ -263,7 +266,7 @@
         </zeebe:properties>
         <zeebe:ioMapping>
           <zeebe:input source="=&#34;blocked&#34;" target="status" />
-          <zeebe:input source="=if mergeState = &#34;draft&#34; then &#34;This PR is in draft and can&#39;t be merged. Mark it ready (gh pr ready), then reply to retry.&#34; else if mergeState = &#34;waiting&#34; and reviewThreads = 0 and failingChecks = 0 and pendingChecks = 0 then &#34;This PR is merge-blocked with all checks green (none failing, none pending) and every review thread resolved. GitHub still reports BLOCKED, which means a required review approval (or code-owner review) is outstanding — nothing the automated loop can produce. Approve the PR (or adjust the branch-protection review requirement), then reply to retry.&#34; else if mergeState = &#34;waiting&#34; then &#34;GitHub never settled this PR&#39;s mergeability (still computing or checks still pending after repeated re-polls, or the state could not be read). Check the PR on GitHub — resolve any conflict or failing required check if present — then reply to retry.&#34; else &#34;This PR is not mergeable (state: &#34; + mergeState + &#34;). Resolve the conflict or failing required check on the branch, then reply to retry.&#34;" target="question" />
+          <zeebe:input source="=if agentSlaJobType != null then &#34;An automated merge-stage agent exceeded its time budget (SLA) before this PR could be merged. Check its progress or intervene, then reply to retry.&#34; else if mergeState = &#34;draft&#34; then &#34;This PR is in draft and can&#39;t be merged. Mark it ready (gh pr ready), then reply to retry.&#34; else if mergeState = &#34;conflict&#34; then &#34;This PR has a merge conflict with the base branch (GitHub reports the branch as CONFLICTING / mergeable_state=dirty). GitHub may not have run the pull_request checks on the conflicting head, so their state is unknown from this signal — the conflict alone is what is established. Resolve the conflict on the branch (git rebase / merge the base branch and push) — the rebase re-triggers CI — then reply to retry.&#34; else if mergeState = &#34;blocked&#34; then &#34;GitHub reports failing required checks on this PR, and the merge loop could not get them green automatically. Fix the failing checks on the branch (or reply with guidance), then reply to retry.&#34; else if mergeState = &#34;waiting&#34; and reviewThreads = 0 and failingChecks = 0 and pendingChecks = 0 then &#34;This PR is merge-blocked with every review thread resolved and no failing or pending checks reported. The likely cause is a required review approval (or code-owner review), but that is not verified: the declared-required checks may never have run on this head (GitHub skips pull_request workflows on a conflicting branch), so their state is not established. Check the PR on GitHub — approve it (or adjust the review requirement), or resolve any conflict (a rebase re-triggers CI) — then reply to retry.&#34; else if mergeState = &#34;waiting&#34; and reviewThreads != null and reviewThreads &#62; 0 and failingChecks = 0 and pendingChecks = 0 then &#34;This PR is merge-blocked with &#34; + string(reviewThreads) + &#34; unresolved review thread(s). Resolve those conversations on GitHub. Separately, no failing or pending checks were reported, but the declared-required checks may never have run on this head (GitHub skips pull_request workflows on a conflicting branch), so their state is not established — the block may also be a merge conflict whose checks never ran, or a required review approval. Resolve the threads, then resolve any conflict (a rebase re-triggers CI) or approve — then reply to retry.&#34; else if mergeState = &#34;waiting&#34; and (reviewThreads = null or reviewThreads &#60; 0) and failingChecks = 0 and pendingChecks = 0 then &#34;This PR is merge-blocked and its GitHub state could not be fully read (the review-thread probe was unreadable or failed), so neither a conflict nor the check/approval state is established. Check the PR on GitHub — resolve any conflict or failing required check if present — then reply to retry.&#34; else if mergeState = &#34;waiting&#34; then &#34;GitHub never settled this PR&#39;s mergeability (still computing or checks still pending after repeated re-polls, or the state could not be read). Check the PR on GitHub — resolve any conflict or failing required check if present — then reply to retry.&#34; else &#34;This PR is not mergeable (state: &#34; + mergeState + &#34;). Resolve the conflict or failing required check on the branch, then reply to retry.&#34;" target="question" />
         </zeebe:ioMapping>
       </bpmn:extensionElements>
       <bpmn:incoming>f_m_mDraft</bpmn:incoming>
@@ -528,6 +531,7 @@
           <zeebe:ioMapping>
             <zeebe:output source="=&#34;escalate&#34;" target="ciOutcome" />
             <zeebe:output source="=null" target="agentSlaJobType" />
+            <zeebe:output source="=&#34;blocked&#34;" target="mergeState" />
           </zeebe:ioMapping>
         </bpmn:extensionElements>
         <bpmn:incoming>f_cib_esc</bpmn:incoming>
@@ -684,6 +688,7 @@
           <zeebe:ioMapping>
             <zeebe:output source="=&#34;escalate-attempt&#34;" target="rebaseOutcome" />
             <zeebe:output source="=null" target="agentSlaJobType" />
+            <zeebe:output source="=&#34;conflict&#34;" target="mergeState" />
           </zeebe:ioMapping>
         </bpmn:extensionElements>
         <bpmn:incoming>f_reb_blocked</bpmn:incoming>