@nanobpm/nano-workforce 0.187.5 → 0.188.0

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, parsePr, pollCapabilityGatesImpl, pollIncidentsImpl, pollWaveGatesImpl, repoEnvelopeVars, startMerge, submitPr, worldRestoreSha } from "./service.ts";
+import { abandonClosedPr, isPrSettled, MAX_ACK_RETRIES, parsePr, pollCapabilityGatesImpl, pollIncidentsImpl, pollWaveGatesImpl, repoEnvelopeVars, startMerge, submitPr, worldRestoreSha } from "./service.ts";
 import { trackingTargetFor } from "./instanceTracking.ts";
 import type { DataLayer } from "@nanobpm/urban";
 
@@ -378,6 +378,45 @@ test("submitPr defaults convergeOnly to false so the global auto-merge default g
   });
 });
 
+// #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
+// this seed would leave deployed loops on the escalation default while every added behaviour test
+// still passes. Assert both the initial counter and the configured max propagate onto the instance.
+function captureVars() {
+  const stores: Record<string, { rows: unknown[]; key: string }> = {
+    pull_requests: { rows: [], key: "pr_key" },
+    escalations: { rows: [], key: "id" },
+    pr_dependencies: { rows: [], key: "pr_key" },
+  };
+  const data = {
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+  } as any;
+  let captured: Record<string, unknown> | undefined;
+  const engine = {
+    createInstance: (req: { variables?: Record<string, unknown> }) => {
+      captured = req.variables;
+      return Promise.resolve({ processInstanceKey: "PI-1" });
+    },
+  } as any;
+  return { data, engine, get: () => captured };
+}
+
+test("submitPr seeds the #796 auto-ack budget onto the instance (ackRetryRound=0, ackRetryMax=MAX_ACK_RETRIES)", async () => {
+  await withGithubOff(async () => {
+    const { data, engine, get } = captureVars();
+    await submitPr(data, engine, {
+      repo: "owner/repo",
+      number: 10,
+      url: "https://github.com/owner/repo/pull/10",
+      prKey: "owner/repo#10",
+    });
+    const vars = get();
+    assertEquals(vars?.ackRetryRound, 0);
+    assertEquals(vars?.ackRetryMax, MAX_ACK_RETRIES);
+  });
+});
+
 // Lineage threading (issue #245): `submitPr` persists the origin `root_request_key` on the PR row
 // and carries it onto the convergence instance; `startMerge` reads it back off the row onto the
 // merge instance. A human/webhook submit that supplies no root self-roots on the `pr_key` (its own

package/app/service.ts

@@ -26,6 +26,7 @@ import {
   CONFORMANCE_ESCALATION_ELEMENT,
   conformanceEscalationQuestion,
 } from "./conformance.ts";
+import { makeDefaultReadHead } from "./currentHead.ts";
 import { isUniqueConstraintFence } from "./dbFence.ts";
 import { deriveDelivery, EPIC_LIVE_STATUSES, TERMINAL_STATUSES } from "./delivery.ts";
 import { sweepExpiredProposals } from "./deliveryGraphProposals.ts";
