@nanobpm/nano-workforce 0.187.6 → 0.188.1

package/app/implementReconcile.test.ts

@@ -0,0 +1,166 @@
+// Red-first coverage for the implement-cell reconcile decision (issue #801) — the implement-stage twin
+// of #796. The defect: an implement-step that returns NO machine-readable `status` but has an OPEN PR
+// on its `feat/<task.id>` branch was dead-ended at a human escalation instead of adopting that PR and
+// converging. These tests pin the canonical `ic_reconcile_gw` decision that reconciles from GitHub
+// before escalating.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import type { HeadPr } from "./github.ts";
+import {
+  implementCellBranch,
+  pickAdoptablePr,
+  reconcileImplement,
+  shouldReconcileImplement,
+} from "./implementReconcile.ts";
+
+const openPr = (number: number, base = "main"): HeadPr => ({
+  number,
+  url: `https://github.com/owner/repo/pull/${number}`,
+  state: "open",
+  baseRef: base,
+});
+
+test("implementCellBranch: the deterministic feat/<task.id> branch", () => {
+  assertEquals(implementCellBranch("issue-796"), "feat/issue-796");
+});
+
+test("shouldReconcileImplement: only a blank/absent status reconciles", () => {
+  assertEquals(shouldReconcileImplement(null), true);
+  assertEquals(shouldReconcileImplement(undefined), true);
+  assertEquals(shouldReconcileImplement("  "), true);
+  assertEquals(shouldReconcileImplement("escalated"), false);
+  assertEquals(shouldReconcileImplement("opened"), false);
+});
+
+test("pickAdoptablePr: the first OPEN PR wins; merged/closed are not adoptable", () => {
+  assertEquals(pickAdoptablePr(null), null);
+  assertEquals(pickAdoptablePr([]), null);
+  assertEquals(pickAdoptablePr([{ ...openPr(1), state: "merged" }]), null);
+  assertEquals(pickAdoptablePr([{ ...openPr(2), state: "closed" }, openPr(3)])?.number, 3);
+});
+
+test("pickAdoptablePr: a known baseBranch adopts only an open PR that targets it", () => {
+  // Multiple open PRs from the same head branch to different bases — only the one matching the
+  // run's pinned base is adoptable; a stale/wrong-base PR (even if first) is never adopted.
+  const prs = [openPr(10, "old-epic-base"), openPr(11, "epic/feat-x")];
+  assertEquals(pickAdoptablePr(prs, "epic/feat-x")?.number, 11);
+  // No open PR targets the pinned base → nothing adoptable (escalate rather than converge the wrong PR).
+  assertEquals(pickAdoptablePr([openPr(12, "some-other-base")], "epic/feat-x"), null);
+  // Whitespace-only base is treated as "unknown" → first-open fallback.
+  assertEquals(pickAdoptablePr([openPr(13, "main")], "  ")?.number, 13);
+});
+
+// The core defect reproduction: blank status + an open PR on the branch → adopt & converge, no escalation.
+test("reconcileImplement: blank status + open PR on feat/<task.id> → adopt (status=opened, pr set)", async () => {
+  const calls: Array<{ repo: string; branch: string }> = [];
+  const lookup = async (repo: string, branch: string): Promise<HeadPr[]> => {
+    calls.push({ repo, branch });
+    return [openPr(800)];
+  };
+  const res = await reconcileImplement(
+    { status: null, subjectKey: "nanobpm/nano-workforce#796", taskId: "issue-796" },
+    lookup,
+    "token",
+  );
+  assertEquals(res, { reconciled: true, status: "opened", pr: "nanobpm/nano-workforce#800" });
+  assertEquals(calls, [{ repo: "nanobpm/nano-workforce", branch: "feat/issue-796" }]);
+});
+
+test("reconcileImplement: blank status but NO branch/PR → escalate (unchanged behaviour)", async () => {
+  const res = await reconcileImplement(
+    { status: null, subjectKey: "owner/repo#7", taskId: "issue-7" },
+    async () => [],
+    "token",
+  );
+  assertEquals(res, { reconciled: false, status: null, pr: null });
+});
+
+test("reconcileImplement: a genuine escalation status is honoured, GitHub never consulted", async () => {
+  let consulted = false;
+  const res = await reconcileImplement(
+    { status: "escalated", subjectKey: "owner/repo#7", taskId: "issue-7" },
+    async () => {
+      consulted = true;
+      return [openPr(9)];
+    },
+    "token",
+  );
+  assertEquals(res, { reconciled: false, status: "escalated", pr: null });
+  assertEquals(consulted, false);
+});
+
+test("reconcileImplement: only merged/closed PRs on the branch → escalate (nothing in-flight to adopt)", async () => {
+  const res = await reconcileImplement(
+    { status: null, subjectKey: "owner/repo#7", taskId: "issue-7" },
+    async () => [{ ...openPr(5), state: "merged" }],
+    "token",
+  );
+  assertEquals(res.reconciled, false);
+});
+
+test("reconcileImplement: a lookup transport failure falls through to escalate (best-effort)", async () => {
+  const res = await reconcileImplement(
+    { status: null, subjectKey: "owner/repo#7", taskId: "issue-7" },
+    async () => {
+      throw new Error("github 502");
+    },
+    "token",
+  );
+  assertEquals(res, { reconciled: false, status: null, pr: null });
+});
+
+test("reconcileImplement: an existing pr is carried through unchanged on fall-through (never wiped)", async () => {
+  // A genuine escalation status → escalate; any pr already in scope must survive the re-emit.
+  const escalated = await reconcileImplement(
+    { status: "escalated", subjectKey: "owner/repo#7", taskId: "issue-7", pr: "owner/repo#42" },
+    async () => [],
+    "token",
+  );
+  assertEquals(escalated, { reconciled: false, status: "escalated", pr: "owner/repo#42" });
+
+  // Blank status but no adoptable PR → escalate; an existing pr still survives.
+  const noAdopt = await reconcileImplement(
+    { status: null, subjectKey: "owner/repo#7", taskId: "issue-7", pr: "owner/repo#42" },
+    async () => [],
+    "token",
+  );
+  assertEquals(noAdopt, { reconciled: false, status: null, pr: "owner/repo#42" });
+});
+
+test("reconcileImplement: a successful adoption overwrites any existing pr with the adopted key", async () => {
+  const res = await reconcileImplement(
+    { status: null, subjectKey: "owner/repo#7", taskId: "issue-7", pr: "owner/repo#42" },
+    async () => [openPr(99)],
+    "token",
+  );
+  assertEquals(res, { reconciled: true, status: "opened", pr: "owner/repo#99" });
+});
+
+test("reconcileImplement: with a pinned baseBranch, only a PR targeting it is adopted", async () => {
+  // The head branch carries two open PRs to different bases — adopt the one matching the run's base.
+  const adopt = await reconcileImplement(
+    { status: null, subjectKey: "owner/repo#7", taskId: "issue-7", baseBranch: "epic/feat-x" },
+    async () => [openPr(50, "stale-base"), openPr(51, "epic/feat-x")],
+    "token",
+  );
+  assertEquals(adopt, { reconciled: true, status: "opened", pr: "owner/repo#51" });
+
+  // Only a wrong-base PR exists → escalate rather than converge the wrong branch.
+  const escalate = await reconcileImplement(
+    { status: null, subjectKey: "owner/repo#7", taskId: "issue-7", baseBranch: "epic/feat-x", pr: "owner/repo#42" },
+    async () => [openPr(52, "stale-base")],
+    "token",
+  );
+  assertEquals(escalate, { reconciled: false, status: null, pr: "owner/repo#42" });
+});
+
+test("reconcileImplement: a missing taskId or unparseable subjectKey → escalate, no lookup", async () => {
+  let consulted = false;
+  const lookup = async (): Promise<HeadPr[]> => {
+    consulted = true;
+    return [openPr(1)];
+  };
+  assertEquals((await reconcileImplement({ status: null, subjectKey: "owner/repo#7", taskId: null }, lookup, "t")).reconciled, false);
+  assertEquals((await reconcileImplement({ status: null, subjectKey: "not-a-key", taskId: "issue-7" }, lookup, "t")).reconciled, false);
+  assertEquals(consulted, false);
+});

