@nanobpm/nano-workforce 0.189.0 → 0.189.1

package/app/convergenceAdjudicationResume.test.ts

@@ -0,0 +1,274 @@
+// Red/green regression for issue #806 — the convergence loop must not re-escalate an already-answered
+// `wait-answer` question. When a durable adjudication exists for (this PR, this question fingerprint),
+// the poller (`pollUserTasks`) auto-resumes the parked `wait-answer` with the recorded answer through
+// the SAME `completeEscalationAsHuman` door a human uses — attributed to the prior adjudicator —
+// instead of re-parking a human (PR #800 / proc 46310: the same design question escalated at round 2
+// and again at round 13, both answered identically).
+//
+// A materially different question (no matching adjudication) still escalates normally.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import type { DataLayer, EngineClient } from "@nanobpm/urban";
+import { questionFingerprint } from "./github.ts";
+import { pollUserTasks } from "./service.ts";
+
+// biome-ignore lint/suspicious/noExplicitAny: in-memory table double, mirrors pollUserTasks.test.ts
+function memData(seed: Record<string, any[]> = {}): { data: DataLayer; stores: Record<string, any[]> } {
+  // biome-ignore lint/suspicious/noExplicitAny: see above
+  const stores: Record<string, any[]> = {};
+  for (const [k, v] of Object.entries(seed)) stores[k] = v.map((r) => ({ ...r }));
+  function tbl(name: string, pk = "id") {
+    // biome-ignore lint/suspicious/noExplicitAny: see above
+    const rows = (stores[name] ??= [] as any[]);
+    // biome-ignore lint/suspicious/noExplicitAny: see above
+    const match = (r: any, where: any) => Object.entries(where).every(([k, v]) => r[k] === v);
+    return {
+      async all() {
+        return rows.slice();
+      },
+      // biome-ignore lint/suspicious/noExplicitAny: see above
+      async get(id: any) {
+        return rows.find((r) => r[pk] === id);
+      },
+      // biome-ignore lint/suspicious/noExplicitAny: see above
+      async find(where: any = {}) {
+        return rows.filter((r) => match(r, where));
+      },
+      // biome-ignore lint/suspicious/noExplicitAny: see above
+      async insert(r: any) {
+        rows.push({ ...r });
+        return r[pk];
+      },
+      // biome-ignore lint/suspicious/noExplicitAny: see above
+      async update(id: any, patch: any) {
+        const r = rows.find((row) => row[pk] === id);
+        if (r) Object.assign(r, patch);
+      },
+      // biome-ignore lint/suspicious/noExplicitAny: see above
+      async delete(id: any) {
+        const i = rows.findIndex((r) => r[pk] === id);
+        if (i >= 0) rows.splice(i, 1);
+      },
+    };
+  }
+  const data = { table: (n: string, pk?: string) => tbl(n, pk) } as unknown as DataLayer;
+  return { data, stores };
+}
+
+type FakeTask = { userTaskKey: string; elementId: string; processInstanceKey: string };
+
+/** A fake engine backing BOTH the poller's per-instance `openUserTasks({processInstanceKey})` scan AND
+ *  the `completeEscalationAsHuman` door's unfiltered `openUserTasks()` resolve. `completeUserTask`
+ *  removes the task (a resumed task is no longer open) and records the completion for assertions. */
+function fakeEngine(tasks: FakeTask[]) {
+  const open = tasks.slice();
+  const completions: { userTaskKey: string; variables: Record<string, unknown> }[] = [];
+  // Every `openUserTasks` filter seen this run, so a test can assert the auto-apply resolve scans a
+  // single instance (`{processInstanceKey}`) rather than an engine-wide unfiltered scan (issue #806).
+  const scans: (undefined | { processInstanceKey?: string; rootProcessInstanceKey?: string })[] = [];
+  const engine = {
+    openUserTasks: (filter?: { processInstanceKey?: string; rootProcessInstanceKey?: string }) => {
+      scans.push(filter);
+      return Promise.resolve(
+        open.filter((t) => {
+          if (filter?.processInstanceKey) return t.processInstanceKey === filter.processInstanceKey;
+          if (filter?.rootProcessInstanceKey) return t.processInstanceKey === filter.rootProcessInstanceKey;
+          return true;
+        }),
+      );
+    },
+    completeUserTask: (userTaskKey: string, variables: Record<string, unknown>) => {
+      const i = open.findIndex((t) => t.userTaskKey === userTaskKey);
+      if (i < 0) return Promise.reject(new Error("no such open task"));
+      open.splice(i, 1);
+      completions.push({ userTaskKey, variables });
+      return Promise.resolve();
+    },
+  } as unknown as EngineClient;
+  return { engine, completions, scans };
+}
+
+test("pollUserTasks: auto-resumes an already-answered wait-answer instead of re-parking a human (#806)", async () => {
+  const question = "Should the timeout be a boundary event or a poller sentinel?";
+  const { data, stores } = memData({
+    pull_requests: [{ pr_key: "o/r#800", status: "escalated", process_key: "rp-800", url: "https://github.com/o/r/pull/800", title: "Converge" }],
+    escalations: [{ id: 1, pr_key: "o/r#800", status: "open", question }],
+    pr_adjudications: [
+      {
+        id: 1,
+        pr_key: "o/r#800",
+        // Whitespace/case variant — the canonical fingerprint normalises it to the same key.
+        question_fingerprint: questionFingerprint(`  ${question.toUpperCase()}  `),
+        answer: "Option A: a bounded boundary event.",
+        adjudicated_by: "alice",
+        adjudicated_at: "2025-01-01T00:00:00.000Z",
+      },
+    ],
+  });
+  const { engine, completions } = fakeEngine([{ userTaskKey: "ut-800", elementId: "wait-answer", processInstanceKey: "rp-800" }]);
+
+  await pollUserTasks(data, engine);
+
+  assertEquals(completions.length, 1, "the parked wait-answer is auto-resumed");
+  assertEquals(completions[0].userTaskKey, "ut-800");
+  assertEquals(completions[0].variables.answer, "Option A: a bounded boundary event.", "resumed with the recorded answer");
+  assertEquals((stores.user_tasks ?? []).length, 0, "no wait-answer row is projected — the human is NOT re-parked");
+  const ledger = stores.task_completions ?? [];
+  assertEquals(ledger.length, 1, "the auto-resume is recorded in the completion ledger");
+  assertEquals(ledger[0].actor_id, "alice", "attributed to the prior adjudicator");
+  assertEquals(ledger[0].actor_kind, "human", "the prior adjudicator's kind is preserved (a human-settled decision)");
+  assertEquals(ledger[0].auto_applied, 1, "the replay is marked auto_applied — distinguishable from a first-hand submission");
+  assertEquals(ledger[0].reversible, 1, "an auto-applied replay is human-overridable");
+});
+
+test("pollUserTasks: auto-resume PRESERVES an agent adjudicator's kind and stays reversible (#806 review)", async () => {
+  // A prior AGENT-settled adjudication (ADR 0046) must replay as an agent completion, never laundered
+  // into an irreversible human authority — the whole point of recording `adjudicated_kind`.
+  const question = "Which retry cap should the husk loop use?";
+  const { data, stores } = memData({
+    pull_requests: [{ pr_key: "o/r#801", status: "escalated", process_key: "rp-801", url: "https://github.com/o/r/pull/801", title: "Converge" }],
+    escalations: [{ id: 1, pr_key: "o/r#801", status: "open", question }],
+    pr_adjudications: [
+      {
+        id: 1,
+        pr_key: "o/r#801",
+        question_fingerprint: questionFingerprint(question),
+        answer: "Cap at 3.",
+        adjudicated_by: "senior-agent",
+        adjudicated_kind: "agent",
+        adjudicated_at: "2025-01-01T00:00:00.000Z",
+      },
+    ],
+  });
+  const { engine, completions } = fakeEngine([{ userTaskKey: "ut-801", elementId: "wait-answer", processInstanceKey: "rp-801" }]);
+
+  await pollUserTasks(data, engine);
+
+  assertEquals(completions.length, 1, "the parked wait-answer is auto-resumed");
+  const ledger = stores.task_completions ?? [];
+  assertEquals(ledger[0].actor_kind, "agent", "the agent adjudicator's kind is preserved — not laundered into a human");
+  assertEquals(ledger[0].actor_id, "senior-agent");
+  assertEquals(ledger[0].auto_applied, 1, "still marked auto_applied");
+  assertEquals(ledger[0].reversible, 1, "still reversible — a human may override the replayed agent answer");
+});
+
+test("pollUserTasks: a DIFFERENT question with no adjudication still escalates to a human (#806)", async () => {
+  const { data, stores } = memData({
+    pull_requests: [{ pr_key: "o/r#800", status: "escalated", process_key: "rp-800", url: "https://github.com/o/r/pull/800", title: "Converge" }],
+    escalations: [{ id: 1, pr_key: "o/r#800", status: "open", question: "A brand-new question nobody has answered." }],
+    pr_adjudications: [
+      {
+        id: 1,
+        pr_key: "o/r#800",
+        question_fingerprint: questionFingerprint("Some other, already-settled question."),
+        answer: "Prior answer.",
+        adjudicated_by: "alice",
+        adjudicated_at: "2025-01-01T00:00:00.000Z",
+      },
+    ],
+  });
+  const { engine, completions } = fakeEngine([{ userTaskKey: "ut-800", elementId: "wait-answer", processInstanceKey: "rp-800" }]);
+
+  await pollUserTasks(data, engine);
+
+  assertEquals(completions.length, 0, "no auto-resume — the question is materially different");
+  const rows = stores.user_tasks ?? [];
+  assertEquals(rows.length, 1, "the new question is projected for a human to answer");
+  assertEquals(rows[0].user_task_key, "ut-800");
+  assertEquals(rows[0].question, "A brand-new question nobody has answered.");
+});
+
+test("pollUserTasks: an adjudication with UNKNOWN provenance fails open to a human, not a synthetic actor (#806 review)", async () => {
+  // A settled row whose `adjudicated_by` is blank (completed out of band, so `latestAdjudicator`
+  // returned no actor) must NOT be auto-replayed as a manufactured `human` actor — that would audit an
+  // unknown-provenance replay as a first-hand human decision. It fails open to a fresh human task.
+  const question = "Should the cache be write-through or write-back?";
+  const { data, stores } = memData({
+    pull_requests: [{ pr_key: "o/r#802", status: "escalated", process_key: "rp-802", url: "https://github.com/o/r/pull/802", title: "Converge" }],
+    escalations: [{ id: 1, pr_key: "o/r#802", status: "open", question }],
+    pr_adjudications: [
+      {
+        id: 1,
+        pr_key: "o/r#802",
+        question_fingerprint: questionFingerprint(question),
+        answer: "Write-through.",
+        adjudicated_by: null,
+        adjudicated_kind: null,
+        adjudicated_at: "2025-01-01T00:00:00.000Z",
+      },
+    ],
+  });
+  const { engine, completions } = fakeEngine([{ userTaskKey: "ut-802", elementId: "wait-answer", processInstanceKey: "rp-802" }]);
+
+  await pollUserTasks(data, engine);
+
+  assertEquals(completions.length, 0, "no auto-resume — a synthetic human actor is never manufactured");
+  const rows = stores.user_tasks ?? [];
+  assertEquals(rows.length, 1, "the question projects for a human to answer (fail-open)");
+  assertEquals(rows[0].user_task_key, "ut-802");
+});
+
+test("pollUserTasks: a transient adjudication-lookup error fails open and never aborts the pass (#806 review)", async () => {
+  // The adjudication LOOKUP is inside the fail-open try, so a transient `pr_adjudications.find` error
+  // must NOT reject `project`/abort `pollUserTasks` — the task still projects and reaches a human.
+  const question = "Should retries be capped?";
+  const { data, stores } = memData({
+    pull_requests: [{ pr_key: "o/r#803", status: "escalated", process_key: "rp-803", url: "https://github.com/o/r/pull/803", title: "Converge" }],
+    escalations: [{ id: 1, pr_key: "o/r#803", status: "open", question }],
+  });
+  const base = data.table.bind(data);
+  const failing = {
+    table(name: string, pk?: string) {
+      const t = base(name, pk);
+      if (name === "pr_adjudications") {
+        return { ...t, find: () => Promise.reject(new Error("transient db error")) };
+      }
+      return t;
+    },
+  } as unknown as DataLayer;
+  const { engine, completions } = fakeEngine([{ userTaskKey: "ut-803", elementId: "wait-answer", processInstanceKey: "rp-803" }]);
+
+  await pollUserTasks(failing, engine);
+
+  assertEquals(completions.length, 0, "no auto-resume on a lookup error");
+  const rows = stores.user_tasks ?? [];
+  assertEquals(rows.length, 1, "the task still projects — the poller did not abort (fail-open)");
+  assertEquals(rows[0].user_task_key, "ut-803");
+});
+
+test("pollUserTasks: auto-resume resolves the task per-instance, never an engine-wide scan (#806 review)", async () => {
+  // Copilot review of #806: `completeEscalationAutoApplied` -> `resolveEscalationTask` used an
+  // UNFILTERED `openUserTasks()` scan, run once per already-adjudicated PR in a single poll pass — so
+  // N parked-and-answered PRs cost N full engine scans (O(N²) work/REST). The poller already knows each
+  // task's owning instance, so the resolve must scan THAT instance (`{processInstanceKey}`) only. Seed
+  // several answered PRs and assert the pass issues ZERO unfiltered scans.
+  const q = "Boundary event or poller sentinel?";
+  const prKeys = ["o/r#810", "o/r#811", "o/r#812"];
+  const { data } = memData({
+    pull_requests: prKeys.map((pr_key, i) => ({
+      pr_key,
+      status: "escalated",
+      process_key: `rp-81${i}`,
+      url: `https://github.com/o/r/pull/81${i}`,
+      title: "Converge",
+    })),
+    escalations: prKeys.map((pr_key, i) => ({ id: i + 1, pr_key, status: "open", question: q })),
+    pr_adjudications: prKeys.map((pr_key, i) => ({
+      id: i + 1,
+      pr_key,
+      question_fingerprint: questionFingerprint(q),
+      answer: "Option A: a bounded boundary event.",
+      adjudicated_by: "alice",
+      adjudicated_at: "2025-01-01T00:00:00.000Z",
+    })),
+  });
+  const { engine, completions, scans } = fakeEngine(
+    prKeys.map((_, i) => ({ userTaskKey: `ut-81${i}`, elementId: "wait-answer", processInstanceKey: `rp-81${i}` })),
+  );
+
+  await pollUserTasks(data, engine);
+
+  assertEquals(completions.length, 3, "all three answered wait-answers auto-resume");
+  const unfiltered = scans.filter((f) => !f?.processInstanceKey && !f?.rootProcessInstanceKey);
+  assertEquals(unfiltered.length, 0, "no engine-wide (unfiltered) openUserTasks scan — the resolve is per-instance");
+});

