@nanobpm/nano-workforce 0.188.0 → 0.188.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.188.1](https://github.com/nanobpm/nano-workforce/compare/v0.188.0...v0.188.1) (2026-09-17)
+
+### Bug Fixes
+
+* **feature:** reconcile the implement-step result from GitHub before escalating ([#805](https://github.com/nanobpm/nano-workforce/issues/805)) ([7099c31](https://github.com/nanobpm/nano-workforce/commit/7099c31793a6dd4543fddd2494615b166241d302)), closes [#796](https://github.com/nanobpm/nano-workforce/issues/796) [#796](https://github.com/nanobpm/nano-workforce/issues/796) [#801](https://github.com/nanobpm/nano-workforce/issues/801)
+
 ## [0.188.0](https://github.com/nanobpm/nano-workforce/compare/v0.187.6...v0.188.0) (2026-09-17)
 
 ### Features

package/app/fineGrainedCells.test.ts

@@ -52,6 +52,29 @@ test("implement-cell runs the senior:feature loop and delegates escalation to th
   assert(/targetRef="implement-task"/.test(xml), "implement-cell loops the answer back into implement-task");
 });
 
+test("implement-cell reconciles from GitHub before escalating (issue #801)", () => {
+  const xml = flat("implement-cell");
+  // The escalate arm passes through the reconcile step BEFORE the human escalation recorder, so a
+  // machine-recoverable result (an open PR on the cell's branch) adopts-and-converges instead of
+  // dead-ending at a person.
+  assert(
+    /<zeebe:taskDefinition\b[^>]*\btype="pr.reconcile-implement"/.test(xml),
+    "implement-cell must reconcile via pr.reconcile-implement on the escalate arm",
+  );
+  assert(
+    /<bpmn:exclusiveGateway\b[^>]*\bid="ic_reconcile_gw"/.test(xml),
+    "implement-cell must gate the reconcile outcome (adopt vs escalate) on ic_reconcile_gw",
+  );
+  assert(
+    /<bpmn:sequenceFlow\b[^>]*\bid="ic_reconciled"[^>]*\btargetRef="ic_end"/.test(xml),
+    "a reconciled (adopted) PR routes straight to the cell's done end — no human escalation",
+  );
+  assert(
+    /<bpmn:sequenceFlow\b[^>]*\bid="ic_toRecordEscalation"[^>]*\btargetRef="record-escalation"/.test(xml),
+    "an unreconciled result still escalates through record-escalation",
+  );
+});
+
 test("converge-cell and merge-cell keep their engine-native handoff task types", () => {
   assert(/<zeebe:taskDefinition\b[^>]*\btype="pr.converge-feature"/.test(flat("converge-cell")), "converge-cell hands off via pr.converge-feature");
   assert(/<zeebe:taskDefinition\b[^>]*\btype="senior:trial-merge"/.test(flat("merge-cell")), "merge-cell runs the senior:trial-merge agent");

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/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.188.0",
+  "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",

package/resources/processes/feature.bpmn

@@ -174,6 +174,7 @@
         <zeebe:calledElement processId="implement-cell" />
         <zeebe:ioMapping>
           <zeebe:input source="=task" target="task" />
+          <zeebe:input source="=baseBranch" target="baseBranch" />
           <zeebe:input source="=if (is defined(baseBranchBrief)) then baseBranchBrief else null" target="baseBranchBrief" />
           <zeebe:input source="=if (is defined(resolvedArtifacts)) then resolvedArtifacts else null" target="resolvedArtifacts" />
           <zeebe:input source="=if (is defined(customInstructions)) then customInstructions else null" target="customInstructions" />

package/resources/processes/implement-cell.bpmn

@@ -37,6 +37,23 @@
       <bpmn:outgoing>ic_escalate</bpmn:outgoing>
       <bpmn:outgoing>ic_done</bpmn:outgoing>
     </bpmn:exclusiveGateway>
+    <bpmn:serviceTask id="reconcile-implement" name="Reconcile from GitHub">
+      <bpmn:extensionElements>
+        <zeebe:taskDefinition type="pr.reconcile-implement" />
+        <zeebe:ioMapping>
+          <zeebe:output source="=reconciled" target="reconciled" />
+          <zeebe:output source="=status" target="status" />
+          <zeebe:output source="=pr" target="pr" />
+        </zeebe:ioMapping>
+      </bpmn:extensionElements>
+      <bpmn:incoming>ic_escalate</bpmn:incoming>
+      <bpmn:outgoing>ic_toReconcileGw</bpmn:outgoing>
+    </bpmn:serviceTask>
+    <bpmn:exclusiveGateway id="ic_reconcile_gw" name="reconciled?" default="ic_toRecordEscalation">
+      <bpmn:incoming>ic_toReconcileGw</bpmn:incoming>
+      <bpmn:outgoing>ic_reconciled</bpmn:outgoing>
+      <bpmn:outgoing>ic_toRecordEscalation</bpmn:outgoing>
+    </bpmn:exclusiveGateway>
     <bpmn:callActivity id="escalate" name="Human escalation">
       <bpmn:extensionElements>
         <zeebe:calledElement processId="human-escalation" />
@@ -61,7 +78,7 @@
           <zeebe:output source="=question" target="question" />
         </zeebe:ioMapping>
       </bpmn:extensionElements>
-      <bpmn:incoming>ic_escalate</bpmn:incoming>
+      <bpmn:incoming>ic_toRecordEscalation</bpmn:incoming>
       <bpmn:outgoing>ic_toEscalate</bpmn:outgoing>
     </bpmn:serviceTask>
     <bpmn:exclusiveGateway id="ic_gw_answer" name="answer?" default="ic_abandon">
@@ -81,6 +98,7 @@
     </bpmn:serviceTask>
     <bpmn:endEvent id="ic_end" name="Task done">
       <bpmn:incoming>ic_done</bpmn:incoming>
+      <bpmn:incoming>ic_reconciled</bpmn:incoming>
       <bpmn:incoming>ic_abandon</bpmn:incoming>
     </bpmn:endEvent>
     <bpmn:sequenceFlow id="ic_toImplement" sourceRef="Start" targetRef="implement-task" />
@@ -88,7 +106,12 @@
     <bpmn:sequenceFlow id="ic_done" name="done" sourceRef="ic_gw" targetRef="ic_end">
       <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=status = "opened" or status = "blocked" or status = "skipped"</bpmn:conditionExpression>
     </bpmn:sequenceFlow>
-    <bpmn:sequenceFlow id="ic_escalate" name="escalated" sourceRef="ic_gw" targetRef="record-escalation" />
+    <bpmn:sequenceFlow id="ic_escalate" name="reconcile" sourceRef="ic_gw" targetRef="reconcile-implement" />
+    <bpmn:sequenceFlow id="ic_toReconcileGw" sourceRef="reconcile-implement" targetRef="ic_reconcile_gw" />
+    <bpmn:sequenceFlow id="ic_reconciled" name="adopted" sourceRef="ic_reconcile_gw" targetRef="ic_end">
+      <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=reconciled = true</bpmn:conditionExpression>
+    </bpmn:sequenceFlow>
+    <bpmn:sequenceFlow id="ic_toRecordEscalation" name="escalated" sourceRef="ic_reconcile_gw" targetRef="record-escalation" />
     <bpmn:sequenceFlow id="ic_toEscalate" sourceRef="record-escalation" targetRef="escalate" />
     <bpmn:sequenceFlow id="ic_toAnswerGw" sourceRef="escalate" targetRef="ic_gw_answer" />
     <bpmn:sequenceFlow id="ic_answerLoop" name="answer" sourceRef="ic_gw_answer" targetRef="record-implementing">
@@ -114,25 +137,34 @@
           <dc:Bounds x="406" y="62" width="70" height="28" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="BPMNShape_reconcile-implement" bpmnElement="reconcile-implement">
+        <dc:Bounds x="566" y="80" width="100" height="80" />
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="BPMNShape_ic_reconcile_gw" bpmnElement="ic_reconcile_gw" isMarkerVisible="true">
+        <dc:Bounds x="766" y="95" width="50" height="50" />
+        <bpmndi:BPMNLabel>
+          <dc:Bounds x="751" y="76" width="81" height="14" />
+        </bpmndi:BPMNLabel>
+      </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_escalate" bpmnElement="escalate">
-        <dc:Bounds x="766" y="80" width="100" height="80" />
+        <dc:Bounds x="1116" y="80" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_record-escalation" bpmnElement="record-escalation">
-        <dc:Bounds x="566" y="80" width="100" height="80" />
+        <dc:Bounds x="916" y="80" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_ic_gw_answer" bpmnElement="ic_gw_answer" isMarkerVisible="true">
-        <dc:Bounds x="966" y="95" width="50" height="50" />
+        <dc:Bounds x="1316" y="95" width="50" height="50" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="963" y="76" width="56" height="14" />
+          <dc:Bounds x="1313" y="76" width="56" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_record-implementing" bpmnElement="record-implementing">
-        <dc:Bounds x="1116" y="240" width="100" height="80" />
+        <dc:Bounds x="1466" y="240" width="100" height="80" />
       </bpmndi:BPMNShape>
       <bpmndi:BPMNShape id="BPMNShape_ic_end" bpmnElement="ic_end">
-        <dc:Bounds x="1148" y="102" width="36" height="36" />
+        <dc:Bounds x="1498" y="102" width="36" height="36" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1133" y="83" width="66" height="14" />
+          <dc:Bounds x="1483" y="83" width="66" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNShape>
       <bpmndi:BPMNEdge id="BPMNEdge_ic_toImplement" bpmnElement="ic_toImplement">
@@ -150,41 +182,61 @@
           <dc:Bounds x="483" y="128" width="67" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
-      <bpmndi:BPMNEdge id="BPMNEdge_ic_toEscalate" bpmnElement="ic_toEscalate">
+      <bpmndi:BPMNEdge id="BPMNEdge_ic_toReconcileGw" bpmnElement="ic_toReconcileGw">
         <di:waypoint x="666" y="120" />
         <di:waypoint x="766" y="120" />
       </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_ic_toRecordEscalation" bpmnElement="ic_toRecordEscalation">
+        <di:waypoint x="816" y="120" />
+        <di:waypoint x="916" y="120" />
+        <bpmndi:BPMNLabel>
+          <dc:Bounds x="833" y="128" width="67" height="14" />
+        </bpmndi:BPMNLabel>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_ic_toEscalate" bpmnElement="ic_toEscalate">
+        <di:waypoint x="1016" y="120" />
+        <di:waypoint x="1116" y="120" />
+      </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_ic_toAnswerGw" bpmnElement="ic_toAnswerGw">
-        <di:waypoint x="866" y="120" />
-        <di:waypoint x="966" y="120" />
+        <di:waypoint x="1216" y="120" />
+        <di:waypoint x="1316" y="120" />
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_ic_abandon" bpmnElement="ic_abandon">
-        <di:waypoint x="1016" y="120" />
-        <di:waypoint x="1148" y="120" />
+        <di:waypoint x="1366" y="120" />
+        <di:waypoint x="1498" y="120" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="1056" y="98" width="53" height="14" />
+          <dc:Bounds x="1406" y="98" width="53" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_ic_answerLoop" bpmnElement="ic_answerLoop">
-        <di:waypoint x="991" y="145" />
-        <di:waypoint x="991" y="280" />
-        <di:waypoint x="1116" y="280" />
+        <di:waypoint x="1341" y="145" />
+        <di:waypoint x="1341" y="280" />
+        <di:waypoint x="1466" y="280" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="996" y="206" width="49" height="14" />
+          <dc:Bounds x="1346" y="206" width="49" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_ic_done" bpmnElement="ic_done">
         <di:waypoint x="441" y="145" />
-        <di:waypoint x="441" y="180" />
-        <di:waypoint x="1166" y="180" />
-        <di:waypoint x="1166" y="138" />
+        <di:waypoint x="441" y="200" />
+        <di:waypoint x="1516" y="200" />
+        <di:waypoint x="1516" y="138" />
+        <bpmndi:BPMNLabel>
+          <dc:Bounds x="963" y="208" width="32" height="14" />
+        </bpmndi:BPMNLabel>
+      </bpmndi:BPMNEdge>
+      <bpmndi:BPMNEdge id="BPMNEdge_ic_reconciled" bpmnElement="ic_reconciled">
+        <di:waypoint x="791" y="145" />
+        <di:waypoint x="791" y="180" />
+        <di:waypoint x="1516" y="180" />
+        <di:waypoint x="1516" y="138" />
         <bpmndi:BPMNLabel>
-          <dc:Bounds x="788" y="188" width="32" height="14" />
+          <dc:Bounds x="1047" y="158" width="53" height="14" />
         </bpmndi:BPMNLabel>
       </bpmndi:BPMNEdge>
       <bpmndi:BPMNEdge id="BPMNEdge_ic_reImplement" bpmnElement="ic_reImplement">
-        <di:waypoint x="1166" y="320" />
-        <di:waypoint x="1166" y="340" />
+        <di:waypoint x="1516" y="320" />
+        <di:waypoint x="1516" y="340" />
         <di:waypoint x="266" y="340" />
         <di:waypoint x="266" y="160" />
       </bpmndi:BPMNEdge>

package/resources/processes/plan-fanout.bpmn

@@ -443,6 +443,7 @@
           <zeebe:ioMapping>
             <zeebe:input source="=task" target="task" />
             <zeebe:input source="=planKey" target="subjectKey" />
+            <zeebe:input source="=baseBranch" target="baseBranch" />
             <zeebe:input source="=escalationSlaTimeout" target="escalationSlaTimeout" />
             <zeebe:input source="=if (is defined(escalationAssignee)) then escalationAssignee else null" target="escalationAssignee" />
             <zeebe:input source="=if (is defined(baseBranchBrief)) then baseBranchBrief else null" target="baseBranchBrief" />

package/workers/reconcile-implement/worker.test.ts

@@ -0,0 +1,87 @@
+// Unit coverage for pr.reconcile-implement — the implement-cell's reconcile-before-escalate step
+// (issue #801). It wraps the canonical `reconcileImplement` decision with the injected GitHub read;
+// here we assert the handler wires job variables through and re-emits the decision (the gate variable
+// `reconciled` plus the adopted `status`/`pr`). The decision logic itself is exhaustively covered in
+// app/implementReconcile.test.ts.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import { noopLog } from "../../test/log.ts";
+import handler from "./worker.ts";
+
+// biome-ignore lint/suspicious/noExplicitAny: tiny app double — the handler only touches app.log.
+const fakeApp: any = { log: noopLog() };
+
+test("adopts an open PR on the branch: emits reconciled + status=opened + pr", async () => {
+  const prevToken = process.env.GITHUB_TOKEN;
+  const prevTransport = process.env.NANO_PR_GITHUB_TRANSPORT;
+  const prevFetch = globalThis.fetch;
+  process.env.GITHUB_TOKEN = "t";
+  process.env.NANO_PR_GITHUB_TRANSPORT = "token";
+  // Token transport (never shells out to `gh`): stub the pulls listing so `listPrsForHead` returns one
+  // open PR opened from `feat/issue-801`.
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify([{ number: 801, html_url: "https://github.com/owner/repo/pull/801", state: "open", base: { ref: "main" } }]), {
+      status: 200,
+    })) as typeof fetch;
+  try {
+    const out = await handler(
+      { jobKey: "j1", variables: { subjectKey: "owner/repo#801", task: { id: "issue-801" }, status: null } } as never,
+      fakeApp,
+    );
+    assertEquals(out, { reconciled: true, status: "opened", pr: "owner/repo#801" });
+  } finally {
+    globalThis.fetch = prevFetch;
+    if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
+    else process.env.GITHUB_TOKEN = prevToken;
+    if (prevTransport === undefined) delete process.env.NANO_PR_GITHUB_TRANSPORT;
+    else process.env.NANO_PR_GITHUB_TRANSPORT = prevTransport;
+  }
+});
+
+test("wires baseBranch through: a wrong-base open PR is NOT adopted → escalate", async () => {
+  const prevToken = process.env.GITHUB_TOKEN;
+  const prevTransport = process.env.NANO_PR_GITHUB_TRANSPORT;
+  const prevFetch = globalThis.fetch;
+  process.env.GITHUB_TOKEN = "t";
+  process.env.NANO_PR_GITHUB_TRANSPORT = "token";
+  // The only open PR on the head branch targets a different base than the run's pinned `baseBranch`.
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify([{ number: 55, html_url: "https://github.com/owner/repo/pull/55", state: "open", base: { ref: "stale-base" } }]), {
+      status: 200,
+    })) as typeof fetch;
+  try {
+    const out = await handler(
+      { jobKey: "j3", variables: { subjectKey: "owner/repo#7", task: { id: "issue-7" }, status: null, baseBranch: "epic/feat-x" } } as never,
+      fakeApp,
+    );
+    assertEquals(out, { reconciled: false, status: null, pr: null });
+  } finally {
+    globalThis.fetch = prevFetch;
+    if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
+    else process.env.GITHUB_TOKEN = prevToken;
+    if (prevTransport === undefined) delete process.env.NANO_PR_GITHUB_TRANSPORT;
+    else process.env.NANO_PR_GITHUB_TRANSPORT = prevTransport;
+  }
+});
+
+test("no open PR on the branch: falls through to escalate (reconciled=false)", async () => {
+  const prevToken = process.env.GITHUB_TOKEN;
+  const prevTransport = process.env.NANO_PR_GITHUB_TRANSPORT;
+  const prevFetch = globalThis.fetch;
+  process.env.GITHUB_TOKEN = "t";
+  process.env.NANO_PR_GITHUB_TRANSPORT = "token";
+  globalThis.fetch = (async () => new Response(JSON.stringify([]), { status: 200 })) as typeof fetch;
+  try {
+    const out = await handler(
+      { jobKey: "j2", variables: { subjectKey: "owner/repo#7", task: { id: "issue-7" }, status: null } } as never,
+      fakeApp,
+    );
+    assertEquals(out, { reconciled: false, status: null, pr: null });
+  } finally {
+    globalThis.fetch = prevFetch;
+    if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
+    else process.env.GITHUB_TOKEN = prevToken;
+    if (prevTransport === undefined) delete process.env.NANO_PR_GITHUB_TRANSPORT;
+    else process.env.NANO_PR_GITHUB_TRANSPORT = prevTransport;
+  }
+});

