audit-tools 0.30.51 → 0.30.54

package/dist/remediate/steps/nextStep.js

@@ -1,8 +1,8 @@
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { mkdir, readFile, rename } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { StateStore } from "../state/store.js";
-import { readOptionalJsonFile, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DISPATCH_PROMPT_HANDOFF_NOTE, renderQuotaCoverageNudge, coerceJsonObjectArg, createRollingDispatcher, setQuotaStateDir, interpretFreeFormIntent, advance, decideFrictionTriage, buildFrictionTriageBlock, planHybridDispatch, readSettledPools, addSettledPool, sourceByPoolId, classifyProvider, selectDispatchDriver, renderDispatchDriverInstruction, HostSessionQuotaSource, buildProviderModelKey, captureStepBoundaryFriction, LENSES, SEVERITIES } from "audit-tools/shared";
+import { readOptionalJsonFile, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DISPATCH_PROMPT_HANDOFF_NOTE, renderQuotaCoverageNudge, renderTokenBudgetView, coerceJsonObjectArg, createRollingDispatcher, setQuotaStateDir, interpretFreeFormIntent, advance, decideFrictionTriage, buildFrictionTriageBlock, planHybridDispatch, readSettledPools, addSettledPool, sourceByPoolId, classifyProvider, selectDispatchDriver, renderDispatchDriverInstruction, HostSessionQuotaSource, buildProviderModelKey, captureStepBoundaryFriction, LENSES, SEVERITIES } from "audit-tools/shared";
 import { applyPlanPipeline, buildCoverageLedger } from "../phases/plan.js";
 import { groundExtractedFindings } from "../phases/grounding.js";
 import { runTriagePhase } from "../phases/triage.js";
@@ -246,6 +246,26 @@ function resolveInputPaths(root, input) {
  * in the tool, never by asking the loader to remember to drop the flag (a needed
  * manual flag is a bug signal).
  */
+/**
+ * True when `candidatePath` (the best default-discovered input, e.g.
+ * `.audit-tools/audit-findings.json`) was modified more recently than
+ * `reportPath` (a leftover `remediation-report.md`). A freshly-regenerated
+ * audit doc postdating the last remediation report is a NEW remediation
+ * source, not evidence the old run is still "the" answer — used to stop
+ * `complete_redelivery` from silently re-presenting a stale report over it.
+ * Missing/unreadable files compare as "not fresher" (fail toward redelivering,
+ * the pre-existing behaviour) rather than throwing.
+ */
+function isDefaultCandidateFresherThanReport(candidatePath, reportPath) {
+    if (!candidatePath)
+        return false;
+    try {
+        return statSync(candidatePath).mtimeMs > statSync(reportPath).mtimeMs;
+    }
+    catch {
+        return false;
+    }
+}
 function suppliedInputMatchesRun(inputResolution, manifest) {
     if (!inputResolution.supplied)
         return false;
@@ -517,11 +537,42 @@ export async function driveRollingDispatch(levels, options) {
             });
             dispatcher.enqueue(packets);
             levelResults.push(...(await dispatcher.run()));
+            // Piece D: surface the wave's partial-completion terminal (quota_paused /
+            // empty_pool). Aggregate across waves keeping the EARLIEST-reset quota_paused
+            // terminal (a paused wave is retryable and should resume soonest); union the
+            // stranded ids so a later step re-dispatches all of them. An empty_pool
+            // terminal only stands when no quota_paused terminal was seen.
+            out.terminal = mergePartialTerminals(out.terminal, dispatcher.getTerminal());
         }
         out.levels.push({ blockIds: level.map((b) => b.block_id), results: levelResults });
     }
     return out;
 }
