@nanobpm/nano-workforce 0.206.4 → 0.208.0

package/app/service.test.ts

@@ -675,6 +675,123 @@ test("pollIncidents picks the oldest incident by creationTime, sorting a missing
   assertEquals(row.incident_message, "the first fault");
 });
 
+// Issue #931: the mirror must carry the incident's `errorType` and `creationTime` (not just key +
+// message) so `/status` can show WHAT broke and SINCE WHEN, and it must cover a delivery-graph
+// run's instance too — a delivery parked on an engine incident was just as invisible as a PR.
+test("pollIncidents mirrors errorType + creationTime alongside the key/message, and clears them with the incident", async () => {
+  const row = {
+    pr_key: "owner/repo#12",
+    status: "converging",
+    process_key: "PI-12",
+    incident_key: null as string | null,
+    incident_type: null as string | null,
+    incident_message: null as string | null,
+    incident_since: null as string | null,
+    updated_at: "t0",
+  };
+  const stores: Record<string, { rows: unknown[]; key: string }> = {
+    pull_requests: { rows: [row], key: "pr_key" },
+  };
+  const data = {
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
+  } as any;
+  const headers = { "content-type": "application/json" };
+
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = incidentFetch({
+    "PI-12": [{
+      incidentKey: "598235",
+      errorType: "JOB_NO_RETRIES",
+      errorMessage: 'agent "nano-coder" failed: no output and no subtree progress for >= 300000ms (idle)',
+      state: "ACTIVE",
+      creationTime: "2026-11-09T01:00:00.000Z",
+    }],
+  }) as typeof fetch;
+  try {
+    await pollIncidentsImpl(data, "http://engine/v2", headers);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(row.incident_key, "598235");
+  assertEquals(row.incident_type, "JOB_NO_RETRIES");
+  assertEquals(row.incident_message, 'agent "nano-coder" failed: no output and no subtree progress for >= 300000ms (idle)');
+  assertEquals(row.incident_since, "2026-11-09T01:00:00.000Z");
+  assertEquals(row.status, "converging"); // orthogonal: the workflow transient is never touched
+
+  // Once resolved, ALL FOUR columns clear idempotently — a stale `incident_since` must not linger.
+  globalThis.fetch = incidentFetch({ "PI-12": [] }) as typeof fetch;
+  try {
+    await pollIncidentsImpl(data, "http://engine/v2", headers);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(row.incident_key, null);
+  assertEquals(row.incident_type, null);
+  assertEquals(row.incident_message, null);
+  assertEquals(row.incident_since, null);
+});
+
+test("pollIncidents mirrors an ACTIVE incident onto a delivery-graph run row, and skips a terminal run", async () => {
+  const running = {
+    run_key: "dg-1",
+    status: "running",
+    process_key: "PI-DG-1",
+    incident_key: null as string | null,
+    incident_type: null as string | null,
+    incident_message: null as string | null,
+    incident_since: null as string | null,
+    updated_at: "t0",
+  };
+  const done = {
+    run_key: "dg-2",
+    status: "done",
+    process_key: "PI-DG-2",
+    incident_key: "STALE-DG",
+    incident_type: "JOB_NO_RETRIES",
+    incident_message: "left over",
+    incident_since: "2026-11-08T00:00:00.000Z",
+    updated_at: "t0",
+  };
+  const stores: Record<string, { rows: unknown[]; key: string }> = {
+    delivery_graph_runs: { rows: [running, done], key: "run_key" },
+  };
+  const data = {
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
+  } as any;
+  const headers = { "content-type": "application/json" };
+
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = incidentFetch({
+    "PI-DG-1": [{
+      incidentKey: "INC-DG-1",
+      errorType: "JOB_NO_RETRIES",
+      errorMessage: "delivery node job exhausted retries",
+      state: "ACTIVE",
+      creationTime: "2026-11-09T03:00:00.000Z",
+    }],
+    // A terminal run's instance is gone — the pass must never query it (the stub would serve an
+    // incident, so a query would wrongly overwrite the clearing below).
+    "PI-DG-2": [{ incidentKey: "INC-DG-2", errorMessage: "ghost", state: "ACTIVE", creationTime: "2026-11-09T04:00:00.000Z" }],
+  }) as typeof fetch;
+  try {
+    await pollIncidentsImpl(data, "http://engine/v2", headers);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(running.incident_key, "INC-DG-1");
+  assertEquals(running.incident_type, "JOB_NO_RETRIES");
+  assertEquals(running.incident_message, "delivery node job exhausted retries");
+  assertEquals(running.incident_since, "2026-11-09T03:00:00.000Z");
+  assertEquals(running.status, "running"); // orthogonal: status untouched
+  // Terminal run: the stale incident is cleared without ever consulting the engine.
+  assertEquals(done.incident_key, null);
+  assertEquals(done.incident_type, null);
+  assertEquals(done.incident_message, null);
+  assertEquals(done.incident_since, null);
+});
+
 
 // Red/green regression (nano-workforce#845 Copilot review): the convergence loop runs TWO external
 // agent task types while the PR reads `converging` — `review-round` (`senior:pr-review`) and, since
@@ -2446,3 +2563,152 @@ test("pollCapabilityGatesImpl: scopes the barrier subscription search server-sid
   assertEquals(published.length, 1, "the scoped search still finds THIS task's subscription and releases it");
   assertEquals(published[0]?.correlationKey, barrierKey);
 });
+
+// Issue #939: the merge loop hands a PR with head-current review findings back to convergence via
+// `submitPr`. The OWNING merge-loop instance (the row's `process_key`) is live while it calls, so the
+// hand-off must bypass the alreadyRunning gate — but ONLY for that exact owner; any other caller still
+// dedupes against the live merge loop.
+test("submitPr handoffFrom: only the owning merge-loop instance may re-enter convergence (#939)", async () => {
+  await withGithubOff(async () => {
+    const PR_KEY = "owner/repo#77";
+    const mk = () => {
+      const stores: Record<string, { rows: any[]; key: string }> = {
+        pull_requests: {
+          rows: [{ pr_key: PR_KEY, repo: "owner/repo", number: 77, url: "https://github.com/owner/repo/pull/77", title: "t", status: "waiting_merge", current_round: 4, process_key: "PI-MERGE" }],
+          key: "pr_key",
+        },
+        escalations: { rows: [], key: "id" },
+        pr_adjudications: { 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)), open: () => memOpen(stores) } as any;
+      return { stores, data };
+    };
+    let calls = 0;
+    const engine = { createInstance: async () => ({ processInstanceKey: `PI-CONV-${++calls}` }) } as any;
+    const parsed = { repo: "owner/repo", number: 77, url: "https://github.com/owner/repo/pull/77", prKey: PR_KEY };
+
+    const a = mk();
+    const plain = await submitPr(a.data, engine, parsed);
+    assertEquals((plain as any).alreadyRunning, true, "a plain submit dedupes against the live merge loop");
+    const foreign = await submitPr(a.data, engine, parsed, [], undefined, false, null, false, false, true, "PI-OTHER");
+    assertEquals((foreign as any).alreadyRunning, true, "a non-owner hand-off still dedupes");
+    assertEquals(calls, 0);
+
+    const owned = await submitPr(a.data, engine, parsed, [], undefined, false, null, false, false, true, "PI-MERGE");
+    assertEquals((owned as any).alreadyRunning, undefined);
+    assertEquals(calls, 1);
+    const row = a.stores.pull_requests.rows[0];
+    assertEquals(row.status, "converging");
+    assertEquals(row.process_key, "PI-CONV-1");
+  });
+});
+
+// Issue #941 review: a redelivered `pr.reconverge` can arrive AFTER its successor has already
+// settled the PR (merged/abandoned). The stale job still carries the OLD merge-loop instance key as
+// `handoffFrom`, and the settled row's `process_key` still names that same instance, so an owner
+// match ALONE would let the bypass treat the dead job as the row's live owner and restart
+// convergence, clearing the settled state. The internal hand-off channel is fenced against a
+// TERMINAL row outright: it dedupes idempotently and never resubmits. Only a DELIBERATE PUBLIC
+// submission (no `handoffFrom`) may re-open a settled PR.
+test("submitPr handoffFrom: a stale hand-off against a settled row is fenced, a public resubmit still re-opens (#941)", async () => {
+  await withGithubOff(async () => {
+    const PR_KEY = "owner/repo#78";
+    const mk = () => {
+      const stores: Record<string, { rows: any[]; key: string }> = {
+        pull_requests: {
+          // The successor convergence run MERGED the PR; the row is terminal (`merged`) but its
+          // `process_key` still names the OLD merge-loop instance the redelivered job belongs to.
+          rows: [{ pr_key: PR_KEY, repo: "owner/repo", number: 78, url: "https://github.com/owner/repo/pull/78", title: "t", status: "merged", current_round: 5, process_key: "PI-MERGE" }],
+          key: "pr_key",
+        },
+        escalations: { rows: [], key: "id" },
+        pr_adjudications: { 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)), open: () => memOpen(stores) } as any;
+      return { stores, data };
+    };
+    const parsed = { repo: "owner/repo", number: 78, url: "https://github.com/owner/repo/pull/78", prKey: PR_KEY };
+
+    // The stale hand-off (owner key matches, but the row is terminal) is FENCED: it dedupes
+    // idempotently, mints no instance, and leaves the settled row byte-for-byte untouched.
+    const a = mk();
+    let calls = 0;
+    const engine = { createInstance: async () => ({ processInstanceKey: `PI-CONV-${++calls}` }) } as any;
+    const stale = await submitPr(a.data, engine, parsed, [], undefined, false, null, false, false, true, "PI-MERGE");
+    assertEquals((stale as any).alreadyRunning, true, "a stale hand-off against a terminal row dedupes instead of re-entering convergence");
+    assertEquals(calls, 0, "no fresh instance is minted for the stale hand-off");
+    assertEquals(a.stores.pull_requests.rows[0].status, "merged", "the settled row's state is untouched");
+    assertEquals(a.stores.pull_requests.rows[0].process_key, "PI-MERGE", "the settled row's owner is untouched");
+
+    // A deliberate PUBLIC resubmission of the same settled PR (no handoffFrom) still re-opens it —
+    // the fence only closes the internal hand-off channel, never the terminal→resubmittable path.
+    const b = mk();
+    const resubmit = await submitPr(b.data, engine, parsed);
+    assertEquals((resubmit as any).alreadyRunning, undefined);
+    assertEquals(calls, 1);
+    assertEquals(b.stores.pull_requests.rows[0].status, "converging");
+    assertEquals(b.stores.pull_requests.rows[0].process_key, "PI-CONV-1");
+  });
+});
+
+// Issue #941 review: if the adjudication reset fails AFTER the atomic reopen advanced `process_key`
+// to the new convergence instance, the rollback cancels that instance — but leaving its key on the
+// row would make the cancelled run the row's "owner". Once tracking derives `abandoned`, the stale
+// hand-off fence would treat the reconverge retry as settled and end the merge loop with no live
+// convergence owner. The rollback must RESTORE the prior row (owner key + status), so the retry is
+// still the owning hand-off and re-enters convergence.
+test("submitPr handoffFrom: a failed reset restores the prior owner so the hand-off retry re-enters (#941)", async () => {
+  await withGithubOff(async () => {
+    const PR_KEY = "owner/repo#79";
+    const stores: Record<string, { rows: any[]; key: string }> = {
+      pull_requests: {
+        rows: [{ pr_key: PR_KEY, repo: "owner/repo", number: 79, url: "https://github.com/owner/repo/pull/79", title: "t", status: "waiting_merge", current_round: 4, process_key: "PI-MERGE" }],
+        key: "pr_key",
+      },
+      escalations: { rows: [], key: "id" },
+      pr_adjudications: { rows: [], key: "id" },
+      pr_dependencies: { rows: [], key: "pr_key" },
+    };
+    let failReset = true;
+    const open = () => {
+      const real = memOpen(stores);
+      return {
+        ...real,
+        exec: async (sql: string, ...rest: unknown[]) => {
+          if (failReset && /DELETE FROM "pr_adjudications"/.test(sql)) throw new Error("boom: reset failed");
+          return (real as any).exec(sql, ...rest);
+        },
+      };
+    };
+    const data = { table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)), open } as any;
+    let calls = 0;
+    const cancelled: string[] = [];
+    const engine = {
+      createInstance: async () => ({ processInstanceKey: `PI-CONV-${++calls}` }),
+      cancelInstance: async (i: { processInstanceKey: string }) => {
+        cancelled.push(i.processInstanceKey);
+      },
+    } as any;
+    const parsed = { repo: "owner/repo", number: 79, url: "https://github.com/owner/repo/pull/79", prKey: PR_KEY };
+
+    let threw = false;
+    try {
+      await submitPr(data, engine, parsed, [], undefined, false, null, false, false, true, "PI-MERGE");
+    } catch {
+      threw = true;
+    }
+    assertEquals(threw, true);
+    assertEquals(cancelled, ["PI-CONV-1"]);
+    const row = stores.pull_requests.rows[0];
+    assertEquals(row.process_key, "PI-MERGE", "rollback restores the prior owner, never leaves the cancelled key");
+    assertEquals(row.status, "waiting_merge", "rollback restores the prior status");
+    assertEquals(row.current_round, 4);
+
+    failReset = false;
+    const retry = await submitPr(data, engine, parsed, [], undefined, false, null, false, false, true, "PI-MERGE");
+    assertEquals((retry as any).alreadyRunning, undefined, "the retried hand-off re-enters convergence");
+    assertEquals(stores.pull_requests.rows[0].process_key, "PI-CONV-2");
+  });
+});