package/workers/reconcile-implement/worker.ts

@@ -0,0 +1,60 @@
+// pr.reconcile-implement — reconcile the implement-cell result from GitHub before escalating (issue #801).
+//
+// Runs on the shared `implement-cell`'s escalate arm (`ic_gw` "clean terminal?" → here), IMMEDIATELY
+// before the human escalation, for EVERY caller that composes the cell: a standalone `feature` run and
+// a plan-fanout wave slice. When the implement step returned no machine-readable `status` (a harness
+// that opened a green PR but reported nothing — #796's implement-stage twin), it looks for an OPEN PR
+// on the cell's deterministic `feat/<task.id>` branch and, when one exists, ADOPTS it — emitting
+// `reconciled = true` (the `ic_reconcile_gw` gate routes straight to the cell's done end) plus
+// `status = "opened"` and a `pr` key so the caller converges the adopted PR exactly as if the agent
+// had reported it. Only when nothing is observable does it fall through (`reconciled = false`) to the
+// human escalation as today.
+//
+// The decision + the injected GitHub read (`listPrsForHead`) live in the canonical, exhaustively
+// tested `app/implementReconcile.ts` mirror — this handler is the thin engine seam. `taskId` is
+// derived from the in-scope `task` process variable (`task.id`) — `implement-cell.bpmn` defines no
+// `<zeebe:ioMapping>` input for this step; the engine populates `task` (and `subjectKey`, `status`,
+// `pr`, `baseBranch`) from process scope. `pr` is passed through so the reconcile step's `pr` output
+// never wipes a PR key the implement harness already set. `baseBranch` (the run's pinned base) is
+// passed through so an open PR on the deterministic head branch is only adopted when it targets that
+// base — never a stale/unrelated PR sharing the head branch but aimed at a different base.
+import type { AppJobHandler } from "@nanobpm/urban";
+import { listPrsForHead } from "../../app/github.ts";
+import { type ReconcileImplementResult, reconcileImplement } from "../../app/implementReconcile.ts";
+
+interface In extends Record<string, unknown> {
+  subjectKey?: unknown;
+  task?: unknown;
+  status?: unknown;
+  pr?: unknown;
+  baseBranch?: unknown;
+}
+
+/** The cell's deterministic branch is `feat/<task.id>`; `task` is the implement-cell's slice object.
+ *  Read it defensively (the process variable is untyped at the engine seam). */
+function taskId(task: unknown): unknown {
+  if (task !== null && typeof task === "object" && "id" in task) return task.id;
+  return undefined;
+}
+
+const handler: AppJobHandler<In, ReconcileImplementResult> = async (job, app) => {
+  const res = await reconcileImplement(
+    {
+      status: job.variables.status,
+      subjectKey: job.variables.subjectKey,
+      taskId: taskId(job.variables.task),
+      pr: job.variables.pr,
+      baseBranch: job.variables.baseBranch,
+    },
+    listPrsForHead,
+    process.env.GITHUB_TOKEN ?? "",
+  );
+  app.log.info("reconcile-implement", {
+    subjectKey: job.variables.subjectKey ?? null,
+    reconciled: res.reconciled,
+    pr: res.pr,
+  });
+  return res;
+};
+
+export default handler;