+/**
+ * Fold a newly-observed partial-completion terminal into the run's aggregate
+ * (piece D). Prefers `quota_paused` (retryable) over `empty_pool`; among
+ * quota_paused terminals keeps the EARLIEST `earliest_reset_at`; always unions the
+ * stranded ids so no stranded node is lost across waves.
+ */
+function mergePartialTerminals(prior, next) {
+    if (!next)
+        return prior;
+    if (!prior)
+        return next;
+    const strandedIds = [...new Set([...prior.stranded_ids, ...next.stranded_ids])];
+    const priorPaused = prior.reason === "quota_paused";
+    const nextPaused = next.reason === "quota_paused";
+    if (priorPaused || nextPaused) {
+        const resets = [prior.earliest_reset_at, next.earliest_reset_at].filter((r) => typeof r === "string");
+        const earliest = resets.length > 0 ? resets.sort()[0] : undefined;
+        return {
+            reason: "quota_paused",
+            stranded_ids: strandedIds,
+            ...(earliest ? { earliest_reset_at: earliest } : {}),
+        };
+    }
+    return { reason: prior.reason, stranded_ids: strandedIds };
+}
 /**
  * Backends the orchestrator can drive IN-PROCESS as the per-node implement worker
  * via `driveRollingImplementDispatch` (it resolves + launches the provider with each
@@ -734,7 +785,7 @@ export async function driveRollingImplementDispatch(options) {
     // the merge-time write-scope gate reads — for file-ownership-disjoint admission
     // (INV-SOO). A block with no plan scope falls back to its touched_files.
     const writePathsByBlock = new Map(allBlockScopes.map((s) => [s.block_id, s.write_paths]));
-    await driveRollingDispatch(levels, {
+    const driven = await driveRollingDispatch(levels, {
         confirmedPools,
         sessionConfig: options.sessionConfig ?? {},
         dispatchNode: dispatchNodeWithWorktree,
@@ -744,6 +795,19 @@ export async function driveRollingImplementDispatch(options) {
         hostSession,
         scopeForBlock: (block) => writePathsByBlock.get(block.block_id) ?? block.touched_files ?? [],
     });
+    // Piece D — persist the rolling engine's partial-completion terminal onto state
+    // BEFORE the merge, so the merge can SKIP-block the quota_paused stranded nodes
+    // (their worker rate-limited → no result file, but they must stay PENDING for a
+    // later step to redispatch clean — the worktrees were PRESERVED by
+    // acceptNodeWorktree). An `empty_pool` terminal does not affect the merge (its
+    // nodes are genuine failures); the `partial_terminal` obligation blocks them.
+    if (driven.terminal) {
+        const pre = await new StateStore(artifactsDir).loadState();
+        if (pre) {
+            pre.partial_completion_terminal = driven.terminal;
+            await new StateStore(artifactsDir).saveState(pre);
+        }
+    }
     // Deterministic merge: same path the wave flow uses (tolerant remap, write-scope
     // gate against each verified branch, lost-update detection). Worktrees are
     // already removed; the merge reads each node's result file + branch diff.
@@ -1306,6 +1370,8 @@ Then run:
 
 ${renderQuotaCoverageNudge(rolling.quotaPath, artifactsDir)}
 
+${renderTokenBudgetView(rolling.quotaPath)}
+
 ${DISPATCH_PROMPT_HANDOFF_NOTE}
 `,
                 allowedCommands: [acceptCmd, rollMerge, rollNext],
@@ -1402,6 +1468,8 @@ ${SHARED_REBUILD_BETWEEN_LEVELS_NOTE}
 
 ${renderQuotaCoverageNudge(implQuotaPath, artifactsDir)}
 
+${renderTokenBudgetView(implQuotaPath)}
+
 ${DISPATCH_PROMPT_HANDOFF_NOTE}
 
 After all results exist:
@@ -1417,6 +1485,41 @@ Then run:
             artifactPaths: { dispatch_plan: planPath, dispatch_quota: implQuotaPath },
         }) };
 }
+/**
+ * Piece D — the quota-paused resumable step. The rolling engine stranded one or
+ * more nodes because every eligible provider pool hit a host session limit and is
+ * paused until its stated reset. The stranded nodes stay PENDING (their worktrees
+ * were preserved), so re-running next-step at/after `resetAt` redispatches them
+ * clean. Emitted (not blocked) so the run is resumable, never a failure.
+ */
+async function buildQuotaPausedStep(params) {
+    const { root, artifactsDir, runId, strandedIds, resetAt } = params;
+    const nextCommand = loaderCommand("next-step");
+    const resetLine = resetAt
+        ? `The earliest provider reset is \`${resetAt}\`. Wait until then, then run:`
+        : `Wait for the provider session limit to reset, then run:`;
+    return writeCurrentStep({
+        stepKind: "quota_paused",
+        status: "ready",
+        runId,
+        repoRoot: root,
+        artifactsDir,
+        prompt: `
+# Remediation paused — provider session limit
+
+Every eligible provider pool hit a host session limit and is paused until its
+stated reset. ${strandedIds.length} node(s) are stranded and remain PENDING —
+their worktrees were preserved, so they will redispatch clean on resume. Nothing
+was blocked or failed; this is a resumable pause.
+
+${resetLine}
+
+\`${nextCommand}\`
+`,
+        allowedCommands: [nextCommand],
+        stopCondition: "Stop and wait for the provider reset. Re-running next-step resumes the stranded nodes.",
+    });
+}
 // --- Per-state handlers -----------------------------------------------------
 // Each handler owns one branch of the original decideNextStepInner dispatch.
 // Handlers that emit a step return RemediationStep directly; handlers that need
