@nanobpm/nano-workforce 0.204.1 → 0.205.1

package/app/mergeLoopBehaviour.test.ts

@@ -96,6 +96,8 @@ const DEFAULT_VARS: Record<string, unknown> = {
   mergeStatus: null,
   ciBlockedReconciled: null,
   failingChecks: 0,
+  reviewThreads: null,
+  pendingChecks: null,
   round: 2,
   abandonUrl: "http://host/app/api/hooks/abandon?token=tok-seeded",
 };
@@ -521,6 +523,133 @@ test("an unclassified verdict routes to auto-rebase (DEFAULT), not to a human (#
   assert(!openTasks.some((t) => t.elementId === "wait-merge-answer"), "the default arm must not page a human");
 });
 
+// ---------------------------------------------------------------------------
+// BLOCKED by unresolved review threads (issue #921)
+// ---------------------------------------------------------------------------
+// A PR at MERGEABLE/BLOCKED with all checks green and ≥1 unresolved review thread (branch
+// protection `required_conversation_resolution`) used to classify as "waiting": the poller never
+// published, the mergeable-wait timer fired, the stall probe re-derived the same "waiting", and
+// after the stall budget the escalation read "GitHub never settled this PR's mergeability" — when
+// GitHub HAD settled. The `review-threads` verdict now routes to a dedicated escalation that names
+// the real cause (and parks the shared `wait-merge-answer` task, whose answer re-arms the poller),
+// never to the CI-fix or rebase agents.
+
+test("a 'review-threads' verdict escalates naming the unresolved threads — never 'never settled', never an agent (#921)", async () => {
+  const engine = await boot();
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.publishMessage({
+    name: "merge-ready",
+    correlationKey: "pr-1",
+    variables: { mergeState: "review-threads", reviewThreads: 2, failingChecks: 0, failingChecksList: "" },
+  });
+  // The threads arm parks the shared answer task with the thread-specific question…
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertThatInstance(engine, byProcessId("merge-loop")).isActive().hasCompletedElements("merge-esc-threads");
+  const q = String(escalation(engine).question ?? "");
+  assertStringIncludes(q, "2 unresolved review thread(s)", "the escalation must name the actual blocker and count");
+  assert(!q.includes("never settled"), "a settled BLOCKED must never read as 'mergeability never settled'");
+  // …and never misroutes to the remediation agents or the generic conflict escalation.
+  assert(!completedElementIds(engine).has("fix-ci"), "green checks must not dispatch fix-ci");
+  assert(!completedElementIds(engine).has("rebase"), "a threads block must not dispatch rebase");
+  assert(!completedElementIds(engine).has("merge-esc-conflict"), "the threads arm has its own escalation");
+});
+
+test("answering the review-threads escalation re-arms the merge poller (#921)", async () => {
+  // The human resolves the threads on GitHub and replies; the answer re-arms `arm-merge` so the
+  // next poll re-derives mergeability — once the threads are gone the verdict flips to `ready` and
+  // the merge proceeds (the merge step is thereby gated on zero unresolved threads).
+  const engine = await boot({ responses: { "pr.merge": { mergeStatus: "merged" } } });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.publishMessage({
+    name: "merge-ready",
+    correlationKey: "pr-1",
+    variables: { mergeState: "review-threads", reviewThreads: 1, failingChecks: 0 },
+  });
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  await engine.completeUserTask(await mergeAnswerTaskKey(engine), { answer: "resolved the threads" });
+  // Re-armed at the poller wait — not merged yet (the poller must re-derive)…
+  assertThatInstance(engine, byProcessId("merge-loop")).isActive().hasActiveElement("wait-mergeable");
+  // …then the re-derived ready verdict lands the merge with no human in the loop.
+  await engine.publishMessage({ name: "merge-ready", correlationKey: "pr-1", variables: { mergeState: "ready", reviewThreads: 0 } });
+  assertThatInstance(engine, byProcessId("merge-loop")).hasCompleted().hasNoIncident().hasCompletedElements("attempt-merge", "mark-merged");
+});
+
+test("a stalled probe that re-derives 'review-threads' routes to the threads arm, not the re-poll loop (#921)", async () => {
+  // The poller-dead path: the mergeable-wait timer fires, the stall probe re-derives ground truth,
+  // and a `review-threads` verdict takes the same dedicated arm a live poller message would.
+  const engine = await boot({
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "review-threads", failingChecks: 0, failingChecksList: "", reviewThreads: 3 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("merge-stall-probe", "merge-esc-threads");
+  const q = String(escalation(engine).question ?? "");
+  assertStringIncludes(q, "3 unresolved review thread(s)", "the probe path must carry the thread count into the question");
+  assert(!completedElementIds(engine).has("wait-mergeable-repoll"), "a settled review-threads verdict must not re-poll");
+});
+
+test("a stall-budget exhaustion on a settled BLOCKED with zero threads names the review requirement, not 'never settled' (#921)", async () => {
+  // GitHub settled: MERGEABLE/BLOCKED, checks green (none failing, none pending), every thread
+  // resolved — the block is a required human review approval. The probe reports `waiting` (the
+  // conservative verdict) with the probed counts, and the exhausted-budget escalation must name
+  // THAT cause.
+  const engine = await boot({
+    vars: { mergeStallMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: 0, pendingChecks: 0 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("merge-stall-probe", "merge-esc-conflict");
+  const q = String(escalation(engine).question ?? "");
+  assertStringIncludes(q, "required review approval", "a settled BLOCKED with clear threads must name the review requirement");
+  assert(!q.includes("never settled"), "a settled BLOCKED must never read as 'mergeability never settled'");
+});
+
+test("a stall-budget exhaustion with checks still pending must NOT claim a verified review-approval blocker (PR #922 review)", async () => {
+  // Zero failing checks + zero unresolved threads, but a check is still queued/running: the BLOCKED
+  // cause is undetermined (the pending run may come back red), so the escalation must NOT assert
+  // "all checks green … required review approval" — it keeps the conservative unsettled wording.
+  const engine = await boot({
+    vars: { mergeStallMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: 0, pendingChecks: 1 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertThatInstance(engine, byProcessId("merge-loop")).hasCompletedElements("merge-stall-probe", "merge-esc-conflict");
+  const q = String(escalation(engine).question ?? "");
+  assert(!q.includes("required review approval"), "a pending check must never read as a verified review-approval block");
+  assertStringIncludes(q, "never settled", "an undetermined BLOCKED keeps the conservative unsettled wording");
+});
+
+test("the 'never settled' question is reserved for a genuinely unreadable/unsettled mergeability (#921)", async () => {
+  // mergeStallMax: 0 + a probe that still reads `waiting` with NOTHING probed (reviewThreads -1,
+  // checks unenumerable) — GitHub genuinely never settled (or the state could not be read). Only
+  // this case keeps the original message.
+  const engine = await boot({
+    vars: { mergeStallMax: 0 },
+    responses: {
+      "pr.merge-stall-probe": { mergeState: "waiting", failingChecks: 0, failingChecksList: "", reviewThreads: -1 },
+    },
+  });
+  await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });
+  await engine.advanceTime(MERGEABLE_WAIT_MS + 1);
+  await assertThatUserTask(engine, { instance: byProcessId("merge-loop"), elementId: "wait-merge-answer" }).isCreated();
+  assertStringIncludes(
+    String(escalation(engine).question ?? ""),
+    "never settled",
+    "a genuinely unsettled/unreadable mergeability keeps the original message",
+  );
+});
+
 test("an evicted queued merge re-arms the poller rather than completing", async () => {
   const engine = await boot({ responses: { "pr.merge": { mergeStatus: "queued" } } });
   await engine.publishMessage({ name: "deps-cleared", correlationKey: "pr-1" });

package/app/mergeStatus.test.ts

@@ -0,0 +1,169 @@
+// Red/green for issue #916 — the effective merge policy must be VISIBLE on every PR status row.
+//
+// The defect: whether a PR run will merge was explicit nowhere an operator looks. The
+// convergence-loop instance carried only the INVERTED legacy `convergeOnly` variable (a feature
+// run's `autoMerge: true` became `convergeOnly: false`, so searching the loop's variables for
+// `autoMerge` found nothing and it looked as if auto-merge had been dropped), and the `/status`
+// projection (`activePrs`) carried no merge-intent field at all — `waiting_merge` only appears once
+// merging has STARTED. An operator concluded auto-merge was lost and wrote `autoMerge=true` onto a
+// running loop — a no-op write, because the loop had `convergeOnly=false` from the start.
+//
+// The fix projects a structured `merge` block onto every ActivePr:
+//   merge.requested — the run's merge intent: the canonical positive `autoMerge` process variable
+//     when present, falling back to the INVERSE of the legacy `convergeOnly` variable for in-flight
+//     loops seeded before `autoMerge` existed (and to `true` — the historical default — when the
+//     instance key is unreadable or carries neither variable).
+//   merge.enabled   — the deployment's global `NANO_PR_AUTO_MERGE` switch.
+//   merge.effective — requested && enabled && !humanApproval: the run merges with no human gate.
+//   merge.blockedBy — "env" | "human-approval" | null: WHY a requested merge will not proceed.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import { withTrackingViews } from "../test/trackingViews.ts";
+import { activePrs } from "./service.ts";
+
+function memTable(rows: any[], key: string) {
+  return {
+    get: (k: any) => Promise.resolve(rows.find((r) => r[key] === k) ?? null),
+    all: () => Promise.resolve([...rows]),
+    find: (q: any) =>
+      Promise.resolve(rows.filter((r) => Object.entries(q).every(([f, v]) => r[f] === v))),
+    findOne: (q: any) =>
+      Promise.resolve(rows.find((r) => Object.entries(q).every(([f, v]) => r[f] === v)) ?? null),
+    insert: (r: any) => {
+      rows.push(r);
+      return Promise.resolve(r);
+    },
+    update: (k: any, patch: any) => {
+      const r = rows.find((x) => x[key] === k);
+      if (r) Object.assign(r, patch);
+      return Promise.resolve(r);
+    },
+    delete: (k: any) => {
+      for (let i = rows.length - 1; i >= 0; i--) if (rows[i][key] === k) rows.splice(i, 1);
+      return Promise.resolve();
+    },
+  };
+}
+
+type Stores = Record<string, { rows: any[]; key: string }>;
+
+function memData(stores: Stores) {
+  return {
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+  } as any;
+}
+
+/** A fake engine whose `searchVariables` serves the given per-instance variables. */
+function fakeEngine(varsByInstance: Record<string, Record<string, unknown>>) {
+  return {
+    searchVariables: (q: { processInstanceKey?: string; name?: string }) => {
+      const vars = varsByInstance[String(q.processInstanceKey)] ?? {};
+      return Promise.resolve(
+        Object.entries(vars)
+          .filter(([name]) => q.name == null || name === q.name)
+          .map(([name, v]) => ({ name, value: JSON.stringify(v) })),
+      );
+    },
+  } as any;
+}
+
+function prRow(over: Record<string, unknown>) {
+  return {
+    pr_key: "owner/repo#1",
+    repo: "owner/repo",
+    number: 1,
+    url: "https://github.com/owner/repo/pull/1",
+    title: "t",
+    status: "converging",
+    current_round: 1,
+    process_key: "PI-1",
+    updated_at: "2024-01-01",
+    ...over,
+  };
+}
+
+async function mergeOf(vars: Record<string, unknown>, rowOver: Record<string, unknown> = {}) {
+  return mergeOfWith({ activePrs }, vars, rowOver);
+}
+
+/** `mergeOf` against an explicitly-loaded service module — for the env-switched tests that import
+ *  a fresh copy of app/service.ts (e.g. `NANO_PR_AUTO_MERGE=0`). */
+async function mergeOfWith(
+  mod: Pick<typeof import("./service.ts"), "activePrs">,
+  vars: Record<string, unknown>,
+  rowOver: Record<string, unknown> = {},
+) {
+  const stores: Stores = {
+    pull_requests: { rows: [prRow(rowOver)], key: "pr_key" },
+    user_tasks: { rows: [], key: "id" },
+  };
+  const [pr] = await mod.activePrs(memData(stores), fakeEngine({ "PI-1": vars }));
+  return pr.merge;
+}
+
+// AUTO_MERGE is computed once at app/service.ts import time; the test env leaves NANO_PR_AUTO_MERGE
+// unset, so the global switch is ON here (the default).
+
+test("merge policy: a loop seeded autoMerge=true reads requested+effective (the #916 phantom)", async () => {
+  const merge = await mergeOf({ autoMerge: true, convergeOnly: false, humanApproval: false });
+  assertEquals(merge, { requested: true, enabled: true, effective: true, blockedBy: null });
+});
+
+test("merge policy: a legacy in-flight loop (convergeOnly only) derives requested from its inverse", async () => {
+  // Seeded BEFORE `autoMerge` existed: only the legacy inverted variable is present.
+  const review = await mergeOf({ convergeOnly: true });
+  assertEquals(review, { requested: false, enabled: true, effective: false, blockedBy: null });
+  const merging = await mergeOf({ convergeOnly: false });
+  assertEquals(merging, { requested: true, enabled: true, effective: true, blockedBy: null });
+});
+
+test("merge policy: humanApproval gates the effective merge and is named as the blocker", async () => {
+  const merge = await mergeOf({ autoMerge: true, humanApproval: true });
+  assertEquals(merge, { requested: true, enabled: true, effective: false, blockedBy: "human-approval" });
+});
+
+test("merge policy: an approved PR with finalization still pending reports no blocker (PR #917 review)", async () => {
+  // The `merge-approval` user task clears the loop's `humanApproval` variable on an explicit
+  // "approve" (convergence-loop.bpmn), so while `pr.finalize` is still queued or incidented the
+  // projection reads humanApproval=false and must NOT keep reporting a human-approval blocker for
+  // an approval that is already complete. (`status` stays non-terminal: `converged_at` is only
+  // stamped once `pr.finalize` actually runs.)
+  const merge = await mergeOf({ autoMerge: true, humanApproval: false }, { status: "converging" });
+  assertEquals(merge, { requested: true, enabled: true, effective: true, blockedBy: null });
+});
+
+test("merge policy: a review-only request reads requested=false (distinct from env/human blocking)", async () => {
+  const merge = await mergeOf({ autoMerge: false, convergeOnly: true });
+  assertEquals(merge, { requested: false, enabled: true, effective: false, blockedBy: null });
+});
+
+test("merge policy: no readable instance key (or neither variable) defaults to the historical merge default", async () => {
+  // A mid-handoff row (process_key null) or a legacy loop carrying neither variable: the pre-#916
+  // behaviour merged by default, so the projection must NOT read such a PR as review-only.
+  const stores: Stores = {
+    pull_requests: { rows: [prRow({ process_key: null })], key: "pr_key" },
+    user_tasks: { rows: [], key: "id" },
+  };
+  const [noKey] = await activePrs(memData(stores), fakeEngine({}));
+  assertEquals(noKey.merge, { requested: true, enabled: true, effective: true, blockedBy: null });
+  const bare = await mergeOf({});
+  assertEquals(bare, { requested: true, enabled: true, effective: true, blockedBy: null });
+});
+
+test("merge policy: NANO_PR_AUTO_MERGE=0 blocks a requested merge as env, never a review-only one", async () => {
+  // `AUTO_MERGE` is read once at app/service.ts import time, so load a fresh copy of the module
+  // under the env (the same pattern app/service.test.ts uses) — every other test here runs with
+  // the switch ON (the default) and none exercised `blockedBy: "env"` before this one.
+  const prev = process.env["NANO_PR_AUTO_MERGE"];
+  process.env["NANO_PR_AUTO_MERGE"] = "0";
+  try {
+    const mod: typeof import("./service.ts") = await import(`./service.ts?mergeStatusAutoMergeOff=${Date.now()}`);
+    const requested = await mergeOfWith(mod, { autoMerge: true, humanApproval: true });
+    assertEquals(requested, { requested: true, enabled: false, effective: false, blockedBy: "env" });
+    const reviewOnly = await mergeOfWith(mod, { autoMerge: false });
+    assertEquals(reviewOnly, { requested: false, enabled: false, effective: false, blockedBy: null });
+  } finally {
+    if (prev === undefined) delete process.env["NANO_PR_AUTO_MERGE"];
+    else process.env["NANO_PR_AUTO_MERGE"] = prev;
+  }
+});

package/app/readiness.ts

@@ -768,6 +768,7 @@ export function parsePrView(payload: unknown): PrObservation {
     isDraft: j.isDraft === true,
     headRefOid: str(j.headRefOid).trim() || null,
     mergeQueueEntry: null, // readiness probe doesn't read native-queue membership (merge-loop-only signal)
+    unresolvedThreads: -1, // …nor the review-threads probe (merge-stage-only signal, #921) → unprobed
     mergedSha,
     pendingChecks: pending.length,
   };

package/app/service.test.ts

@@ -1005,6 +1005,31 @@ test("submitPr defaults convergeOnly to false so the global auto-merge default g
   });
 });
 
+// Issue #916: the loop must ALSO carry the POSITIVE `autoMerge` variable — an operator searching a
+// live convergence loop's variables for `autoMerge` previously found nothing (only the inverted
+// `convergeOnly`), and concluded auto-merge had been dropped. `submitPr` seeds both, keeping them
+// consistent: `autoMerge` is canonical, `convergeOnly` its inverse mirror for in-flight compat.
+test("submitPr seeds the positive autoMerge variable alongside the convergeOnly mirror (issue #916)", 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}` });
+    // Legacy positional form: convergeOnly=true ⇒ autoMerge=false (both seeded, consistent).
+    const legacy = captureVars();
+    await submitPr(legacy.data, legacy.engine, pr(30), [], 20, true);
+    assertEquals(legacy.get()?.autoMerge, false);
+    assertEquals(legacy.get()?.convergeOnly, true);
+    // Default (no override): merge intent on — the global default governs.
+    const dflt = captureVars();
+    await submitPr(dflt.data, dflt.engine, pr(31));
+    assertEquals(dflt.get()?.autoMerge, true);
+    assertEquals(dflt.get()?.convergeOnly, false);
+    // The positive trailing form wins over the legacy alias when both are supplied.
+    const both = captureVars();
+    await submitPr(both.data, both.engine, pr(32), [], 20, true, null, false, false, true);
+    assertEquals(both.get()?.autoMerge, true);
+    assertEquals(both.get()?.convergeOnly, false);
+  });
+});
+
 // #796 auto-ack budget seeding: `submitPr` is the ONLY production write that makes the retry budget
 // available to a fresh convergence instance — the engine behaviour tests seed `ackRetryRound` /
 // `ackRetryMax` directly and never exercise `submitPr`, so a regression dropping or misconfiguring