@@ -40,6 +41,7 @@ import {
   coalesceTitle,
   ensureFreshHeadRun,
   ensurePromotionPr,
+  fetchBranchHead,
   fetchDefaultBranch,
   fetchPrHead,
   fetchPrMeta,
@@ -91,7 +93,7 @@ import {
 // (submitPr/startMerge) and re-exported below so the long-standing `import { repoEnvelopeVars } from
 // "./service.ts"` call sites (and its tests) keep resolving.
 import { repoEnvelopeVars } from "./repoEnvelope.ts";
-import { clampNudgeMinutes, reviewWaitTimeout } from "./reviewWait.ts";
+import { clampNudgeMinutes, isReviewStale, reviewWaitTimeout } from "./reviewWait.ts";
 import { trialMergeAudits } from "./trialMerge.ts";
 import {
   buildUserTaskRow,
@@ -157,6 +159,20 @@ export const MAX_REBASE_ROUNDS = clampCiFixBudget(process.env.NANO_PR_MAX_REBASE
  * retry (a race escalates immediately). Reuses the CI-fix budget clamp (allows 0 = disable). */
 export const MAX_MERGE_RETRIES = clampCiFixBudget(process.env.NANO_PR_MAX_MERGE_RETRIES, 5);
 
+/** How many times the convergence loop will re-dispatch the `senior:pr-review` (review-round) agent
+ * to auto-ack unacked suppressed advisories before escalating to a human. When the converge-gate
+ * blocks SOLELY on unacknowledged suppressed advisories (no unresolved inline threads), the block is
+ * recoverable: re-running the review-round agent posts the missing `nano-ack:` threads and converges,
+ * so the loop tries that — bounded — before parking the human `wait-answer` (issue #796). A resolved
+ * `Declined … nano-ack:` advisory is an acknowledgement and CONVERGES (issue #787), so a decline does
+ * not escalate; only the agent returning `needs_input` (a genuinely contested advisory it cannot
+ * decide) or `blocked` (an external blocker it reports with a question — the `gw-status` arm at
+ * `convergence-loop.bpmn:442-443` routes both to `wait-answer`), or this budget being exhausted,
+ * escalates. Default 2; set
+ * `NANO_PR_MAX_ACK_RETRIES=0` to escalate on the first ack-only block. Reuses the CI-fix budget clamp
+ * (allows 0 = disable, ceiling-capped). */
+export const MAX_ACK_RETRIES = clampCiFixBudget(process.env.NANO_PR_MAX_ACK_RETRIES, 2);
+
 /** How many times the mergeable-wait timeout backstop (`merge-stall-probe`) will re-derive
  * mergeability from ground truth and re-arm the merge stage before giving up and escalating to a
  * human. Bounds the timer arm of the `gw-merge-wait` event-based gateway so a dead in-process poller
@@ -642,6 +658,11 @@ export async function submitPr(
       round: 1,
       maxRounds: clampRounds(maxRounds, MAX_ROUNDS),
       reviewWaitTimeout: REVIEW_WAIT_TIMEOUT,
+      // Bounded agent auto-ack (issue #796): the convergence loop re-dispatches the review-round
+      // agent up to `ackRetryMax` times to ack suppressed advisories when the converge-gate blocks
+      // solely on unacked ones, before escalating to a human. `ackRetryRound` counts those passes.
+      ackRetryRound: 0,
+      ackRetryMax: MAX_ACK_RETRIES,
       // Lineage (issue #245): carry the origin identity onto the convergence instance so every
       // descendant (and any message it correlates) is stitched back to the originating request.
       // A human/webhook PR that is its own root carries its own `pr_key` (never NULL — see above).
@@ -833,7 +854,12 @@ export async function activePrs(data: DataLayer): Promise<ActivePr[]> {
  * fresh-review detection + Copilot nudge below stay here because review freshness is inherently
  * STATEFUL (keyed off `last_review_id`/`waiting_since`), which the stateless probe matchers cannot
  * subsume — the poller owns the forward-progress guarantee, the gate owns the bounded wait. */
-async function pollReviews(data: DataLayer, engine: EngineClient, token: string) {
+// The poller's PR current-head reader — the SAME branch-ref-preferring reader the converge-gate and
+// progress-check bind (#786/#799), so the poller's stale-review detection sees the exact head those
+// steps do. Fails OPEN to `null` (unreadable head → not stale, per `isReviewStale`).
+const readCurrentHead = makeDefaultReadHead({ fetchPrHead, fetchBranchHead });
+
+export async function pollReviews(data: DataLayer, engine: EngineClient, token: string) {
   const waiting = await prs(data).find({ status: "waiting_review" });
   for (const pr of waiting) {
     const { repo, number, pr_key: prKey } = pr;
@@ -854,6 +880,34 @@ async function pollReviews(data: DataLayer, engine: EngineClient, token: string)
         await maybeRerequestReview(data, pr, token);
         continue;
       }
+      // #799 (FM2): only resume the loop on a review of the CURRENT head. If the PR HEAD has
+      // advanced past the commit the newest review was submitted against, that review is STALE — its
+      // advisories describe code the head has moved past (e.g. an advisory the agent already fixed in
+      // a later commit). Publishing `readiness-ready` on it would resume the loop on obsolete
+      // findings and, at the converge-gate, re-escalate a human on an already-fixed advisory (PR
+      // #789). Treat a stale review like "no fresh review": (re-)solicit a fresh review of the
+      // current head and wait — without bumping `last_review_id`, so the next HEAD-current review is
+      // still detected. The head read fails OPEN (null → not stale), so a transport hiccup never
+      // strands a genuine review; the review-wait timer remains the backstop.
+      //
+      // Read the head via the SHARED branch-ref-preferring reader (`makeDefaultReadHead`, #786) — the
+      // exact reader the converge-gate uses — NOT `fetchPrHead(...).headSha` directly: the PR object's
+      // `head.sha` is an asynchronously-denormalized projection that can still equal `fresh.commit_id`
+      // right after a push, which would make the poller advance `last_review_id` on a stale review the
+      // gate would then classify stale, wedging the loop. Using the atomic branch ref makes the poller
+      // detect the same stale-head case the gate does.
+      // Read the head with the SAME per-call token the review fetch above uses (#799) — NOT the
+      // env-token default `makeDefaultReadHead` would otherwise fall back to. A caller that supplies
+      // a `token` without also setting GITHUB_TOKEN would otherwise get a `null` head here, which
+      // `isReviewStale` treats as not-stale (fails OPEN) and would advance `last_review_id` /
+      // publish readiness on a genuinely stale review. Passing `token` keeps both reads on one
+      // credential so the stale guard sees the real head.
+      const headSha = await readCurrentHead(repo, number, token).catch(() => null);
+      if (isReviewStale(fresh.commit_id, headSha)) {
+        console.log(`[poller] review ${fresh.id} is stale (predates HEAD) -> re-soliciting ${prKey}`);
+        await maybeRerequestReview(data, pr, token);
+        continue;
+      }
       await prs(data).update(prKey, { last_review_id: fresh.id, status: "converging", updated_at: now() });
       await engine.publishMessage({
         name: READINESS_READY_MESSAGE,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.187.5",
+  "version": "0.188.0",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",