@@ -3156,9 +3259,17 @@ function buildPreIntakeObligations(ctx, snapshot) {
                 // built) — an active run, not a finished one. A fully-green close deletes
                 // the whole artifact dir (close.ts), so the summary + checkpoint can only
                 // co-exist for a live run; never re-deliver the leftover root report over it.
+                //
+                // A freshly-regenerated default-discovered audit doc (audit-findings.json /
+                // audit-report.md newer than the leftover report) is the same "don't
+                // redeliver" signal — a fresh audit run just landed and a bare next-step
+                // must fall through to pending_intake (which re-presents the discovered
+                // file for confirmation via confirm_auto_discovered_input, mtime + type +
+                // finding count included) rather than silently re-showing the stale report.
                 const freshIntent = existsSync(ip.conversationStart) ||
                     existsSync(ip.extractedPlan) ||
-                    (existsSync(ip.summary) && existingCheckpoint?.confirmed_by === "host");
+                    (existsSync(ip.summary) && existingCheckpoint?.confirmed_by === "host") ||
+                    isDefaultCandidateFresherThanReport(inputResolution.existing[0], reportPath);
                 return freshIntent ? "satisfied" : "missing";
             },
             execute: async (state, c) => ({
@@ -3288,6 +3399,28 @@ function buildMainObligations(ctx) {
                 const terminal = s.partial_completion_terminal;
                 if (!terminal)
                     return { kind: "transition", state: s };
+                // Piece D — quota_paused is a RETRYABLE pause, NOT a failure. The stranded
+                // nodes stay PENDING (their worktrees were preserved), nothing is blocked,
+                // and the close transition is NOT forced. EMIT a paused step (terminating
+                // this advance loop) that tells the host to re-run next-step at/after the
+                // stated reset, when the pool's session limit has cleared and the stranded
+                // nodes redispatch clean. Clearing the terminal here (before the emit) so
+                // the resuming step starts fresh; the pending nodes are the durable signal.
+                if (terminal.reason === "quota_paused") {
+                    const resetAt = terminal.earliest_reset_at ?? null;
+                    delete s.partial_completion_terminal;
+                    await store.saveState(s);
+                    return {
+                        kind: "emit",
+                        step: await buildQuotaPausedStep({
+                            root,
+                            artifactsDir,
+                            runId: stateRunId(s),
+                            strandedIds: terminal.stranded_ids ?? [],
+                            resetAt,
+                        }),
+                    };
+                }
                 const strandedSet = new Set(terminal.stranded_ids ?? []);
                 for (const it of Object.values(s.items ?? {})) {
                     if (isTerminalStatus(it.status))