package/app/implementReconcile.ts

@@ -0,0 +1,112 @@
+// Implement-step reconcile — reconcile the implement-cell result from GitHub BEFORE escalating to a
+// human (issue #801).
+//
+// The shared `implement-cell` (resources/processes/implement-cell.bpmn) routes ANY implement-step
+// outcome that is not a clean terminal (`opened`/`blocked`/`skipped`) to a human escalation. But a
+// harness that returns NO machine-readable result envelope (a blank/absent `status`) can still have
+// pushed the slice's branch and opened a green PR — a machine-observable, recoverable outcome the
+// escalation question literally asked a human to go and check (#796's implement-stage twin). Dead-
+// ending that at a person is the defect.
+//
+// This is the CANONICAL, pure decision for the cell's reconcile step: on a blank/absent `status`,
+// look for an OPEN PR opened from the cell's deterministic branch (`feat/<task.id>`, the agent-guide
+// convention every implement-cell caller shares — see resources/prompts/feature.md) and, when one
+// exists, ADOPT it (derive `status = "opened"` + a `pr` key) so the run converges exactly as if the
+// agent had reported it — no human escalation. Only when nothing is observable does the run escalate
+// as today. The GitHub read is injected (the canonical `listPrsForHead`) so this stays a pure,
+// exhaustively testable mirror of the `ic_reconcile_gw` gateway — no second GitHub reconciler.
+import type { HeadPr } from "./github.ts";
+import { parsePr } from "./prParse.ts";
+
+/** The escalate-arm inputs the reconcile step reads from the implement-cell scope. `subjectKey` is the
+ *  cell's `owner/repo#N` subject (a feature run's `feature_key`, or a wave slice's epic `plan_key`) —
+ *  its `owner/repo` half is the repository to look in. `taskId` is `task.id`, which fixes the
+ *  deterministic implement branch `feat/<task.id>`. `status` is the (blank, on this arm) implement-step
+ *  status. `pr` is any PR key already in scope (the implement harness may have set it) — carried through
+ *  unchanged on the non-adopt fall-through so re-emitting the output never wipes it. `baseBranch` is the
+ *  run's pinned base branch (the epic/graph integration branch every implement-cell caller maps into the
+ *  cell scope): when known, only a PR whose base matches it is adoptable, so a stale/unrelated PR sharing
+ *  the deterministic head branch but targeting a different base is never adopted. */
+export interface ReconcileImplementInput {
+  status: unknown;
+  subjectKey: unknown;
+  taskId: unknown;
+  pr?: unknown;
+  baseBranch?: unknown;
+}
+
+/** The reconcile decision. `reconciled` is the `ic_reconcile_gw` gate: true → adopt-and-converge (with
+ *  `status = "opened"` + `pr` set); false → escalate as today. `status`/`pr` are re-emitted so the
+ *  cell (and its caller) route on the adopted values. */
+export interface ReconcileImplementResult {
+  reconciled: boolean;
+  status: string | null;
+  pr: string | null;
+}
+
+/** The injected GitHub read — the canonical `listPrsForHead(repo, headBranch, token)` (so this module
+ *  never grows a second PR-lookup transport). */
+export type OpenPrLookup = (repo: string, branch: string, token: string) => Promise<HeadPr[] | null>;
+
+const str = (v: unknown): string | undefined =>
+  typeof v === "string" && v.trim().length > 0 ? v.trim() : undefined;
+
+/** Reconcile ONLY when the agent left no machine-readable status (blank/absent) — the #796/#801
+ *  no-result condition. A genuine escalation that carries its own status string is honoured (escalate),
+ *  never silently overridden by a branch PR that may be unrelated to the agent's question. */
+export function shouldReconcileImplement(status: unknown): boolean {
+  return str(status) === undefined;
+}
+
+/** The cell's deterministic implement branch — `feat/<task.id>` (resources/prompts/feature.md). */
+export function implementCellBranch(taskId: string): string {
+  return `feat/${taskId}`;
+}
+
+/** The adoptable PR from a head-branch listing: the first OPEN one (a merged/closed PR on the branch is
+ *  not an in-flight result to converge). When `baseBranch` is given, only an open PR whose `baseRef`
+ *  matches it is adoptable — GitHub can carry multiple open PRs from one head branch to different bases,
+ *  so adopting blind to the base could converge a stale/unrelated PR; with no base known, fall back to
+ *  the first open PR (unchanged best-effort behaviour). `null` when the listing is absent (no transport)
+ *  or has no adoptable PR. */
+export function pickAdoptablePr(prs: HeadPr[] | null, baseBranch?: string): HeadPr | null {
+  if (!prs) return null;
+  const open = prs.filter((p) => p.state === "open");
+  const base = typeof baseBranch === "string" ? baseBranch.trim() : "";
+  if (base) return open.find((p) => p.baseRef === base) ?? null;
+  return open[0] ?? null;
+}
+
+/** The canonical implement-cell reconcile decision (mirror of `ic_reconcile_gw`). Best-effort: any
+ *  missing input, unusable transport, or lookup failure falls through to `escalate` — never worse than
+ *  today's behaviour, and idempotent (a pure GitHub read that adopts the SAME open PR on a re-run, so
+ *  a re-dispatch never opens or double-adopts a second PR). */
+export async function reconcileImplement(
+  input: ReconcileImplementInput,
+  lookup: OpenPrLookup,
+  token: string,
+): Promise<ReconcileImplementResult> {
+  const escalate: ReconcileImplementResult = {
+    reconciled: false,
+    status: str(input.status) ?? null,
+    // Carry any existing PR key through unchanged — the reconcile step's `pr` output is mapped back
+    // into the process variable, so returning a bare `null` here would wipe a `pr` the implement
+    // harness already set. Only a successful adoption below overwrites it.
+    pr: str(input.pr) ?? null,
+  };
+  if (!shouldReconcileImplement(input.status)) return escalate;
+  const taskId = str(input.taskId);
+  // `subjectKey` shares the `owner/repo#N` shape parsePr validates; we use only its `repo` half.
+  const parsed = parsePr(input.subjectKey);
+  if (!taskId || !parsed) return escalate;
+  const branch = implementCellBranch(taskId);
+  let prs: HeadPr[] | null;
+  try {
+    prs = await lookup(parsed.repo, branch, token);
+  } catch {
+    return escalate; // transport hiccup → escalate as today
+  }
+  const adopt = pickAdoptablePr(prs, str(input.baseBranch));
+  if (!adopt) return escalate;
+  return { reconciled: true, status: "opened", pr: `${parsed.repo}#${adopt.number}` };
+}

