@nanobpm/nano-workforce 0.49.0 → 0.50.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.50.0](https://github.com/nanobpm/nano-workforce/compare/v0.49.0...v0.50.0) (2026-08-12)
+
+
+### Features
+
+* **merge:** adopt @nanobpm/urban/effect matchTags for exhaustive land dispatch ([#139](https://github.com/nanobpm/nano-workforce/issues/139)) ([c251763](https://github.com/nanobpm/nano-workforce/commit/c251763a050858ea610ce45e59a34f859163c29c)), closes [nano-ide#215](https://github.com/nano-ide/issues/215)
+
 # [0.49.0](https://github.com/nanobpm/nano-workforce/compare/v0.48.2...v0.49.0) (2026-08-12)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.49.0",
+  "version": "0.50.0",
   "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",
@@ -46,7 +46,7 @@
     "lint:fix": "biome check --write app operations workers pages components scripts e2e main.ts"
   },
   "dependencies": {
-    "@nanobpm/urban": "^0.44.0"
+    "@nanobpm/urban": "^0.45.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.11",

package/workers/merge/worker.test.ts

@@ -6,6 +6,7 @@
 // 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 { _clearMergeProtocolCache } from "../../app/mergeProtocol.ts";
 import { noopLog } from "../../test/log.ts";
 import handler from "./worker.ts";
 
@@ -95,3 +96,114 @@ test("pr.merge short-circuits an already-merged PR without re-running the land p
     assertEquals(calls.some((u) => /comments|merge$/.test(u)), false);
   });
 });
+
+// The land protocol has three terminal outcomes, dispatched by the worker's exhaustive `matchTags`
+// (worker.ts §"Exhaustive dispatch"). The already-merged short-circuit above never reaches that
+// dispatch, so the two land branches below — `queued` (repo lands via an on-demand merge queue) and
+// `blocked` (GitHub refuses the merge) — pin the behaviour of that critical terminal switch so a
+// regression in any arm is caught. Both drive the token transport and route GitHub calls through a
+// stubbed `globalThis.fetch`.
+// Each recorded call keeps the HTTP method alongside the URL so tests can assert not just *which*
+// endpoint the worker hit but *how* (e.g. enqueue via POST, merge via PUT) — a URL-only matcher
+// would stay green if the verb regressed.
+type GithubCall = { url: string; method: string };
+
+function withGithub(
+  routes: (url: string, init: RequestInit | undefined) => Response | null,
+  run: (calls: GithubCall[]) => Promise<void>,
+): Promise<void> {
+  const oldTransport = process.env["NANO_PR_GITHUB_TRANSPORT"];
+  const oldToken = process.env["GITHUB_TOKEN"];
+  const oldFetch = globalThis.fetch;
+  const calls: GithubCall[] = [];
+  process.env["NANO_PR_GITHUB_TRANSPORT"] = "token";
+  process.env["GITHUB_TOKEN"] = "test-token";
+  _clearMergeProtocolCache();
+  globalThis.fetch = ((input: string | URL | Request, init?: RequestInit) => {
+    const url = String(input);
+    calls.push({ url, method: (init?.method ?? "GET").toUpperCase() });
+    const res = routes(url, init);
+    return Promise.resolve(res ?? 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;
+    _clearMergeProtocolCache();
+  });
+}
+
+test("pr.merge routes a mergify-queue repo through the queued branch (enqueue comment, status=queued)", async () => {
+  // AGENTS.md publishes a mergify-queue land protocol, so the worker enqueues via a comment rather
+  // than issuing a direct merge; the queued arm of `matchTags` marks the PR `queued` and returns.
+  const protocol =
+    "# repo\n\n```merge-protocol\n{ \"land\": { \"method\": \"mergify-queue\", \"comment\": \"@mergifyio queue\" } }\n```\n";
+  await withGithub(
+    (url) => {
+      if (/\/contents\/AGENTS\.md$/.test(url)) return new Response(protocol);
+      if (/\/pulls\/\d+$/.test(url)) return new Response(JSON.stringify({ merged: false, mergeable_state: "clean" }));
+      if (/\/issues\/\d+\/comments$/.test(url)) return new Response(JSON.stringify({ id: 1 }), { status: 201 });
+      return null;
+    },
+    async (calls) => {
+      const { app, stores } = fakeApp();
+      const out = (await handler(
+        { variables: { prKey: "acme/widgets#7", repo: "acme/widgets", prNumber: 7 } } as any,
+        app,
+      )) as Record<string, unknown>;
+
+      // Queued arm: waits for `merge-landed`, so it reports `queued` (not `merged`/`blocked`).
+      assertEquals(out, { mergeStatus: "queued" });
+
+      // Enqueued via the protocol's comment (POST), never a direct merge PUT.
+      assertEquals(
+        calls.some((c) => /\/issues\/\d+\/comments$/.test(c.url) && c.method === "POST"),
+        true,
+      );
+      assertEquals(calls.some((c) => /\/merge$/.test(c.url)), false);
+
+      // Audit row records the queue-comment land, and the PR row is flipped to `queued`.
+      assertEquals(stores.merges.length, 1);
+      assertEquals(stores.merges[0].outcome, "queued");
+      assertEquals(stores.merges[0].method, "queue-comment");
+      assertEquals(stores.pull_requests.find((r) => r.pr_key === "acme/widgets#7")?.status, "queued");
+    },
+  );
+});
+
+test("pr.merge routes a refused merge through the blocked branch (escalation payload)", async () => {
+  // Default (gh-merge) protocol; GitHub refuses the merge PUT, so `mergePr` reports `blocked` and the
+  // blocked arm of `matchTags` shapes the human-facing escalation question from the failure detail.
+  await withGithub(
+    (url) => {
+      if (/\/pulls\/\d+\/merge$/.test(url))
+        return new Response("Pull Request is not mergeable", { status: 405, statusText: "Method Not Allowed" });
+      if (/\/pulls\/\d+$/.test(url)) return new Response(JSON.stringify({ merged: false, mergeable_state: "dirty" }));
+      return null; // no AGENTS.md / merge-protocol.json → DEFAULT gh-merge protocol
+    },
+    async (calls) => {
+      const { app, stores } = fakeApp();
+      const out = (await handler(
+        { variables: { prKey: "acme/widgets#9", repo: "acme/widgets", prNumber: 9 } } as any,
+        app,
+      )) as Record<string, unknown>;
+
+      // Blocked arm: surfaces both the loop-terminal `mergeStatus` and the escalation `status`.
+      assertEquals(out.mergeStatus, "blocked");
+      assertEquals(out.status, "blocked");
+      assertEquals(typeof out.question, "string");
+      assertEquals((out.question as string).startsWith("Automated merge was blocked:"), true);
+
+      // Attempted a real merge PUT (not an enqueue comment), and recorded a blocked audit row.
+      assertEquals(
+        calls.some((c) => /\/pulls\/\d+\/merge$/.test(c.url) && c.method === "PUT"),
+        true,
+      );
+      assertEquals(calls.some((c) => /\/comments$/.test(c.url)), false);
+      assertEquals(stores.merges.length, 1);
+      assertEquals(stores.merges[0].outcome, "blocked");
+    },
+  );
+});

package/workers/merge/worker.ts

@@ -9,6 +9,7 @@
 // calls live in app/github.ts; this worker records the attempt in the `merges` audit table and
 // shapes the escalation payload on a block.
 import type { AppJobHandler } from "@nanobpm/urban";
+import { matchTags, tag } from "@nanobpm/urban/effect";
 import { abandonTokenFromUrl } from "../../app/abandon.ts";
 import { checkBaseTarget } from "../../app/baseGuard.ts";
 import { enqueueViaComment, fetchPrState, mergePr } from "../../app/github.ts";
@@ -134,25 +135,29 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     at: now,
   });
 
