@nanobpm/nano-workforce 0.198.1 → 0.200.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.200.0](https://github.com/nanobpm/nano-workforce/compare/v0.199.0...v0.200.0) (2026-10-02)
+
+### Features
+
+* **convergence:** local adversarial-review agent pass before Copilot ([#845](https://github.com/nanobpm/nano-workforce/issues/845)) ([3aec0da](https://github.com/nanobpm/nano-workforce/commit/3aec0da99224dd29f43566a9c75a5cf34dbc843a)), closes [#842](https://github.com/nanobpm/nano-workforce/issues/842) [#844](https://github.com/nanobpm/nano-workforce/issues/844) [#844](https://github.com/nanobpm/nano-workforce/issues/844) [#844](https://github.com/nanobpm/nano-workforce/issues/844) [#822](https://github.com/nanobpm/nano-workforce/issues/822)
+
+## [0.199.0](https://github.com/nanobpm/nano-workforce/compare/v0.198.1...v0.199.0) (2026-10-02)
+
+### Features
+
+* **review-round:** fix the bug class + self-review before push; heredoc result examples ([#843](https://github.com/nanobpm/nano-workforce/issues/843)) ([0b2f26f](https://github.com/nanobpm/nano-workforce/commit/0b2f26f817f15191ef530075d34f6131c99e43cb)), closes [#842](https://github.com/nanobpm/nano-workforce/issues/842)
+
 ## [0.198.1](https://github.com/nanobpm/nano-workforce/compare/v0.198.0...v0.198.1) (2026-10-02)
 
 ### Bug Fixes

package/SPEC.md

@@ -110,7 +110,13 @@ known at submit time, carried as a process variable and stored on the DB row.
 │      │                                 → [Escalate: unaddressed comments] (blocked)             │
 │      │                                 → [Wait: wait-answer userTask] ────────────────────────────┤
 │      │                                                                                          │
-│      ├── addressed  → [Record round] → [Check progress] (did the PR head advance?)              │
+│      ├── addressed  → <adversarial pass due? (#844)>                                             │
+│      │  (or waiting)    ├── pass due (addressed, or first push; budget unspent)                  │
+│      │                  │      → [Adversarial review] (service task, taskType: senior:adversarial-review) │
+│      │                  │          → <findings?> ── findings → re-dispatch [Review round] (round unchanged) │
+│      │                  │                          └── clean → [Record round]                    │
+│      │                  └── disabled / budget spent → [Record round]                             │
+│      │                        [Record round] → [Check progress] (did the PR head advance?)       │
 │      │                   ├── progressed → <guard: round ≥ maxRounds → escalate "not converged"> │
 │      │                   │                   → <event-based gateway: review ready or timeout?>   │
 │      │                   │      ├── readiness-ready (msg catch, key = prKey) → round++ ─┐        │
@@ -139,6 +145,21 @@ step, then retry the same round with the human's `answer`. They differ only by e
 which the UI uses to label the card. Neither ends the run — a human always gets
 a chance to unblock and resume.
 
+**Local adversarial-review stage (issue #844).** Before an `addressed` or first-push
+`waiting` round parks on `waiting_review` (the only status the poller solicits a Copilot
+review for), the loop runs a bounded local adversarial pass over the round's diff. The
+`<adversarial pass due?>` gate (`gw-adv-due`) fires when the per-round budget is unspent
+and the round is `addressed` **or** the first push (`advMax != null and advPass < advMax
+and (status != "waiting" or round = 1)`); otherwise (disabled, budget spent) it skips
+straight to `[Record round]`. The `senior:adversarial-review` service task (prompt
+delivered via the `prompts/adversarial-review.md` linked resource) critiques the diff and
+returns `adversarialFindings`. Non-blank findings **re-dispatch `[Review round]` within the
+same round** (round unchanged) with `adversarialFindings` seeded, so the agent fixes them
+before this app's poller solicits the Copilot review (the only `waiting_review` trigger); a
+clean result records the round and proceeds to `[Check progress]`. The pass budget is
+`MAX_ADVERSARIAL_PASSES` (default 1,
+`NANO_PR_MAX_ADVERSARIAL_PASSES=0` disables the stage).
+
 **Durable adjudication auto-resume (issue #806).** A human's answer to a `wait-answer`
 is remembered durably, keyed by `(PR, canonical question fingerprint)` — the
 `record-answer` step persists it (`pr_adjudications`), and before the poller surfaces a
@@ -350,6 +371,7 @@ Notes:
 | `prNumber` | int | |
 | `round` | int | 1-based round counter |
 | `answer` | string? | present only when resuming from an escalation |
+| `adversarialFindings` | string? | present only when the local adversarial-review stage (§4) produced findings on this round's push — the agent is re-dispatched within the same round to address them |
 
 The base instructions are **not** a job variable: they are delivered as a
 **linked resource** on the `senior:pr-review` task —

package/app/contracts.ts

@@ -140,6 +140,14 @@ export const ENV_CONTRACTS = {
       "Maximum bounded review-round re-dispatches the convergence loop makes to auto-ack unacked suppressed advisories before escalating to a human (#796); 0 escalates on the first ack-only block.",
     default: "2",
   },
+  NANO_PR_MAX_ADVERSARIAL_PASSES: {
+    category: "env",
+    name: "NANO_PR_MAX_ADVERSARIAL_PASSES",
+    owner: "app/service.ts",
+    semantics:
+      "Maximum local adversarial-review agent passes per convergence round before the round parks for a Copilot review (#844); non-blank findings re-dispatch review-round. 0 disables the stage.",
+    default: "1",
+  },
   NANO_PR_MAX_MERGE_STALL_ROUNDS: {
     category: "env",
     name: "NANO_PR_MAX_MERGE_STALL_ROUNDS",

package/app/convergeAdversarial.test.ts

@@ -0,0 +1,294 @@
+// Behavioural coverage for the local adversarial-review pass on the convergence loop's ADDRESSED
+// path (issue #844, sub-issue of #842).
+//
+// Copilot had become our discovery loop: each finding costs a full GitHub re-review round, and many
+// are the obvious "next" finding a second reader would catch locally. So an `addressed` round now
+// runs a separate `senior:adversarial-review` agent BEFORE the round is persisted / parked on
+// `waiting_review` (the only status the poller solicits a Copilot review for). Non-blank findings
+// loop straight back into `review-round` (carrying `adversarialFindings`) — not through
+// `capture-head`, so the round-entry head and the no-progress check still span the whole round.
+// The pass count is BOUNDED per round by `advPass`/`advMax` and reset when a new review lands.
+//
+// These deploy the committed convergence-loop into the real WASM engine and drive tokens through it,
+// asserting what the loop DOES (element run counts, job inputs, the parked wait), not how it is drawn.
+import { after, test } from "node:test";
+import { assert } from "#test-assert";
+import { readFileSync } from "node:fs";
+import { assertThatInstance, byProcessId, createWasmEngineClient, type WasmEngineClient } from "@nanobpm/urban-testkit";
+
+const MODEL = readFileSync("resources/processes/convergence-loop.bpmn", "utf8");
+
+type Output = Record<string, unknown>;
+type Job = { variables: Record<string, unknown> };
+type Responder = Output | Output[] | ((job: Job) => Output);
+
+const ALL_JOB_TYPES = [
+  "senior:pr-review",
+  "senior:adversarial-review",
+  "pr.capture-head",
+  "pr.persist-round",
+  "pr.progress-check",
+  "pr.converge-gate",
+  "senior:scope-classify",
+  "pr.finalize",
+  "pr.persist-escalation",
+  "pr.answer-escalation",
+] as const;
+
+const FINDINGS = "Open: src/a.ts:10 fail-open on unknown input (high)";
+const CLEAN = { adversarialFindings: "", adversarialSummary: "no findings" };
+
+const DEFAULT_RESPONSES: Record<string, Responder> = {
+  "senior:pr-review": { status: "addressed", summary: "fixed" },
+  "senior:adversarial-review": CLEAN,
+  "pr.capture-head": { roundEntryHead: "sha-entry" },
+  "pr.persist-round": {},
+  "pr.progress-check": { progressed: true },
+  "pr.converge-gate": { convergeBlocked: false, convergeBlockReason: "", convergeAckOnly: false },
+  "senior:scope-classify": { scopeBlocked: false, scopeBlockReason: "" },
+  "pr.finalize": {},
+  "pr.persist-escalation": { escalated: true },
+  "pr.answer-escalation": {},
+};
+
+const DEFAULT_VARS: Record<string, unknown> = {
+  prKey: "o/r#1",
+  repo: "o/r",
+  prNumber: 1,
+  prUrl: "https://example.test/pr/1",
+  round: 1,
+  maxRounds: 20,
+  reviewWaitTimeout: "PT30M",
+  ackRetryRound: 0,
+  ackRetryMax: 2,
+  advPass: 0,
+  advMax: 1,
+  abandonBrief: null,
+  status: null,
+  question: null,
+  summary: null,
+  answer: null,
+  scopePending: false,
+  scopeAnswer: null,
+  convergeBlocked: null,
+  convergeBlockReason: null,
+  convergeAckOnly: null,
+  reviewStale: null,
+  roundEntryHead: null,
+  huskRetries: 0,
+  progressed: true,
+  escalated: null,
+};
+
+const engines: WasmEngineClient[] = [];
+after(async () => {
+  await Promise.all(engines.map((e) => e.close()));
+});
+
+/** Boot the loop; records every job's input variables per job type for assertions. */
+async function boot(opts: { responses?: Record<string, Responder>; vars?: Record<string, unknown> } = {}) {
+  const engine = await createWasmEngineClient();
+  engines.push(engine);
+  await engine.deployResources([{ name: "convergence-loop.bpmn", content: MODEL, contentType: "text/xml" }]);
+  const responses = { ...DEFAULT_RESPONSES, ...(opts.responses ?? {}) };
+  const seen: Record<string, Record<string, unknown>[]> = {};
+  for (const jobType of ALL_JOB_TYPES) {
+    const responder = responses[jobType];
+    const queue = Array.isArray(responder) ? [...responder] : null;
+    seen[jobType] = [];
+    await engine.registerWorker(jobType, (job) => {
+      seen[jobType].push({ ...(job as Job).variables });
+      if (queue) return queue.length > 1 ? queue.shift()! : (queue[0] ?? {});
+      if (typeof responder === "function") return responder(job as Job);
+      return responder ?? {};
+    });
+  }
+  await engine.createInstance({
+    processDefinitionId: "convergence-loop",
+    awaitCompletion: false,
+    variables: { ...DEFAULT_VARS, ...(opts.vars ?? {}) },
+  });
+  return { engine, seen };
+}
+
+function completions(engine: WasmEngineClient, elementId: string): number {
+  const snap = engine.snapshot() as { elementStats?: { elementId: string; completed: number }[] };
+  return (snap.elementStats ?? []).find((s) => s.elementId === elementId)?.completed ?? 0;
+}
+function instanceVars(engine: WasmEngineClient): Record<string, unknown> {
+  const snap = engine.snapshot() as { instances?: { variables?: Record<string, unknown> }[] };
+  return snap.instances?.[0]?.variables ?? {};
+}
+function runs(engine: WasmEngineClient): string {
+  return ["review-round", "adversarial-review", "persist-round", "check-progress"]
+    .map((id) => `${id}=${completions(engine, id)}`)
+    .join(" ");
+}
+
+test("addressed + adversarial findings loop back into review-round with the findings, then park for Copilot", async () => {
+  const { engine, seen } = await boot({
+    responses: { "senior:adversarial-review": [{ adversarialFindings: FINDINGS, adversarialSummary: "1 finding" }, CLEAN] },
+    vars: { advMax: 2 },
+  });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "review-round") === 2, `review-round should run twice: ${runs(engine)}`);
+  assert(completions(engine, "adversarial-review") === 2, `adversarial-review should run twice: ${runs(engine)}`);
+  // The round is persisted and progress-checked ONCE, only after the adversarial pass came back clean.
+  assert(completions(engine, "persist-round") === 1, `persist-round once: ${runs(engine)}`);
+  assert(completions(engine, "check-progress") === 1, `check-progress once: ${runs(engine)}`);
+  // The loop goes straight back to review-round, not through capture-head (round-entry head kept).
+  assert(completions(engine, "capture-head") === 1, "the findings loop must not re-capture the round-entry head");
+  const reviewJobs = seen["senior:pr-review"];
+  assert(!reviewJobs[0].adversarialFindings, "the first review-round has no adversarial findings");
+  assert(reviewJobs[1].adversarialFindings === FINDINGS, "the re-dispatched review-round receives the findings");
+  // Parked on the Copilot review wait (the poller solicits only after progress-check parks it).
+  assert(completions(engine, "wait-review") === 0, "must be parked waiting for the review");
+});
+
+test("a clean adversarial pass proceeds straight to persist-round", async () => {
+  const { engine } = await boot();
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "review-round") === 1, runs(engine));
+  assert(completions(engine, "adversarial-review") === 1, runs(engine));
+  assert(completions(engine, "persist-round") === 1, runs(engine));
+});
+
+// Regression for Copilot review 5386944381 (round 5): the round-4 verdict reset on
+// `adversarial-review` was UNCONDITIONAL, so it also fired on the clean/default arm
+// (`f_advClean` -> `persist-round`). A first-round `waiting` verdict was therefore blanked before
+// `pr.progress-check` ran; the real worker classifies a blank status as `addressed`, and because the
+// head did not change it routed the initial pass to no-progress escalation instead of parking on
+// `waiting_review` for Copilot. The reset must be findings-ONLY: a clean pass must PRESERVE the
+// review-round verdict (status/summary/question) all the way to persist-round.
+test("a clean adversarial pass preserves a first-round waiting verdict for progress-check", async () => {
+  const { engine, seen } = await boot({
+    responses: {
+      "senior:pr-review": { status: "waiting", summary: "no review yet" },
+      "senior:adversarial-review": CLEAN,
+    },
+  });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "adversarial-review") === 1, runs(engine));
+  assert(completions(engine, "persist-round") === 1, runs(engine));
+  // The clean pass must NOT blank the verdict: persist-round / progress-check see `waiting`, so the
+  // worker parks the PR on `waiting_review` (the only status the poller solicits a review for).
+  const recorded = seen["pr.persist-round"][0];
+  assert(
+    recorded.status === "waiting",
+    `a clean pass must preserve the waiting verdict; status reaching persist-round: ${JSON.stringify(recorded.status)}`,
+  );
+  const progress = seen["pr.progress-check"][0];
+  assert(
+    progress.status === "waiting",
+    `progress-check must see the waiting verdict, not a blanked one: ${JSON.stringify(progress.status)}`,
+  );
+});
+
+test("the adversarial pass is bounded by advMax per round", async () => {
+  const { engine } = await boot({
+    responses: { "senior:adversarial-review": { adversarialFindings: FINDINGS, adversarialSummary: "always" } },
+    vars: { advMax: 2 },
+  });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "adversarial-review") === 2, `cap of 2 passes: ${runs(engine)}`);
+  // 1 initial + 2 findings loops = 3 review-rounds, then the round proceeds despite findings.
+  assert(completions(engine, "review-round") === 3, runs(engine));
+  assert(completions(engine, "persist-round") === 1, runs(engine));
+});
+
+test("advMax=0 disables the adversarial pass", async () => {
+  const { engine } = await boot({ vars: { advMax: 0 } });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "adversarial-review") === 0, runs(engine));
+  assert(completions(engine, "persist-round") === 1, runs(engine));
+});
+
+test("an instance seeded without advPass/advMax (pre-#844 shape) skips the pass, no incident", async () => {
+  const { engine } = await boot({ vars: { advPass: null, advMax: null } });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "adversarial-review") === 0, runs(engine));
+  assert(completions(engine, "persist-round") === 1, runs(engine));
+});
+
+// The FIRST push (#844): a PR enters the loop with no Copilot review yet, so round 1 returns
+// `waiting`. That never-reviewed head is exactly what Copilot would review first, so the adversarial
+// pass runs on it too — before progress-check parks the PR on `waiting_review` (which is what makes
+// the poller solicit the initial Copilot review). This covers every PR entering convergence
+// (feature runs, plan fan-out slices, human-submitted PRs) from the one canonical stage.
+test("the first push (round 1, no review yet) gets an adversarial pass before Copilot is solicited", async () => {
+  const { engine, seen } = await boot({
+    responses: {
+      "senior:pr-review": [{ status: "waiting", summary: "no review yet" }, { status: "addressed", summary: "fixed finding" }],
+      "senior:adversarial-review": [{ adversarialFindings: FINDINGS, adversarialSummary: "1 finding" }],
+    },
+  });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "adversarial-review") === 1, `first push must be adversarially reviewed: ${runs(engine)}`);
+  assert(completions(engine, "review-round") === 2, `findings must re-dispatch review-round: ${runs(engine)}`);
+  assert(seen["senior:pr-review"][1].adversarialFindings === FINDINGS, "the re-dispatch carries the findings");
+  assert(completions(engine, "persist-round") === 1, runs(engine));
+  assert(completions(engine, "capture-head") === 1, "no head re-capture within the round");
+});
+
+test("a later waiting round (round > 1, review still pending) does not re-run the adversarial pass", async () => {
+  const { engine } = await boot({
+    vars: { round: 2 },
+    responses: { "senior:pr-review": { status: "waiting", summary: "review pending" } },
+  });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "adversarial-review") === 0, runs(engine));
+  assert(completions(engine, "persist-round") === 1, runs(engine));
+});
+
+// Issue #822 husk failure mode ON THE FINDINGS BACK-EDGE: the `f_advFindings` edge re-dispatches
+// `review-round` straight from `gw-adv-result`, bypassing `capture-head` — so it must not inherit the
+// PRIOR review-round's verdict. Here round 1 returns `waiting` (no review yet), the adversarial pass
+// finds a finding, and the re-dispatched `review-round` HUSKS (completes with NO result vars). If the
+// back-edge does not reset the round's output vars, the stale `status="waiting"` survives into
+// gw-status / persist-round even though the findings were never handled. The back-edge must clear
+// `status`/`summary`/`question` (a findings-only reset) while PRESERVING `roundEntryHead`, `advPass`
+// and `adversarialFindings` (so the budget and the findings survive the re-dispatch).
+test("a husked re-dispatch on the findings back-edge does not reuse the prior round's verdict", async () => {
+  const { engine, seen } = await boot({
+    responses: {
+      // Round 1 review-round: waiting (no review yet). Re-dispatched review-round: HUSK ({}).
+      "senior:pr-review": [{ status: "waiting", summary: "no review yet" }, {}],
+      "senior:adversarial-review": [{ adversarialFindings: FINDINGS, adversarialSummary: "1 finding" }],
+    },
+    vars: { advMax: 1 },
+  });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  assert(completions(engine, "review-round") === 2, `findings re-dispatch review-round: ${runs(engine)}`);
+  assert(completions(engine, "adversarial-review") === 1, runs(engine));
+  assert(completions(engine, "persist-round") === 1, runs(engine));
+  // The findings survived the re-dispatch (the husked review-round received them)...
+  assert(seen["senior:pr-review"][1].adversarialFindings === FINDINGS, "the re-dispatch carries the findings");
+  // ...and the pass budget was consumed (advPass incremented, NOT reset to 0 by a capture-head re-entry).
+  assert(instanceVars(engine).advPass === 1, `advPass preserved across the back-edge: ${instanceVars(engine).advPass}`);
+  // ...but the stale `waiting` verdict did NOT reach persist-round: the back-edge reset it to blank,
+  // so the round is recorded on the safe default rather than the inherited `waiting`.
+  const recorded = seen["pr.persist-round"][0];
+  assert(
+    recorded.status == null || recorded.status === "",
+    `a husked re-dispatch must not record the stale verdict; status reaching persist-round: ${JSON.stringify(recorded.status)}`,
+  );
+});
+
+test("a converged round does not run the adversarial pass", async () => {
+  const { engine } = await boot({ responses: { "senior:pr-review": { status: "converged", summary: "done" } } });
+  assertThatInstance(engine, byProcessId("convergence-loop")).hasCompleted().hasNoIncident();
+  assert(completions(engine, "adversarial-review") === 0, runs(engine));
+});
+
+test("the pass budget resets when the next review lands (new round)", async () => {
+  const { engine } = await boot({
+    responses: { "senior:adversarial-review": { adversarialFindings: FINDINGS, adversarialSummary: "always" } },
+    vars: { advMax: 1 },
+  });
+  assert(completions(engine, "adversarial-review") === 1, runs(engine));
+  assert(instanceVars(engine).advPass === 1, `advPass after round 1: ${instanceVars(engine).advPass}`);
+  await engine.publishMessage({ name: "readiness-ready", correlationKey: "o/r#1", variables: { ready: true } });
+  assertThatInstance(engine, byProcessId("convergence-loop")).isActive().hasNoIncident();
+  // Round 2 gets its own full budget of 1 pass.
+  assert(completions(engine, "adversarial-review") === 2, `round 2 must get a fresh pass: ${runs(engine)}`);
+});