package/app/service.test.ts

@@ -11,7 +11,7 @@ import { memDataFor } from "../test/worldDb.ts";
 import { withTrackingViews } from "../test/trackingViews.ts";
 import { DurableResumeRegistry } from "./durableResume.ts";
 import { WorldStore } from "./world/index.ts";
-import { abandonClosedPr, isPrSettled, parsePr, pollCapabilityGatesImpl, pollIncidentsImpl, pollWaveGatesImpl, repoEnvelopeVars, startMerge, submitPr, worldRestoreSha } from "./service.ts";
+import { abandonClosedPr, isPrSettled, MAX_ACK_RETRIES, parsePr, pollCapabilityGatesImpl, pollIncidentsImpl, pollWaveGatesImpl, repoEnvelopeVars, startMerge, submitPr, worldRestoreSha } from "./service.ts";
 import { trackingTargetFor } from "./instanceTracking.ts";
 import type { DataLayer } from "@nanobpm/urban";
 
@@ -378,6 +378,45 @@ test("submitPr defaults convergeOnly to false so the global auto-merge default g
   });
 });
 
+// #796 auto-ack budget seeding: `submitPr` is the ONLY production write that makes the retry budget
+// available to a fresh convergence instance — the engine behaviour tests seed `ackRetryRound` /
+// `ackRetryMax` directly and never exercise `submitPr`, so a regression dropping or misconfiguring
+// this seed would leave deployed loops on the escalation default while every added behaviour test
+// still passes. Assert both the initial counter and the configured max propagate onto the instance.
+function captureVars() {
+  const stores: Record<string, { rows: unknown[]; key: string }> = {
+    pull_requests: { rows: [], key: "pr_key" },
+    escalations: { rows: [], key: "id" },
+    pr_dependencies: { rows: [], key: "pr_key" },
+  };
+  const data = {
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+  } as any;
+  let captured: Record<string, unknown> | undefined;
+  const engine = {
+    createInstance: (req: { variables?: Record<string, unknown> }) => {
+      captured = req.variables;
+      return Promise.resolve({ processInstanceKey: "PI-1" });
+    },
+  } as any;
+  return { data, engine, get: () => captured };
+}
+
+test("submitPr seeds the #796 auto-ack budget onto the instance (ackRetryRound=0, ackRetryMax=MAX_ACK_RETRIES)", async () => {
+  await withGithubOff(async () => {
+    const { data, engine, get } = captureVars();
+    await submitPr(data, engine, {
+      repo: "owner/repo",
+      number: 10,
+      url: "https://github.com/owner/repo/pull/10",
+      prKey: "owner/repo#10",
+    });
+    const vars = get();
+    assertEquals(vars?.ackRetryRound, 0);
+    assertEquals(vars?.ackRetryMax, MAX_ACK_RETRIES);
+  });
+});
+
 // Lineage threading (issue #245): `submitPr` persists the origin `root_request_key` on the PR row
 // and carries it onto the convergence instance; `startMerge` reads it back off the row onto the
 // merge instance. A human/webhook submit that supplies no root self-roots on the `pr_key` (its own