package/app/github.ts

@@ -240,6 +240,16 @@ export function advisoryStableKey(path: string, text: string): string {
   return `${path.trim()}#${fingerprint(normalizeAdvisoryText(text))}`;
 }
 
+/** The line-stable fingerprint of a convergence escalation QUESTION (issue #806): the SAME canonical
+ * `normalizeAdvisoryText` + `fingerprint` digest advisory acks key on, applied to the escalation's
+ * question text. Reuses the ONE normaliser/fingerprint pair (no second implementation) so a durable
+ * wait-answer adjudication keyed by `(prKey, questionFingerprint)` is byte/semantic-stable the exact
+ * disciplined way an advisory ack is — only a semantically-identical, already-answered question is
+ * suppressed; a materially different question keys differently and still escalates. */
+export function questionFingerprint(text: string): string {
+  return fingerprint(normalizeAdvisoryText(text));
+}
+
 /** Parse Copilot's suppressed / low-confidence advisories out of a review body. Copilot renders them
  * under a `<summary>Suppressed comments (N)</summary>` block, each as a bold `**path:line**` header
  * followed by the advisory prose. Returns de-duplicated advisories (empty when there is no block). */

package/app/service.test.ts

@@ -39,6 +39,33 @@ function memTable(rows: any[], key: string) {
   };
 }
 