-  if (outcome === "queued") {
-    await app.data.table("pull_requests", "pr_key").update(prKey, {
-      status: "queued",
-      updated_at: now,
-    });
-    return { mergeStatus: "queued" };
-  }
-  if (outcome === "merged") {
-    return { mergeStatus: "merged" };
-  }
-  // blocked → hand the escalation machinery a concrete question.
+  // Exhaustive dispatch on the land outcome. Modelled as a tagged value so
+  // `matchTags` forces a handler for every case — adding a new outcome to the
+  // `"merged" | "queued" | "blocked"` union becomes a compile error here rather
+  // than silently falling through to the "blocked" branch.
   const docHint = protocol?.doc ? ` See the repo's merge protocol (${protocol.doc}).` : "";
-  return {
-    mergeStatus: "blocked",
-    status: "blocked",
-    question:
-      `Automated merge was blocked: ${detail}. ` +
-      `Resolve it on GitHub (rebase / fix a required check / grant merge rights), then reply to retry.${docHint}`,
-  };
+  return await matchTags(tag(outcome, { detail }), {
+    queued: async () => {
+      await app.data.table("pull_requests", "pr_key").update(prKey, {
+        status: "queued",
+        updated_at: now,
+      });
+      return { mergeStatus: "queued" };
+    },
+    merged: async () => ({ mergeStatus: "merged" }),
+    // blocked → hand the escalation machinery a concrete question.
+    blocked: async (o) => ({
+      mergeStatus: "blocked",
+      status: "blocked",
+      question:
+        `Automated merge was blocked: ${o.detail}. ` +
+        `Resolve it on GitHub (rebase / fix a required check / grant merge rights), then reply to retry.${docHint}`,
+    }),
+  });
 };
 
 export default handler;