@nanobpm/nano-workforce 0.187.3 → 0.187.5

package/app/persist-round.test.ts

@@ -1,11 +1,12 @@
-// Red/green regression for pr.persist-round's round recording + parking behaviour.
+// Red/green regression for pr.persist-round's round recording behaviour.
 //
 // The convergence loop routes both `addressed` (the agent pushed changes) and the new `waiting`
 // (nothing to triage yet — round 1, awaiting the first review) statuses through gw-guard into
-// persist-round. Both must be recorded in `rounds` under their own status and both must park the
-// PR in `waiting_review` so the deterministic poller (app/service.ts) starts soliciting a review.
-// A `waiting` round is what replaced the old failure mode where an agent with nothing to do
-// re-requested the review destructively and escalated `blocked`.
+// persist-round. Both must be recorded in `rounds` under their own status and both must advance the
+// PR's `current_round`. The PARK into `waiting_review` is owned by the downstream pr.progress-check
+// step (the single writer of the post-round wait status), NOT persist-round — persist-round runs
+// before the husk decision, so parking here would let the poller fire a spurious review re-request
+// against a husk-retry round before progress-check resolves it (#786).
 import { test } from "node:test";
 import { assertEquals } from "#test-assert";
 import handler from "../workers/persist-round/worker.ts";