+// Emulates the `data.open().exec` raw-SQL path submitPr uses to atomically reset a PR's adjudication
+// memory (`resetAdjudications` → `DELETE FROM "pr_adjudications" WHERE "pr_key" = ?`, Copilot review of
+// #806). The bulk-DELETE SQL itself is validated against real SQLite in app/adjudications.test.ts; here
+// it need only mutate the in-memory `pr_adjudications` store so submitPr's reset is observable. Pushes
+// an optional ordering token so the fence-ordering test can assert the reset runs AFTER `process_key`.
+function memOpen(stores: Record<string, { rows: any[]; key: string }>, ops?: string[]) {
+  return {
+    exec: async (sql: string, params: any[] = []) => {
+      if (/DELETE FROM "pr_adjudications" WHERE "pr_key" = \?/.test(sql)) {
+        ops?.push("adjudication-delete");
+        const store = stores.pr_adjudications;
+        let changed = 0;
+        if (store) {
+          for (let i = store.rows.length - 1; i >= 0; i--) {
+            if (store.rows[i].pr_key === params[0]) {
+              store.rows.splice(i, 1);
+              changed++;
+            }
+          }
+        }
+        return { changed };
+      }
+      throw new Error(`unexpected exec sql: ${sql}`);
+    },
+  };
+}
+
 function withGithubOff(run: () => Promise<void>): Promise<void> {
   const prevMode = process.env["NANO_PR_GITHUB_TRANSPORT"];
   const prevTok = process.env["GITHUB_TOKEN"];
@@ -104,6 +131,7 @@ test("re-submit of a cancelled PR marks stale open escalations", async () => {
     };
     const data = {
       table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
     } as any;
     const engine = {
       createInstance: () => Promise.resolve({ processInstanceKey: "PI-9" }),
@@ -140,7 +168,142 @@ test("re-submit of a cancelled PR marks stale open escalations", async () => {
   });
 });
 
-// Red/green regression for technical-incident surfacing (issue #94). A convergence/merge instance
+// Red/green regression for issue #806 (Copilot review): re-submitting a PR must ALSO invalidate its
+// durable adjudication memory. The auto-resume replays a prior `(PR, question)` answer forever, so a
+// re-opened PR whose question recurs would silently auto-apply the stale decision and an operator
+// could never force a fresh one. `submitPr`'s reopen path clears `pr_adjudications` for the PR.
+test("re-submit of a PR invalidates its durable adjudications (#806 review)", async () => {
+  await withGithubOff(async () => {
+    const PR_KEY = "owner/repo#42";
+    const stores: Record<string, { rows: unknown[]; key: string }> = {
+      pull_requests: {
+        rows: [{ pr_key: PR_KEY, repo: "owner/repo", number: 42, url: "https://github.com/owner/repo/pull/42", title: "t", status: "converged" }],
+        key: "pr_key",
+      },
+      escalations: { rows: [], key: "id" },
+      pr_adjudications: {
+        rows: [
+          { id: 1, pr_key: PR_KEY, question_fingerprint: "fp-a", answer: "prior A", adjudicated_by: "alice", adjudicated_kind: "human", adjudicated_at: "t" },
+          { id: 2, pr_key: "owner/repo#99", question_fingerprint: "fp-b", answer: "other PR", adjudicated_by: "bob", adjudicated_kind: "human", adjudicated_at: "t" },
+        ],
+        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;
+    const engine = { createInstance: () => Promise.resolve({ processInstanceKey: "PI-9" }) } as any;
+
+    await submitPr(data, engine, { repo: "owner/repo", number: 42, url: "https://github.com/owner/repo/pull/42", prKey: PR_KEY });
+
+    const remaining = stores.pr_adjudications.rows as Record<string, unknown>[];
+    assertEquals(remaining.length, 1, "this PR's adjudication is invalidated; another PR's is untouched");
+    assertEquals(remaining[0].pr_key, "owner/repo#99", "only the re-submitted PR's adjudications are cleared");
+  });
+});
+
+// Red/green regression for issue #806 (Copilot review): the durable adjudication RESET must happen
+// AFTER `process_key` is advanced to the new instance — not before createInstance. Clearing the memory
+// while `process_key` still names the OLD instance leaves a window where a delayed old-instance answer
+// job passes the worker's staleness gate and reinserts its adjudication into the fresh run. Advancing
+// the run identity FIRST fences that job, so the ordering is the fix. This asserts the observable
+// invariant: the `pull_requests.process_key` write is issued BEFORE any `pr_adjudications.delete`.
+test("re-submit advances process_key BEFORE resetting adjudications (fence ordering, #806 review)", async () => {
+  await withGithubOff(async () => {
+    const PR_KEY = "owner/repo#42";
+    const ops: string[] = [];
+    const stores: Record<string, { rows: any[]; key: string }> = {
+      pull_requests: {
+        rows: [{ pr_key: PR_KEY, repo: "owner/repo", number: 42, url: "https://github.com/owner/repo/pull/42", title: "t", status: "converged", process_key: "PI-OLD" }],
+        key: "pr_key",
+      },
+      escalations: { rows: [], key: "id" },
+      pr_adjudications: {
+        rows: [{ id: 1, pr_key: PR_KEY, question_fingerprint: "fp-a", answer: "prior A", adjudicated_by: "alice", adjudicated_kind: "human", adjudicated_at: "t" }],
+        key: "id",
+      },
+      pr_dependencies: { rows: [], key: "pr_key" },
+    };
+    const wrap = (name: string, key: string) => {
+      const t = memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key);
+      return {
+        ...t,
+        update: (k: any, patch: any) => {
+          if (name === "pull_requests" && Object.prototype.hasOwnProperty.call(patch, "process_key")) ops.push("process_key");
+          return t.update(k, patch);
+        },
+      };
+    };
+    // The adjudication reset is now the atomic bulk `DELETE` via `data.open().exec` (Copilot review of
+    // #806), so `memOpen(stores, ops)` records the `adjudication-delete` ordering token — the table
+    // `delete` gateway is no longer on the reset path.
+    const data = { table: withTrackingViews(wrap), open: () => memOpen(stores, ops) } as any;
+    const engine = { createInstance: () => Promise.resolve({ processInstanceKey: "PI-NEW" }) } as any;
+
+    await submitPr(data, engine, { repo: "owner/repo", number: 42, url: "https://github.com/owner/repo/pull/42", prKey: PR_KEY });
+
+    assertEquals(stores.pr_adjudications.rows.length, 0, "the re-submitted PR's adjudication is invalidated");
+    const pkIdx = ops.indexOf("process_key");
+    const delIdx = ops.indexOf("adjudication-delete");
+    assertEquals(pkIdx >= 0, true, "process_key is advanced on reopen");
+    assertEquals(delIdx >= 0, true, "adjudications are reset on reopen");
+    assertEquals(pkIdx < delIdx, true, "process_key is advanced BEFORE the adjudication memory is reset (the fence ordering)");
+  });
+});
+
+// Red/green regression (Copilot review): the durable adjudication RESET runs AFTER the new instance is
+// created and `process_key` is advanced. If the reset DELETE fails, the new convergence instance is
+// already live while the OLD adjudications remain — and because the new instance is ACTIVE the
+// `alreadyRunning` idempotency gate short-circuits every retry, so the reset is never re-run and the
+// fresh run replays STALE decisions forever. `submitPr` must instead ROLL THE NEW RUN BACK on a reset
+// failure: terminate the just-created instance (so nothing auto-applies stale memory) and rethrow, so
+// the submission is not treated as started and a retry re-creates a clean run.
+test("re-submit rolls back (cancels) the new instance when the adjudication reset fails (#806 review)", async () => {
+  await withGithubOff(async () => {
+    const PR_KEY = "owner/repo#42";
+    const stores: Record<string, { rows: any[]; key: string }> = {
+      pull_requests: {
+        rows: [{ pr_key: PR_KEY, repo: "owner/repo", number: 42, url: "https://github.com/owner/repo/pull/42", title: "t", status: "converged", process_key: "PI-OLD" }],
+        key: "pr_key",
+      },
+      escalations: { rows: [], key: "id" },
+      pr_adjudications: {
+        rows: [{ id: 1, pr_key: PR_KEY, question_fingerprint: "fp-a", answer: "prior A", adjudicated_by: "alice", adjudicated_kind: "human", adjudicated_at: "t" }],
+        key: "id",
+      },
+      pr_dependencies: { rows: [], key: "pr_key" },
+    };
+    // The reset DELETE throws (a transient DB failure), leaving the new instance live but the memory
+    // uncleared — the exact half-committed state the rollback guards against.
+    const failingOpen = () => ({
+      exec: async (sql: string) => {
+        if (/DELETE FROM "pr_adjudications" WHERE "pr_key" = \?/.test(sql)) throw new Error("boom: reset DELETE failed");
+        throw new Error(`unexpected exec sql: ${sql}`);
+      },
+    });
+    const data = { table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)), open: failingOpen } as any;
+    const cancelled: string[] = [];
+    const engine = {
+      createInstance: () => Promise.resolve({ processInstanceKey: "PI-NEW" }),
+      cancelInstance: (input: { processInstanceKey: string }) => {
+        cancelled.push(input.processInstanceKey);
+        return Promise.resolve();
+      },
+    } as any;
+
+    let threw = false;
+    try {
+      await submitPr(data, engine, { repo: "owner/repo", number: 42, url: "https://github.com/owner/repo/pull/42", prKey: PR_KEY });
+    } catch {
+      threw = true;
+    }
+    assertEquals(threw, true, "a failed reset propagates so the caller can retry");
+    assertEquals(cancelled, ["PI-NEW"], "the just-created instance is terminated (rolled back), never left live with stale memory");
+  });
+});
+
 // can hit an engine incident that parks the token; until `pollIncidents` nothing on the PR row
 // reflected it, so the grid kept showing "converging" while the run was dead in the water. This
 // drives the pass's reconciliation core against a stubbed `/v2/incidents/search`:
@@ -180,6 +343,7 @@ test("pollIncidents mirrors an ACTIVE incident onto the PR row, then clears it,
   };
   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" };
 
@@ -233,6 +397,7 @@ test("pollIncidents never queries a PR with no live instance and clears any stal
   };
   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" };
 
@@ -266,6 +431,7 @@ test("pollIncidents picks the oldest incident by creationTime, sorting a missing
   };
   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" };
 
@@ -305,6 +471,7 @@ test("submitPr stringifies a numeric processInstanceKey (contract: string | null
     };
     const data = {
       table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
     } as any;
     const engine = {
       // A large key delivered as a JS number — the exact case that breaks dev response validation
@@ -339,6 +506,7 @@ function captureConvergeOnly() {
   };
   const data = {
     table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
   } as any;
   let captured: unknown;
   const engine = {
@@ -391,6 +559,7 @@ function captureVars() {
   };
   const data = {
     table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
   } as any;
   let captured: Record<string, unknown> | undefined;
   const engine = {
@@ -429,6 +598,7 @@ function captureRoot() {
   };
   const data = {
     table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
   } as any;
   let captured: unknown;
   const engine = {
@@ -795,6 +965,7 @@ test("pollWaveGatesImpl is level-triggered: PRs merged before the token arrives
     };
     const data = {
       table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
     } as any;
 
     const published: { name: string; correlationKey?: string }[] = [];
@@ -884,6 +1055,7 @@ test("pollWaveGatesImpl never releases the barrier on an unverifiable subscripti
     };
     const data = {
       table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
     } as any;
 
     const published: { name: string; correlationKey?: string }[] = [];
@@ -988,6 +1160,7 @@ test("pollWaveGatesImpl releases the wave when a member PR is closed-unmerged an
     };
     const data = {
       table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
     } as any;
 
     const published: { name: string; correlationKey?: string }[] = [];
@@ -1044,6 +1217,7 @@ test("abandonClosedPr is idempotent — the terminal merges audit row is written
   };
   const data = {
     table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
   } as any;
 
   await abandonClosedPr(data, "owner/repo#70", "closed without merging");
@@ -1072,6 +1246,7 @@ test("abandonClosedPr self-heals a missing pull_requests parent row before the F
   };
   const data = {
     table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
   } as any;
 
   await abandonClosedPr(data, "owner/repo#71", "closed without merging");
@@ -1098,6 +1273,7 @@ test("abandonClosedPr rejects a malformed prKey with a clear error before any FK
   };
   const data = {
     table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
   } as any;
 
   const err = await assertRejects(() => abandonClosedPr(data, "not-a-valid-pr-key", "closed without merging"));
@@ -1170,6 +1346,7 @@ function capsProbeExec(ready: boolean) {
 function capsDataLayer(stores: Record<string, { rows: any[]; key: string }>) {
   return {
     table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
   } as any;
 }