package/app/service.ts

@@ -159,6 +159,20 @@ export const MAX_REBASE_ROUNDS = clampCiFixBudget(process.env.NANO_PR_MAX_REBASE
  * retry (a race escalates immediately). Reuses the CI-fix budget clamp (allows 0 = disable). */
 export const MAX_MERGE_RETRIES = clampCiFixBudget(process.env.NANO_PR_MAX_MERGE_RETRIES, 5);
 
+/** How many times the convergence loop will re-dispatch the `senior:pr-review` (review-round) agent
+ * to auto-ack unacked suppressed advisories before escalating to a human. When the converge-gate
+ * blocks SOLELY on unacknowledged suppressed advisories (no unresolved inline threads), the block is
+ * recoverable: re-running the review-round agent posts the missing `nano-ack:` threads and converges,
+ * so the loop tries that — bounded — before parking the human `wait-answer` (issue #796). A resolved
+ * `Declined … nano-ack:` advisory is an acknowledgement and CONVERGES (issue #787), so a decline does
+ * not escalate; only the agent returning `needs_input` (a genuinely contested advisory it cannot
+ * decide) or `blocked` (an external blocker it reports with a question — the `gw-status` arm at
+ * `convergence-loop.bpmn:442-443` routes both to `wait-answer`), or this budget being exhausted,
+ * escalates. Default 2; set
+ * `NANO_PR_MAX_ACK_RETRIES=0` to escalate on the first ack-only block. Reuses the CI-fix budget clamp
+ * (allows 0 = disable, ceiling-capped). */
+export const MAX_ACK_RETRIES = clampCiFixBudget(process.env.NANO_PR_MAX_ACK_RETRIES, 2);
+
 /** How many times the mergeable-wait timeout backstop (`merge-stall-probe`) will re-derive
  * mergeability from ground truth and re-arm the merge stage before giving up and escalating to a
  * human. Bounds the timer arm of the `gw-merge-wait` event-based gateway so a dead in-process poller
@@ -644,6 +658,11 @@ export async function submitPr(
       round: 1,
       maxRounds: clampRounds(maxRounds, MAX_ROUNDS),
       reviewWaitTimeout: REVIEW_WAIT_TIMEOUT,
+      // Bounded agent auto-ack (issue #796): the convergence loop re-dispatches the review-round
+      // agent up to `ackRetryMax` times to ack suppressed advisories when the converge-gate blocks
+      // solely on unacked ones, before escalating to a human. `ackRetryRound` counts those passes.
+      ackRetryRound: 0,
+      ackRetryMax: MAX_ACK_RETRIES,
       // Lineage (issue #245): carry the origin identity onto the convergence instance so every
       // descendant (and any message it correlates) is stitched back to the originating request.
       // A human/webhook PR that is its own root carries its own `pr_key` (never NULL — see above).

package/e2e/feature-run.e2e.ts

@@ -67,6 +67,7 @@ interface PrRow {
 describe("single-issue feature run (#172 — feature.bpmn)", () => {
   const savedEnv = new Map<string, string | undefined>();
   let restoreGithub: (() => void) | undefined;
+  const githubState = admitGithubState("owner/repo", "main");
 
   before(() => {
     for (const [k, v] of Object.entries(GITHUB_ENV_OVERRIDES)) {
@@ -75,7 +76,7 @@ describe("single-issue feature run (#172 — feature.bpmn)", () => {
     }
     // ADR 0003: `startFeature` + the `pr.ensure-base-branch` head task pass through base admission,
     // which reads/creates the base ref. Pin the hermetic `token` transport + fetch stub.
-    restoreGithub = installAdmitGithub(admitGithubState("owner/repo", "main"));
+    restoreGithub = installAdmitGithub(githubState);
   });
 
   after(() => {
@@ -331,6 +332,49 @@ describe("single-issue feature run (#172 — feature.bpmn)", () => {
     }
   });
 
+  test("reconcile before escalate: a no-status result with an open PR on the branch adopts & converges (issue #801)", async () => {
+    // The #796/#801 defect: a harness returns NO machine-readable status but has pushed the branch and
+    // opened a green PR. Instead of dead-ending at a human, the cell's reconcile step observes the open
+    // PR on `feat/<task.id>` (= `feat/issue-7`), adopts it (status=opened, prKey), and converges.
+    githubState.openPrs.set("feat/issue-7", { number: 801, base: "epic/e2e" });
+    try {
+      await withApp(
+        { "senior:feature": () => ({ summary: "opened a PR but reported no status" }) },
+        { baseBranch: "epic/e2e", converge: true },
+        async ({ app, featureKey }) => {
+          const flows = takenFlows(app);
+          assert.ok(
+            flows.includes("ic_reconcile_gw->ic_end"),
+            `the adopted PR routed straight to the cell's done end (flows: ${flows.join(", ")})`,
+          );
+          assert.ok(
+            !flows.includes("ic_reconcile_gw->record-escalation"),
+            "the run did NOT escalate to a human",
+          );
+          assert.ok(
+            flows.includes("gw-converge->converge"),
+            `the adopted PR was handed to the convergence loop (flows: ${flows.join(", ")})`,
+          );
+          const run = await featureRow(app, featureKey);
+          assert.equal(run.status, "converging", "the reconciled run settled at converging");
+          assert.equal(run.pr_key, "owner/repo#801", "the adopted PR key is recorded on the run");
+          const prs = await app.db.table<PrRow>("pull_requests", "pr_key").find({ pr_key: "owner/repo#801" });
+          assert.equal(prs.length, 1, "the adopted PR was enrolled into the convergence loop (submitPr)");
+
+          // A native user-task escalation was never parked — the machine-recoverable outcome was
+          // reconciled without pulling in a person.
+          const tasks = await app.engine.searchUserTasks({ rootProcessInstanceKey: run.process_key! });
+          assert.ok(
+            !tasks.some((t) => t.elementId === "escalation"),
+            "no human-escalation task was created for the adopted run",
+          );
+        },
+      );
+    } finally {
+      githubState.openPrs.delete("feat/issue-7");
+    }
+  });
+
   test("escalate + abandon: abandoning routes to record-feature (default flow)", async () => {
     await withApp(
       {

package/e2e/support/github-admit.ts

@@ -16,6 +16,10 @@ export interface AdmitGithubState {
   branches: Map<string, string>; // branch → head sha
   creates: { ref: string; sha: string }[];
   resets: string[]; // any PATCH/force-update on an existing ref (must stay empty)
+  /** Open PRs keyed by head branch (issue #801): the implement-cell reconcile step lists PRs for a
+   *  head via `listPrsForHead`. Empty by default → the pulls listing returns `[]` (no adoptable PR),
+   *  so suites that don't opt in keep exactly today's escalate behaviour. */
+  openPrs: Map<string, { number: number; base?: string }>;
 }
 
 /** Build a fresh admit-github state with the default branch pre-seeded with a HEAD sha so an
@@ -30,6 +34,7 @@ export function admitGithubState(
     branches: new Map([[defaultBranch, "0".repeat(40)]]),
     creates: [],
     resets: [],
+    openPrs: new Map(),
   };
 }
 
@@ -72,6 +77,24 @@ function admitFetch(state: AdmitGithubState) {
       state.resets.push(decodeURIComponent(path.split("/git/refs/heads/")[1] ?? ""));
       return Promise.resolve(json({ ok: true }));
     }
+    // GET /repos/{repo}/pulls?state=…&head=owner:branch → the open PRs for a head branch, as read by
+    // `listPrsForHead` (the implement-cell reconcile step, issue #801). Default empty state → `[]`.
+    if (method === "GET" && path === `/repos/${state.repo}/pulls`) {
+      const head = u.searchParams.get("head") ?? "";
+      const branch = head.includes(":") ? head.slice(head.indexOf(":") + 1) : head;
+      const hit = state.openPrs.get(branch);
+      if (!hit) return Promise.resolve(json([]));
+      return Promise.resolve(
+        json([
+          {
+            number: hit.number,
+            html_url: `https://github.com/${state.repo}/pull/${hit.number}`,
+            state: "open",
+            base: { ref: hit.base ?? state.defaultBranch },
+          },
+        ]),
+      );
+    }
     // Any other endpoint is a best-effort read the sealed transport used to skip → 404 (null).
     return Promise.resolve(new Response("Not Found", { status: 404 }));
   };

package/nano.app.json

@@ -239,6 +239,10 @@
     {
       "taskType": "pr.record-feature-implementing",
       "handler": "workers/record-feature-implementing/worker.ts"
+    },
+    {
+      "taskType": "pr.reconcile-implement",
+      "handler": "workers/reconcile-implement/worker.ts"
     }
   ],
   "externalTaskTypes": [

package/package.json

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