audit-tools 0.32.58 → 0.32.60

package/dist/remediate/steps/nextStep.js

@@ -2,7 +2,7 @@ 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, readValidatedSessionConfig, stagedAndUntracked, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DISPATCH_PROMPT_HANDOFF_NOTE, renderHostScratchNote, hostScratchDir, renderQuotaCoverageNudge, renderTokenBudgetView, coerceJsonObjectArg, driveRolling, resolveLedgerBudgets, setQuotaStateDir, detectHostDispatchWall, reconcileAdmissionLeasesFromQuotaFile, buildQuotaPausedTerminal, interpretFreeFormIntent, advance, decideFrictionTriage, buildFrictionTriageBlock, planHybridDispatch, readSettledPools, addSettledPool, sourceByPoolId, classifyProvider, selectDispatchDriver, renderDispatchDriverInstruction, HostSessionQuotaSource, buildProviderModelKey, captureStepBoundaryFriction, captureCostDriftFriction, LENSES, SEVERITIES, resolveHostProviderName, resolveConversationHostProvider, resolveHostDispatchCapability as sharedResolveHostDispatchCapability, resolveRollingEngineFlag, shouldDemotePrimaryInProcess, DEFAULT_CONTEXT_TOKENS } from "audit-tools/shared";
+import { readOptionalJsonFile, readValidatedSessionConfig, stagedAndUntracked, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DISPATCH_PROMPT_HANDOFF_NOTE, renderHostScratchNote, hostScratchDir, renderQuotaCoverageNudge, renderTokenBudgetView, coerceJsonObjectArg, driveRolling, resolveLedgerBudgets, setQuotaStateDir, detectHostDispatchWall, reconcileAdmissionLeasesFromQuotaFile, buildQuotaPausedTerminal, interpretFreeFormIntent, advance, decideFrictionTriage, buildFrictionTriageBlock, planHybridDispatch, readSettledPools, addSettledPool, sourceByPoolId, classifyProvider, selectDispatchDriver, renderDispatchDriverInstruction, HostSessionQuotaSource, buildProviderModelKey, captureStepBoundaryFriction, captureCostDriftFriction, captureCreditExhaustionFriction, captureQuotaUnclassifiedFriction, LENSES, SEVERITIES, resolveHostProviderName, resolveConversationHostProvider, resolveHostDispatchCapability as sharedResolveHostDispatchCapability, resolveRollingEngineFlag, shouldDemotePrimaryInProcess, DEFAULT_CONTEXT_TOKENS } from "audit-tools/shared";
 import { readRemediationAccessMemory, computeBlockContinuityScores } from "../state/accessMemory.js";
 import { applyPlanPipeline, buildCoverageLedger } from "../phases/plan.js";
 import { groundExtractedFindings } from "../phases/grounding.js";
@@ -23,14 +23,13 @@ import { deduplicateCrossLensFindings, fixupBlocksAfterDedup, } from "../dedup/c
 import { checkAffectedFileIntegrity } from "../utils/fileIntegrity.js";
 import { resolveIntakeStep } from "./intakeResolver.js";
 import { runToolOwnedFinalGate, applyCoarseReblock, readFinalGateSidecar, writeFinalGateSidecar, } from "./finalGate.js";
-import { buildNextContractPipelineStep, shouldEnterContractPipeline, writePathASeedFromFindings, } from "./contractPipeline.js";
-import { buildLeanExtractedPlan, interpretLeanLightReviewVerdict, LEAN_LIGHT_REVIEW_SCHEMA_VERSION, } from "./leanFastPath.js";
+import { buildNextContractPipelineStep, shouldEnterContractPipeline, writePathASeedFromFindings, buildLeanExtractedPlan, } from "./contractPipeline.js";
 import { contractArtifactExists, contractPipelineDir, } from "../contractPipeline/artifactStore.js";
 import { buildReviewRequest, applyReviewResolution, } from "../review/reviewGate.js";
 import { buildAutonomousReviewDecision } from "../review/autonomousGate.js";
 import { runFindingFilterPass } from "../findingFilter.js";
 import { intakePaths, isIntakeReady, readIntakeArtifacts, resolveManifestSources, } from "../intake.js";
