@nanobpm/nano-workforce 0.39.1 → 0.39.2

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.39.2](https://github.com/nanobpm/nano-workforce/compare/v0.39.1...v0.39.2) (2026-08-11)
+
+
+### Bug Fixes
+
+* **merge:** recover PRs merged out-of-band instead of wedging in "merging" ([#112](https://github.com/nanobpm/nano-workforce/issues/112)) ([037d8aa](https://github.com/nanobpm/nano-workforce/commit/037d8aa2538b85f9c1b43927378f3578530a924e)), closes [Magikcraft/nano-bpm#723](https://github.com/Magikcraft/nano-bpm/issues/723)
+
 ## [0.39.1](https://github.com/nanobpm/nano-workforce/compare/v0.39.0...v0.39.1) (2026-08-10)
 
 

package/app/service.ts

@@ -668,11 +668,17 @@ async function pollMerges(data: DataLayer, engine: EngineClient, token: string)
       const st = await fetchPrState(repo, number, token);
       if (st === null) continue; // no transport → skip this PR (others may still advance)
       if (st.merged) {
-        // Landed out-of-band (someone merged it) — skip straight to done.
+        // Landed out-of-band (a maintainer clicked Merge, a mergify queue merged it, etc.). The
+        // instance is parked at `wait-mergeable`, which subscribes to `merge-ready` — NOT
+        // `merge-landed` (that catch, `wait-landed`, only exists later, after we enqueue). Publishing
+        // `merge-landed` here has no subscription to correlate to, so the engine drops it and the PR
+        // wedges forever in the transient `merging` status (which no poller branch re-scans).
+        // Publish `merge-ready` with a `ready` verdict instead: it routes through `gw-mergeable` to
+        // `attempt-merge`, whose idempotent already-merged check completes the loop (`mark-merged`).
         await flipToMergingThenPublish(data, engine, prKey, "waiting_merge", {
-          name: "merge-landed",
+          name: "merge-ready",
           correlationKey: prKey,
-          variables: {},
+          variables: { mergeState: "ready", failingChecks: 0, failingChecksList: "" },
         });
         console.log(`[poller] already merged -> ${prKey}`);
         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.39.1",
+  "version": "0.39.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/workers/merge/worker.test.ts

@@ -0,0 +1,96 @@
+// Regression for the out-of-band merge wedge (Magikcraft/nano-bpm#723): when a PR is merged
+// independently of the process (a maintainer clicks Merge, a mergify queue lands it), the poller
+// routes the merge-loop instance back through `attempt-merge`. This worker must detect the
+// already-merged state and complete the loop directly — NOT re-run the land protocol, which would post a
+// spurious `@mergifyio queue` comment (mergify-queue repos) or a redundant merge call. Forces the
+// token transport and stubs `globalThis.fetch` so the single-PR GET reports `merged: true`.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import handler from "./worker.ts";
+
+function fakeApp() {
+  const stores: Record<string, Record<string, unknown>[]> = {
+    pull_requests: [],
+    merges: [],
+  };
+  return {
+    app: {
+      data: {
+        table(name: string, key: string) {
+          const store = (stores[name] ??= []);
+          return {
+            get: (k: any) => Promise.resolve(store.find((r) => r[key] === k)),
+            find: (q: any) =>
+              Promise.resolve(
+                store.filter((r) => Object.entries(q).every(([f, v]) => r[f] === v)),
+              ),
+            insert: (row: any) => {
+              store.push(row);
+              return Promise.resolve(store.length);
+            },
+            update: (k: any, patch: any) => {
+              const row = store.find((r) => r[key] === k);
+              if (row) Object.assign(row, patch);
+              return Promise.resolve(row);
+            },
+          };
+        },
+      },
+      log: () => undefined,
+      engine: {},
+    } as any,
+    stores,
+  };
+}
+
+function withMergedPr(run: (calls: string[]) => Promise<void>): Promise<void> {
+  const oldTransport = process.env["NANO_PR_GITHUB_TRANSPORT"];
+  const oldToken = process.env["GITHUB_TOKEN"];
+  const oldFetch = globalThis.fetch;
+  const calls: string[] = [];
+  process.env["NANO_PR_GITHUB_TRANSPORT"] = "token";
+  process.env["GITHUB_TOKEN"] = "test-token";
+  globalThis.fetch = ((input: string | URL | Request) => {
+    const url = String(input);
+    calls.push(url);
+    // Single-PR GET → report the PR as already merged.
+    if (/\/pulls\/\d+$/.test(url)) {
+      return Promise.resolve(new Response(JSON.stringify({ merged: true, mergeable_state: "clean" })));
+    }
+    return Promise.resolve(new Response("not found", { status: 404 }));
+  }) as typeof fetch;
+  return run(calls).finally(() => {
+    if (oldTransport == null) delete process.env["NANO_PR_GITHUB_TRANSPORT"];
+    else process.env["NANO_PR_GITHUB_TRANSPORT"] = oldTransport;
+    if (oldToken == null) delete process.env["GITHUB_TOKEN"];
+    else process.env["GITHUB_TOKEN"] = oldToken;
+    globalThis.fetch = oldFetch;
+  });
+}
+
+test("pr.merge short-circuits an already-merged PR without re-running the land protocol", async () => {
+  await withMergedPr(async (calls) => {
+    const { app, stores } = fakeApp();
+    const out = (await handler(
+      {
+        variables: {
+          prKey: "Magikcraft/nano-bpm#723",
+          repo: "Magikcraft/nano-bpm",
+          prNumber: 723,
+        },
+      } as any,
+      app,
+    )) as Record<string, unknown>;
+
+    // Completes the loop directly.
+    assertEquals(out, { mergeStatus: "merged" });
+
+    // Records exactly one audit row, tagged as the idempotent already-merged path.
+    assertEquals(stores.merges.length, 1);
+    assertEquals(stores.merges[0].outcome, "merged");
+    assertEquals(stores.merges[0].method, "already-merged");
+
+    // Never posts an enqueue comment or issues a merge call (only the read GET happened).
+    assertEquals(calls.some((u) => /comments|merge$/.test(u)), false);
+  });
+});

package/workers/merge/worker.ts

@@ -11,7 +11,7 @@
 import type { AppJobHandler } from "@nanobpm/urban";
 import { abandonTokenFromUrl } from "../../app/abandon.ts";
 import { checkBaseTarget } from "../../app/baseGuard.ts";
-import { enqueueViaComment, mergePr } from "../../app/github.ts";
+import { enqueueViaComment, fetchPrState, mergePr } from "../../app/github.ts";
 import { loadMergeProtocol } from "../../app/mergeProtocol.ts";
 import { ensurePr, MERGE_ADMIN, MERGE_METHOD } from "../../app/service.ts";
 
@@ -51,6 +51,25 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     abandonToken: abandonTokenFromUrl(abandonUrl),
   });
 
+  // Idempotent already-merged short-circuit. When the poller routes an out-of-band-merged PR back
+  // through `attempt-merge` (service.ts publishes `merge-ready` on the `waiting_merge` out-of-band
+  // branch), the PR is already landed on GitHub. Re-running the land protocol would post a spurious
+  // `@mergifyio queue` comment (mergify-queue repos) or a redundant merge call, so detect the merged
+  // state first and complete the loop directly. Runs AFTER ensurePr so the `merges` audit row has its
+  // FK parent, and BEFORE the base-guard/protocol logic. Best-effort: a transport hiccup falls through
+  // to the normal path rather than blocking a genuine merge.
+  const pre = await fetchPrState(repo, prNumber, token).catch(() => null);
+  if (pre?.merged) {
+    await app.data.table("merges", "id").insert({
+      pr_key: prKey,
+      outcome: "merged",
+      method: "already-merged",
+      detail: "PR was already merged on GitHub (landed out-of-band)",
+      at: now,
+    });
+    return { mergeStatus: "merged" };
+  }
+
   // Dead-end-base guard (#60): never land a PR into a base branch that has itself already merged
   // to the default branch — the merge would land into a dead branch and never reach `main`.
   // GitHub only auto-retargets a PR when its base is *deleted* on merge; a merged-but-undeleted