@@ -14,6 +15,7 @@ function fakeApp() {
   const inserts: Record<string, unknown[]> = { rounds: [] };
   const updates: Record<string, unknown[]> = { pull_requests: [] };
   const rows: Record<string, Map<string, unknown>> = {};
+  let roundsId = 0;
   const app = {
     data: {
       table(name: string, _key: string) {
@@ -22,14 +24,25 @@ function fakeApp() {
           async get(key: string) {
             return store.get(key);
           },
+          async find(criteria: Record<string, unknown>) {
+            return [...store.values()].filter((r) =>
+              Object.entries(criteria).every(([k, v]) => (r as any)[k] === v),
+            );
+          },
           async insert(row: unknown) {
-            (inserts[name] ??= []).push(row);
             const pk = name === "rounds" ? "id" : "pr_key";
+            // The rounds table has an AUTOINCREMENT id; mint one so find/update can key on it.
+            if (name === "rounds" && (row as any).id === undefined) {
+              (row as any).id = ++roundsId;
+            }
+            (inserts[name] ??= []).push(row);
             store.set((row as any)[pk], row);
             return 1;
           },
-          async update(key: string, patch: unknown) {
+          async update(key: string, patch: Record<string, unknown>) {
             (updates[name] ??= []).push({ key, patch });
+            const existing = store.get(key);
+            if (existing) store.set(key, { ...(existing as object), ...patch });
           },
         };
       },
@@ -39,7 +52,7 @@ function fakeApp() {
 }
 
 for (const status of ["addressed", "waiting"]) {
-  test(`persist-round records a '${status}' round and parks the PR in waiting_review`, async () => {
+  test(`persist-round records a '${status}' round and advances current_round without parking`, async () => {
     const { app, inserts, updates } = fakeApp();
     const job = { variables: { prKey: "o/r#1", round: 1, status, summary: `round was ${status}` } };
     await handler(job as any, app as any);
@@ -51,7 +64,11 @@ for (const status of ["addressed", "waiting"]) {
 
     assertEquals(updates.pull_requests!.length, 1, "the PR is updated once");
     const patch = (updates.pull_requests![0] as any).patch;
-    assertEquals(patch.status, "waiting_review", "the PR parks in waiting_review for the poller");
+    // The park into `waiting_review` is owned by pr.progress-check (the single writer of the
+    // post-round wait status), NOT persist-round — persist-round runs before the husk decision, so
+    // parking here would race the poller against a husk retry (#786). It only advances the round.
+    assertEquals(patch.status, undefined, "persist-round does NOT park the PR in waiting_review");
+    assertEquals(patch.waiting_since, undefined, "persist-round does NOT stamp the review-wait start");
     assertEquals(patch.current_round, 1);
   });
 }
@@ -97,9 +114,11 @@ test("persist-round heals a missing pull_requests parent before recording the ro
   assertEquals(healed.status, "converging", "the healed parent starts in the converging aggregate");
   assertEquals(healed.url, "https://github.com/o/r/pull/7", "URL is derived canonically");
   assertEquals(inserts.rounds.length, 1, "the round is still recorded after the heal");
-  // And the worker still parks the (now-present) PR in waiting_review as its final state.
+  // And the worker advances current_round on the (now-present) PR — but does NOT park it in
+  // waiting_review (that is pr.progress-check's job now, #786).
   assertEquals(updates.pull_requests!.length, 1, "the PR is updated once after the heal");
-  assertEquals((updates.pull_requests![0] as any).patch.status, "waiting_review");
+  assertEquals((updates.pull_requests![0] as any).patch.status, undefined, "no park in persist-round");
+  assertEquals((updates.pull_requests![0] as any).patch.current_round, 3);
 });
 
 // rather than writing a NULL status — the round history stays readable.
@@ -135,3 +154,151 @@ test("persist-round heals from the prKey when repo/prNumber are absent", async (
     "the running agent's abandon token is preserved from abandonUrl, not re-minted",
   );
 });
+
+// Idempotent round recording (issue #786): a husk auto-retry re-enters `review-round` WITHOUT
+// advancing the round counter, so pr.persist-round is reached again for the SAME (pr_key, round_no).
+// The `rounds` table has no UNIQUE(pr_key, round_no), so the worker must UPSERT — update the existing
+// row in place, never manufacture a duplicate history row that would corrupt the durable round
+// history the cockpit and the no-progress guard both read.
+test("persist-round is idempotent on (pr_key, round_no) — a retry updates, never duplicates", async () => {
+  const { app, inserts, updates } = fakeApp();
+  const first = { variables: { prKey: "o/r#1", round: 4, status: "addressed", summary: "first attempt" } };
+  await handler(first as any, app as any);
+  assertEquals(inserts.rounds.length, 1, "the first attempt inserts a round row");
+
+  // A husk retry: same round_no, a fresh summary/transcript.
+  const retry = { variables: { prKey: "o/r#1", round: 4, status: "addressed", summary: "retry attempt" } };
+  await handler(retry as any, app as any);
+  assertEquals(inserts.rounds.length, 1, "the retry does NOT insert a second round row");
+
+  const roundUpdate = (updates.rounds ?? []).at(-1) as any;
+  assertEquals(roundUpdate?.patch.summary, "retry attempt", "the retry updates the existing round in place");
+  assertEquals((inserts.rounds[0] as any).round_no, 4);
+});
+
+// Regression (issue #786): the idempotent upsert must reuse only a row THIS worker wrote — never an
+// escalation row. On a needs_input/blocked escalation, pr.persist-escalation records a `rounds` row
+// (status needs_input/blocked) for the SAME (pr_key, round_no); the human-answered resume re-enters
+// that same numeric round and lands here. Blindly updating the newest matching row would overwrite
+// the escalation row to `addressed`, ERASING the escalation attempt from the durable history. The
+// resume must INSERT a fresh row so both the escalation and its resolution survive.
+test("persist-round does NOT overwrite a same-round escalation row — it inserts the resumed attempt", async () => {
+  const { app, inserts, updates, rows } = fakeApp();
+  // Simulate pr.persist-escalation having recorded a needs_input round row for round 5.
+  const roundsStore = (rows.rounds ??= new Map());
+  roundsStore.set(101, {
+    id: 101,
+    pr_key: "o/r#1",
+    round_no: 5,
+    status: "needs_input",
+    summary: "escalated: which API shape?",
+    transcript: "escalation transcript",
+    started_at: "t0",
+    ended_at: "t0",
+  });
+
+  // The human answers; the same numeric round resumes and reaches persist-round as `addressed`.
+  const resume = { variables: { prKey: "o/r#1", round: 5, status: "addressed", summary: "resumed and pushed" } };
+  await handler(resume as any, app as any);
+
+  assertEquals(inserts.rounds.length, 1, "the resumed attempt inserts a NEW round row");
+  assertEquals((inserts.rounds[0] as any).status, "addressed", "the new row is the addressed resume");
+  // The escalation row is untouched — never updated to `addressed`.
+  const escalationTouched = (updates.rounds ?? []).some((u: any) => u.key === 101);
+  assertEquals(escalationTouched, false, "the needs_input escalation row is preserved, not overwritten");
+  assertEquals((roundsStore.get(101) as any).status, "needs_input", "the escalation row keeps its status");
+});
+
+// But a genuine husk retry (a prior pr.persist-round row, status addressed/waiting) is still reused
+// in place — only escalation rows are excluded, so idempotency for the retry path is preserved even
+// when an escalation row for the same round also exists.
+test("persist-round reuses a prior addressed round-record row while skipping an escalation row", async () => {
+  const { app, inserts, updates, rows } = fakeApp();
+  const roundsStore = (rows.rounds ??= new Map());
+  // An escalation row AND a prior persist-round row for the same round.
+  roundsStore.set(200, { id: 200, pr_key: "o/r#1", round_no: 6, status: "blocked", summary: "blocked earlier" });
+  roundsStore.set(201, { id: 201, pr_key: "o/r#1", round_no: 6, status: "addressed", summary: "first addressed" });
+
+  const retry = { variables: { prKey: "o/r#1", round: 6, status: "addressed", summary: "husk retry" } };
+  await handler(retry as any, app as any);
+
+  assertEquals(inserts.rounds.length, 0, "no new row — the prior addressed row is reused");
+  const roundUpdate = (updates.rounds ?? []).at(-1) as any;
+  assertEquals(roundUpdate?.key, 201, "the addressed round-record row is updated, not the blocked escalation row");
+  assertEquals(roundUpdate?.patch.summary, "husk retry");
+  assertEquals((roundsStore.get(200) as any).status, "blocked", "the escalation row is left intact");
+});
+
+// Regression (issue #786): the idempotent upsert must be scoped to the writing RUN, not inferred
+// from status. `submitPr` re-opens a previously converged/abandoned PR at round 1 WITHOUT deleting
+// `rounds` history, so a fresh convergence run (a NEW process instance) at round 1 finds the prior
+// run's `addressed`/`waiting`/`converged` round-1 row. Reusing it (its status is not human-hold)
+// would clobber another run's canonical summary/transcript/worker/timestamps. Scoping reuse by the
+// writing `process_instance_key` means the new run INSERTS a fresh row and the prior run's history
+// survives verbatim.
+test("persist-round scopes idempotency to the process instance — a resubmission inserts a fresh row", async () => {
+  const { app, inserts, updates, rows } = fakeApp();
+  const roundsStore = (rows.rounds ??= new Map());
+  // A prior run's round-1 row (its own process instance) with real history.
+  roundsStore.set(300, {
+    id: 300,
+    pr_key: "o/r#1",
+    round_no: 1,
+    status: "converged",
+    summary: "prior run summary",
+    transcript: "prior run transcript",
+    worker: "senior",
+    process_instance_key: "proc-OLD",
+    started_at: "t0",
+    ended_at: "t0",
+  });
+
+  // A resubmission: submitPr restarts convergence at round 1 in a NEW process instance.
+  const resubmit = {
+    processInstanceKey: "proc-NEW",
+    variables: { prKey: "o/r#1", round: 1, status: "addressed", summary: "fresh run" },
+  };
+  await handler(resubmit as any, app as any);
+
+  assertEquals(inserts.rounds.length, 1, "the resubmission inserts its OWN round row");
+  assertEquals((inserts.rounds[0] as any).process_instance_key, "proc-NEW", "the new row carries the new run's key");
+  const priorTouched = (updates.rounds ?? []).some((u: any) => u.key === 300);
+  assertEquals(priorTouched, false, "the prior run's round-1 row is never updated");
+  assertEquals((roundsStore.get(300) as any).summary, "prior run summary", "the prior run's history is intact");
+});
+
+// But a husk retry WITHIN the same run (same process instance key, same round_no) is still reused in
+// place — process-instance scoping preserves husk-retry idempotency, it does not disable it.
+test("persist-round reuses the same-process-instance row on a husk retry", async () => {
+  const { app, inserts, updates, rows } = fakeApp();
+  const roundsStore = (rows.rounds ??= new Map());
+  // This run's own round-4 row, plus an UNRELATED prior run's round-4 row.
+  roundsStore.set(400, {
+    id: 400,
+    pr_key: "o/r#1",
+    round_no: 4,
+    status: "addressed",
+    summary: "other run",
+    process_instance_key: "proc-OTHER",
+  });
+  roundsStore.set(401, {
+    id: 401,
+    pr_key: "o/r#1",
+    round_no: 4,
+    status: "addressed",
+    summary: "this run first attempt",
+    process_instance_key: "proc-THIS",
+  });
+
+  const retry = {
+    processInstanceKey: "proc-THIS",
+    variables: { prKey: "o/r#1", round: 4, status: "addressed", summary: "this run husk retry" },
+  };
+  await handler(retry as any, app as any);
+
+  assertEquals(inserts.rounds.length, 0, "no new row — this run's own row is reused");
+  const roundUpdate = (updates.rounds ?? []).at(-1) as any;
+  assertEquals(roundUpdate?.key, 401, "the reused row is THIS run's row, not the other run's");
+  assertEquals(roundUpdate?.patch.summary, "this run husk retry");
+  assertEquals((roundsStore.get(400) as any).summary, "other run", "the unrelated run's row is untouched");
+});

package/app/pullRequestReadModel.test.ts

@@ -33,7 +33,7 @@ import {
 const MIG = (name: string) => readFileSync(fileURLToPath(new URL(`../db/migrations/${name}`, import.meta.url)), "utf8");
 const PAGE = (name: string) => JSON.parse(readFileSync(fileURLToPath(new URL(`../pages/${name}`, import.meta.url)), "utf8"));
 
-const READ_MODEL_MIGRATION = "094_pull_requests_read_model.sql";
+const READ_MODEL_MIGRATION = "104_pull_requests_read_model_progress_idempotency.sql";
 
 // The real base `pull_requests` columns, in schema order — DERIVED from the migration chain (not a
 // hand-kept list that could silently omit one), used by both the drift guard and the e2e stand-in.

package/app/reviewWait.test.ts

@@ -13,6 +13,13 @@ import {
   reviewWaitTimeout,
 } from "./reviewWait.ts";
 
+test("DEFAULT_REVIEW_WAIT_TIMEOUT: pins the user-visible default to PT30M", () => {
+  // A direct regression guard on the literal default — the fallback-based assertions below compare
+  // against DEFAULT_REVIEW_WAIT_TIMEOUT itself, so they would still pass if it were accidentally
+  // reverted to PT20M. This anchors the intended value so that change is caught.
+  assertEquals(DEFAULT_REVIEW_WAIT_TIMEOUT, "PT30M");
+});
+
 test("reviewWaitTimeout: blank / absent / malformed → default", () => {
   assertEquals(reviewWaitTimeout(undefined), DEFAULT_REVIEW_WAIT_TIMEOUT);
   assertEquals(reviewWaitTimeout(""), DEFAULT_REVIEW_WAIT_TIMEOUT);

package/app/reviewWait.ts

@@ -12,7 +12,7 @@
 
 /** Default review-wait timeout (ISO-8601 duration): how long the loop waits for a fresh review
  * before the timer arm of the event-based gateway fires and it escalates to a human. */
-export const DEFAULT_REVIEW_WAIT_TIMEOUT = "PT20M";
+export const DEFAULT_REVIEW_WAIT_TIMEOUT = "PT30M";
 
 // A pragmatic ISO-8601 duration matcher: requires a leading `P`, at least one component, and a
 // `T` before any time components (with at least one time component after it). Good enough to