@nanobpm/nano-workforce 0.73.0 → 0.73.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.73.1](https://github.com/nanobpm/nano-workforce/compare/v0.73.0...v0.73.1) (2026-08-16)
+
+
+### Bug Fixes
+
+* **merge:** treat a Depends-on ref that is not a PR as non-blocking ([#246](https://github.com/nanobpm/nano-workforce/issues/246)) ([c800f81](https://github.com/nanobpm/nano-workforce/commit/c800f81b02b3a9a787d79552f4e5eef9971e3edf)), closes [Magikcraft/nano-bpm#806](https://github.com/Magikcraft/nano-bpm/issues/806)
+
 # [0.73.0](https://github.com/nanobpm/nano-workforce/compare/v0.72.1...v0.73.0) (2026-08-15)
 
 

package/app/github.test.ts

@@ -3,7 +3,7 @@
 // the merge-exclusion graph. Force the token transport and stub `globalThis.fetch`.
 import { test } from "node:test";
 import { assertEquals, assertRejects } from "#test-assert";
-import { BaseBranchMustExistError, ensureBaseBranch, fetchPrFiles } from "./github.ts";
+import { BaseBranchMustExistError, ensureBaseBranch, fetchPrFiles, isNotAPullRequestError } from "./github.ts";
 
 // A fake `fetch` that serves `pages` of file batches; each page N (1-based) returns `pages[N-1]`
 // files (named `f{index}`), setting a `Link: rel="next"` header whenever a later page exists.
@@ -236,3 +236,26 @@ test("ensureBaseBranch: missing non-epic/* branch throws BaseBranchMustExistErro
   // A rejected non-epic/* base must never spawn a wrong-rooted branch.
   assertEquals(state.creates.length, 0);
 });
+
+// A `Depends-on:` ref that resolves to an issue (or a non-existent number) can never merge, so the
+// merge-poller's dependency gate must treat it as non-blocking rather than wedging forever — the
+// exact wedge behind Magikcraft/nano-bpm#806 declaring `Depends-on:` its epic tracking *issue*
+// #796. `isNotAPullRequestError` is the discriminator: it must fire for both transports' "not a PR"
+// signals and stay false for transient failures (which must keep the dependency blocking).
+test("isNotAPullRequestError: gh GraphQL 'not a PullRequest' → true", () => {
+  const err = new Error(
+    "GraphQL: Could not resolve to a PullRequest with the number of 796. (repository.pullRequest)",
+  );
+  assertEquals(isNotAPullRequestError(err), true);
+});
+
+test("isNotAPullRequestError: token-mode 404 → true", () => {
+  assertEquals(isNotAPullRequestError(new Error("github 404 Not Found")), true);
+});
+
+test("isNotAPullRequestError: transient failures stay blocking (false)", () => {
+  assertEquals(isNotAPullRequestError(new Error("github 502 Bad Gateway")), false);
+  assertEquals(isNotAPullRequestError(new Error("API rate limit exceeded")), false);
+  assertEquals(isNotAPullRequestError(new Error("fetch failed")), false);
+  assertEquals(isNotAPullRequestError(null), false);
+});

package/app/github.ts

@@ -496,6 +496,20 @@ function allCheckNames(rollup: RollupEntry[]): string[] {
   return names;
 }
 
+/** True when `err` is GitHub reporting that a ref which parsed as `owner/repo#N` is not a pull
+ * request — either it's an issue (issues and PRs share GitHub's number space, so an issue number
+ * is indistinguishable from a PR number by shape alone) or the number does not exist. Both
+ * transports surface here: `gh` mode throws the GraphQL message "Could not resolve to a
+ * PullRequest with the number of N", and token mode throws `github 404 …` from
+ * `GET /repos/{repo}/pulls/{N}`. A ref that is not a pull request can never merge, so a caller
+ * gating a merge queue on it (see `isDepMerged`) must treat it as non-blocking instead of wedging
+ * forever. Transient failures (rate-limit, 5xx, network) deliberately return `false` so the caller
+ * keeps waiting/retrying rather than silently clearing a real dependency. */
+export function isNotAPullRequestError(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /could not resolve to a pullrequest/i.test(msg) || /\bgithub 404\b/i.test(msg);
+}
+
 export async function fetchPrState(
   repo: string,
   number: number | string,

package/app/service.ts

@@ -20,6 +20,7 @@ import {
   fetchPrReviews,
   fetchPrState,
   hasPendingCopilotReviewer,
+  isNotAPullRequestError,
   type MergeMethod,
   type PrState,
   requestCopilotReview,
@@ -738,8 +739,23 @@ async function isDepMerged(data: DataLayer, depKey: string, token: string): Prom
   if (tracked && tracked.status === "merged") return true;
   const parsed = parsePr(depKey);
   if (!parsed) return true; // unparseable dep can't be checked on GitHub → treat as cleared so it never wedges the PR
-  const st = await fetchPrState(parsed.repo, parsed.number, token);
-  return st?.merged ?? false;
+  try {
+    const st = await fetchPrState(parsed.repo, parsed.number, token);
+    return st?.merged ?? false;
+  } catch (err) {
+    // A ref that GitHub cannot resolve to a *pull request* — it's an issue (issues and PRs share
+    // GitHub's number space) or the number doesn't exist — can never merge, so it cannot gate a
+    // merge queue. Treat it as cleared (non-blocking) rather than wedging the run at `wait-deps`
+    // forever, as happened when a PR body declared `Depends-on:` its epic tracking *issue*
+    // (Magikcraft/nano-bpm#806 → #796). Transient failures rethrow so the poller logs and retries.
+    if (isNotAPullRequestError(err)) {
+      console.warn(
+        `[poller] dep ${depKey} is not a mergeable pull request (issue or missing) — treating as non-blocking`,
+      );
+      return true;
+    }
+    throw err;
+  }
 }
 
 /** Flip a PR into the transient `merging` status and publish the correlating message, reverting

package/package.json

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