-import { ensureIntakeRiskSignal, readIntakeRiskSignal, writeIntakeRiskSignal, escalateRiskSignal, findingRiskEvidence, distinctAffectedFiles, } from "../riskSignal.js";
+import { ensureIntakeRiskSignal, readIntakeRiskSignal, writeIntakeRiskSignal, escalateRiskSignal, findingRiskEvidence, distinctAffectedFiles, interpretLeanLightReviewVerdict, LEAN_LIGHT_REVIEW_SCHEMA_VERSION, } from "../riskSignal.js";
 import { ambiguityReviewPrompt, clarificationPrompt, collectIntakeClarificationsPrompt, collectStartingPointPrompt, loaderCommand, reviewApprovalPrompt, synthesizeIntakePrompt, triagePrompt, } from "./prompts.js";
 // Single-sourced prose renders of the canonical lens / severity vocabularies
 // (`audit-tools/shared` `LENSES` / `SEVERITIES`) for the intent-checkpoint
@@ -535,6 +534,8 @@ export async function driveRollingDispatch(levels, options) {
         dispatchPacket: async (packet, slot) => options.dispatchNode(blockById.get(packet.payload.block_id), slot),
         ...(options.root !== undefined ? { root: options.root } : {}),
         ...(options.onCostDrift ? { onCostDrift: options.onCostDrift } : {}),
+        ...(options.onCreditExhausted ? { onCreditExhausted: options.onCreditExhausted } : {}),
+        ...(options.onQuotaUnclassified ? { onQuotaUnclassified: options.onQuotaUnclassified } : {}),
         // Single-flight (CE-001) is enforced by the unified driver.
         rebuildBetweenLevels: options.rebuildSharedBetweenLevels,
         // Host-session escalation: feed recordLimit (write) at the rate_limited observation
@@ -760,10 +761,13 @@ export async function driveRollingImplementDispatch(options) {
             verify_passed: accept.verifyPassed,
             merged: accept.merged,
         });
-        // Release the claim ONLY on a terminal accept. A `rate_limited` worker re-queues
-        // (still owned work — keep the claim so a peer can't grab it mid-retry); success /
-        // error / timeout is terminal → free it through the shared registry (token-checked).
-        if (result.outcome !== "rate_limited") {
+        // Release the claim ONLY on a terminal accept. A `rate_limited`,
+        // `credit_exhausted`, or `quota_unclassified` worker re-queues (still owned
+        // work — keep the claim so a peer can't grab it mid-retry); success / error /
+        // timeout is terminal → free it through the shared registry (token-checked).
+        if (result.outcome !== "rate_limited" &&
+            result.outcome !== "credit_exhausted" &&
+            result.outcome !== "quota_unclassified") {
             await releaseNodeClaim(registry, claimTokens, block.block_id);
         }
         return result;
@@ -794,6 +798,21 @@ export async function driveRollingImplementDispatch(options) {
         onCostDrift: (info) => {
             captureCostDriftFriction(artifactsDir, runId, info, "remediate-code");
         },
+        // Credit exhaustion: a pool out of prepaid usage credits (no reset timer,
+        // distinct from a rate limit) has already been permanently excluded from
+        // this run's admissible set by the engine; surface it as reviewable
+        // friction so the operator knows to top up credits.
+        onCreditExhausted: (info) => {
+            captureCreditExhaustionFriction(artifactsDir, runId, info, "remediate-code");
+        },
+        // Quota-unclassified harvest (Slice A2b): a pool death whose text was
+        // quota-suspicious but matched no precise pattern degraded conservatively
+        // (re-queued, never permanently excluded); surface the verbatim
+        // (secret-scrubbed) text as reviewable friction so the operator can
+        // classify it and improve errorParsing.ts's pattern set.
+        onQuotaUnclassified: (info) => {
+            captureQuotaUnclassifiedFriction(artifactsDir, runId, info, "remediate-code");
+        },
     });
     // 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
@@ -1350,22 +1369,39 @@ async function buildImplementDispatchStep(ctx) {
                 registry: hybridClaimRegistry,
                 sourceByPoolId: sourceByPoolId(confirmedPools),
             });