package/app/roundProgress.test.ts

@@ -945,8 +945,14 @@ test("the round-cap guard is downstream of progress classification, so a husk au
   const retry = flowElement("f_huskRetry");
   assert(retry, "f_huskRetry flow missing");
   assertStringIncludes(retry, 'targetRef="capture-head"');
-  // The addressed/waiting status arms feed persist-round directly (not the guard).
+  // (#844: the addressed AND waiting arms detour through the bounded adversarial gate, whose arms all
+  // land on persist-round or loop to review-round — never gw-guard.)
   for (const id of ["f_addressed", "f_waiting"]) {
+    const f = flowElement(id);
+    assert(f, `${id} flow missing`);
+    assertStringIncludes(f, 'targetRef="gw-adv-due"');
+  }
+  for (const id of ["f_advSkip", "f_advClean"]) {
     const f = flowElement(id);
     assert(f, `${id} flow missing`);
     assertStringIncludes(f, 'targetRef="persist-round"');

package/app/roundResultDefault.test.ts

@@ -77,14 +77,35 @@ test("escalation is an explicit needs_input/blocked arm gated on a non-blank que
 test("the default (addressed) arm carries no condition and re-enters round processing", () => {
   const addressed = flowElement("f_addressed");
   assert(addressed, "f_addressed flow missing");
-  assertStringIncludes(addressed, 'targetRef="persist-round"');
+  // #844: the addressed arm first passes the (bounded) local adversarial-review gate, whose
+  // unconditional defaults — budget spent / findings clean — both land on round processing.
+  assertStringIncludes(addressed, 'targetRef="gw-adv-due"');
   // A default flow must have NO conditionExpression.
   assert(
     !/conditionExpression/.test(addressed),
     "f_addressed is the default flow and must not carry a conditionExpression",
   );
+  assertAdversarialDefaultsReenterRound();
 });
 
+/** The adversarial-review detour (#844) on the addressed arm must always drain to round
+ * processing: both gateways' DEFAULT arms are unconditional and target persist-round, and the only
+ * conditional arm loops back into review-round (bounded by advPass/advMax) — never escalation. */
+function assertAdversarialDefaultsReenterRound() {
+  for (const [gw, dflt] of [["gw-adv-due", "f_advSkip"], ["gw-adv-result", "f_advClean"]]) {
+    const g = flat.match(new RegExp(`<bpmn:exclusiveGateway\\b[^>]*\\bid="${gw}"[^>]*>`));
+    assert(g, `${gw} gateway missing`);
+    assertStringIncludes(g[0], `default="${dflt}"`);
+    const f = flowElement(dflt);
+    assert(f, `${dflt} flow missing`);
+    assertStringIncludes(f, 'targetRef="persist-round"');
+    assert(!/conditionExpression/.test(f), `${dflt} is a default arm and must not carry a condition`);
+  }
+  const loop = flowElement("f_advFindings");
+  assert(loop, "f_advFindings flow missing");
+  assertStringIncludes(loop, 'targetRef="review-round"');
+}
+
 test("regression: an empty/unknown status no longer routes to persist-escalation", () => {
   // Escalation is reachable ONLY via an explicit condition (the needs_input/blocked arm),
   // never as a catch-all default. Enumerate EVERY sequenceFlow into `persist-escalation`
@@ -98,7 +119,8 @@ test("regression: an empty/unknown status no longer routes to persist-escalation
   // The addressed default must land on round processing (persist-round → check-progress, which
   // re-solicits the review after the round-cap gate downstream), not escalation.
   const addressed = flowElement("f_addressed");
-  assert(addressed && /targetRef="persist-round"/.test(addressed), "default arm must re-enter round processing");
+  assert(addressed && /targetRef="gw-adv-due"/.test(addressed), "default arm must re-enter round processing");
+  assertAdversarialDefaultsReenterRound();
 });
 
 // The canonical router (app/roundResultDefault.ts) mirrors the gw-status routing above, with the

package/app/service.test.ts

@@ -11,7 +11,7 @@ import { memDataFor } from "../test/worldDb.ts";
 import { withTrackingViews } from "../test/trackingViews.ts";
 import { DurableResumeRegistry } from "./durableResume.ts";
 import { WorldStore } from "./world/index.ts";
-import { abandonClosedPr, isPrSettled, MAX_ACK_RETRIES, parsePr, pollCapabilityGatesImpl, pollIncidentsImpl, pollReviews, pollWaveGatesImpl, repoEnvelopeVars, startMerge, submitPr, worldRestoreSha } from "./service.ts";
+import { abandonClosedPr, isPrSettled, MAX_ACK_RETRIES, MAX_ADVERSARIAL_PASSES, parsePr, pollCapabilityGatesImpl, pollIncidentsImpl, pollJobActivationImpl, pollReviews, pollWaveGatesImpl, repoEnvelopeVars, startMerge, submitPr, worldRestoreSha } from "./service.ts";
 import { trackingTargetFor } from "./instanceTracking.ts";
 import type { DataLayer } from "@nanobpm/urban";
 import { READINESS_READY_MESSAGE } from "./readiness.ts";
@@ -669,6 +669,168 @@ test("pollIncidents picks the oldest incident by creationTime, sorting a missing
 });
 
 
+// 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
+// issue #844, `adversarial-review` (`senior:adversarial-review`). `pollJobActivation` originally
+// searched only for `senior:pr-review`, so during an adversarial pass it found no matching job and
+// cleared `active_worker`/`lease_until` — the Home/Overview grids reported "queued" while an agent
+// was actively working. This drives the pass's reconciliation core against a stubbed
+// `/v2/jobs/search`:
+//   1. an activated `senior:adversarial-review` job surfaces its leasing worker (the defect),
+//   2. the review-round → adversarial-review handoff keeps a live worker visible across the switch,
+//   3. a non-agent job (an internal `pr.*` worker) is defensively excluded even if the wire `$in`
+//      filter is ignored,
+//   4. a merely-created (unactivated) agent job — no `worker` yet — reads as "queued" (lease null).
+function jobActivationFetch(byInstance: Record<string, unknown[]>, opts: { ignoreTypeFilter?: boolean } = {}) {
+  return (url: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    const u = typeof url === "string" ? url : url.toString();
+    if (!u.endsWith("/jobs/search")) {
+      throw new Error(`unexpected fetch: ${u}`);
+    }
+    const body = JSON.parse(String(init?.body ?? "{}")) as {
+      filter?: { processInstanceKey?: string; type?: string | { $in?: string[] } };
+    };
+    const all = (byInstance[body.filter?.processInstanceKey ?? ""] ?? []) as { type?: string }[];
+    // Honor the wire `type` filter (scalar `$eq` or `{ $in: [...] }`) the way the engine does, so the
+    // test reproduces the real defect: a single-type `senior:pr-review` filter returns ZERO items for
+    // an adversarial-pass job (the engine filters server-side), which is exactly what cleared the
+    // lease pre-fix. A stub that ignores `type` would pass against the old code and prove nothing.
+    // `ignoreTypeFilter` simulates an engine that IGNORES the `$in` filter, so the non-agent item
+    // reaches `pollJobActivationImpl` and the test exercises the defensive client-side `.includes`
+    // re-filter (service.ts) rather than the wire filter doing the work.
+    const t = body.filter?.type;
+    const wanted: string[] | null = typeof t === "string" ? [t] : Array.isArray(t?.$in) ? t.$in : null;
+    const items = opts.ignoreTypeFilter || wanted == null ? all : all.filter((j) => wanted.includes(j.type ?? ""));
+    return Promise.resolve(
+      new Response(JSON.stringify({ items }), { status: 200, headers: { "content-type": "application/json" } }),
+    );
+  };
+}
+
+function jobActivationData(rows: unknown[]) {
+  const stores: Record<string, { rows: unknown[]; key: string }> = {
+    pull_requests: { rows, key: "pr_key" },
+  };
+  return {
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+    open: () => memOpen(stores),
+  } as any;
+}
+
+test("pollJobActivation surfaces an activated adversarial-review agent (not just senior:pr-review)", async () => {
+  const row = {
+    pr_key: "owner/repo#20",
+    status: "converging",
+    process_key: "PI-20",
+    active_worker: null as string | null,
+    lease_until: null as string | null,
+    updated_at: "t0",
+  };
+  const data = jobActivationData([row]);
+  const headers = { "content-type": "application/json" };
+
+  const prevFetch = globalThis.fetch;
+  // The PR is mid adversarial pass: the only open job is `senior:adversarial-review`, leased by a
+  // worker. Before the fix the pass filtered on `senior:pr-review` alone, found nothing, and left
+  // `active_worker` null — the grid showed "queued" while this agent was actively working.
+  globalThis.fetch = jobActivationFetch({
+    "PI-20": [
+      { type: "senior:adversarial-review", worker: "agent-adv", deadline: "2024-01-01T00:15:00Z", state: "CREATED" },
+    ],
+  }) as typeof fetch;
+  try {
+    await pollJobActivationImpl(data, "http://engine/v2", headers);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(row.active_worker, "agent-adv");
+  assertEquals(row.lease_until, "2024-01-01T00:15:00Z");
+});
+
+test("pollJobActivation keeps a live worker visible across the review-round ↔ adversarial handoff", async () => {
+  const row = {
+    pr_key: "owner/repo#21",
+    status: "converging",
+    process_key: "PI-21",
+    active_worker: null as string | null,
+    lease_until: null as string | null,
+    updated_at: "t0",
+  };
+  const data = jobActivationData([row]);
+  const headers = { "content-type": "application/json" };
+
+  const prevFetch = globalThis.fetch;
+  try {
+    // Leg 1: the review-round agent (`senior:pr-review`) is working.
+    globalThis.fetch = jobActivationFetch({
+      "PI-21": [
+        { type: "senior:pr-review", worker: "agent-review", deadline: "2024-01-01T00:10:00Z", state: "CREATED" },
+      ],
+    }) as typeof fetch;
+    await pollJobActivationImpl(data, "http://engine/v2", headers);
+    assertEquals(row.active_worker, "agent-review");
+
+    // Leg 2: the loop handed off to the adversarial pass (`senior:adversarial-review`) — same
+    // `converging` status, different job type. The grid must keep showing "agent working", not
+    // flash "queued".
+    globalThis.fetch = jobActivationFetch({
+      "PI-21": [
+        { type: "senior:adversarial-review", worker: "agent-adv", deadline: "2024-01-01T00:20:00Z", state: "CREATED" },
+      ],
+    }) as typeof fetch;
+    await pollJobActivationImpl(data, "http://engine/v2", headers);
+    assertEquals(row.active_worker, "agent-adv");
+    assertEquals(row.lease_until, "2024-01-01T00:20:00Z");
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+});
+
+test("pollJobActivation excludes a non-agent job and reports an unactivated agent job as queued", async () => {
+  const row = {
+    pr_key: "owner/repo#22",
+    status: "converging",
+    process_key: "PI-22",
+    active_worker: "stale-worker" as string | null,
+    lease_until: "2024-01-01T00:05:00Z" as string | null,
+    updated_at: "t0",
+  };
+  const data = jobActivationData([row]);
+  const headers = { "content-type": "application/json" };
+
+  const prevFetch = globalThis.fetch;
+  try {
+    // An internal `pr.*` worker job is open and "leased" — but it is not a convergence agent, so it
+    // must NOT keep `active_worker` lit even if the engine ignores the wire `$in` type filter. Pass
+    // `ignoreTypeFilter` so the mock returns the non-agent item UNFILTERED (an engine that ignores
+    // `$in`): the defensive client-side `.includes(j.type)` re-filter in `pollJobActivationImpl` is
+    // then what excludes it — so the assertion genuinely guards that branch (a wire-filtered stub
+    // would pass even if the defensive check were deleted).
+    globalThis.fetch = jobActivationFetch(
+      {
+        "PI-22": [
+          { type: "pr.capture-head", worker: "host-internal", deadline: "2024-01-01T00:30:00Z", state: "CREATED" },
+        ],
+      },
+      { ignoreTypeFilter: true },
+    ) as typeof fetch;
+    await pollJobActivationImpl(data, "http://engine/v2", headers);
+    assertEquals(row.active_worker, null);
+    assertEquals(row.lease_until, null);
+
+    // A merely-created (queued) agent job carries no worker yet → still "queued" (lease null).
+    globalThis.fetch = jobActivationFetch({
+      "PI-22": [{ type: "senior:adversarial-review", state: "CREATED" }],
+    }) as typeof fetch;
+    await pollJobActivationImpl(data, "http://engine/v2", headers);
+    assertEquals(row.active_worker, null);
+    assertEquals(row.lease_until, null);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+});
+
+
 // Red/green regression (nano-workforce#102 review): the engine can hand back a numeric
 // `processInstanceKey`, but the OpenAPI `SubmitResult.processKey` contract is `string | null`, so
 // under api `validateResponses:"dev"` a raw number fails response validation. Stringifying at the
@@ -876,6 +1038,21 @@ test("submitPr seeds the #796 auto-ack budget onto the instance (ackRetryRound=0
   });
 });
 
+test("submitPr seeds the #844 adversarial-review budget (advPass=0, advMax=MAX_ADVERSARIAL_PASSES)", async () => {
+  await withGithubOff(async () => {
+    const { data, engine, get } = captureVars();
+    await submitPr(data, engine, {
+      repo: "owner/repo",
+      number: 14,
+      url: "https://github.com/owner/repo/pull/14",
+      prKey: "owner/repo#14",
+    });
+    const vars = get();
+    assertEquals(vars?.advPass, 0);
+    assertEquals(vars?.advMax, MAX_ADVERSARIAL_PASSES);
+  });
+});
+
 test("submitPr seeds humanApproval (issue #826), pinned off for a converge-only run that never merges", async () => {
   await withGithubOff(async () => {
     const pr = (n: number) => ({ repo: "owner/repo", number: n, url: `https://github.com/owner/repo/pull/${n}`, prKey: `owner/repo#${n}` });