-            // DC-4: a backend pool whose node rate-limited is exhausted → settle it
-            // (cross-cycle) so the next cycle routes its share to the host pool.
-            const rateLimited = new Set(inProcessOutcome.nodes.filter((n) => n.outcome === "rate_limited").map((n) => n.block_id));
-            const exhaustedPools = new Set(partition.inProcess.filter((a) => rateLimited.has(a.nodeId)).map((a) => a.poolId));
+            // DC-4: a backend pool whose node rate-limited, credit-exhausted, OR
+            // returned a quota_unclassified death → settle it (cross-cycle) so the next
+            // cycle routes its share to the host pool. This partition spans multiple
+            // cycles, each with its own fresh in-process dispatcher (a fresh in-memory
+            // exhaustedPoolIds AND pausedPoolResetAt), so the rolling engine's own
+            // reversible pause evaporates at the cycle boundary — without settling here,
+            // credit_exhausted (no reset timer) and a chronically-quota_unclassified pool
+            // alike would be RE-OFFERED next cycle and re-die on the same pool. Settling
+            // in the hybrid path is the cross-cycle analog of the rolling path's pause.
+            // NOTE: the verbatim-message harvest (captureQuotaUnclassifiedFriction /
+            // captureCreditExhaustionFriction) rides the rolling engine's hooks, which
+            // this direct-Promise.all partition does not invoke; here every settled node
+            // still surfaces as a quota_escalation friction (below), but without the
+            // verbatim text. Threading verbatim capture into executeInProcessPartition is
+            // a documented follow-up (affects credit_exhausted identically — not new to A2b).
+            const settledOutcomeBlocks = new Set(inProcessOutcome.nodes
+                .filter((n) => n.outcome === "rate_limited" ||
+                n.outcome === "credit_exhausted" ||
+                n.outcome === "quota_unclassified")
+                .map((n) => n.block_id));
+            const exhaustedPools = new Set(partition.inProcess.filter((a) => settledOutcomeBlocks.has(a.nodeId)).map((a) => a.poolId));
             for (const poolId of exhaustedPools) {
                 await partition.coordinator.settlePool(poolId);
             }
-            // Surface each rate-limited node as reviewable friction (not just the
-            // settle side-effect above). The shared step-boundary chokepoint dedupes
-            // on {eventType, runId, discriminator}, so a chronically-exhausted backend
-            // pool re-hitting the same block_id across cycles collapses to one record.
-            for (const blockId of rateLimited) {
+            // Surface each settled node as reviewable friction (not just the settle
+            // side-effect above). The shared step-boundary chokepoint dedupes on
+            // {eventType, runId, discriminator}, so a chronically-exhausted backend pool
+            // re-hitting the same block_id across cycles collapses to one record.
+            for (const blockId of settledOutcomeBlocks) {
                 void captureStepBoundaryFriction(artifactsDir, runId, {
                     eventType: "quota_escalation",
                     discriminator: blockId,
-                    note: "A-8 hybrid in-process node rate-limited; its backend pool was settled for this run.",
+                    note: "A-8 hybrid in-process node rate-limited / credit-exhausted / quota-unclassified; its backend pool was settled for this run.",
                     severity: "high",
                     category: "trap",
                     area: "dispatch/quota",
@@ -2185,8 +2221,10 @@ async function handleReadyIntakeContractPipeline(root, artifactsDir, options) {
                 }
                 // Persist the filter dispositions so coverage is built over the originals.
                 await persistReviewFilterDispositions(artifactsDir, originals, filter);
-                // Lean path = the `low` risk tier's realization (D-68 — leanFastPath folded
-                // into the self-scaling dial). A run skips the heavy contract DESIGN loop and
+                // Lean path = the `low` risk tier's realization (D-68 — the standalone lean
+                // fast-path folded into the self-scaling dial; its two mechanisms now live in
+                // `riskSignal.ts` (light-review) + `contractPipeline.ts` (lean plan builder)).
+                // A run skips the heavy contract DESIGN loop and
                 // synthesizes the extracted plan directly IFF its effective risk tier is `low`;
                 // the plan→implement→close machinery (per-node verify-before-merge + the final
                 // whole-repo gate) is the retained safety net. Runs only here — on Path A