audit-tools 0.32.68 → 0.33.1

package/dist/remediate/steps/nextStep.js

@@ -1,8 +1,9 @@
+import { loadRemediateSessionConfig } from "./sessionConfigLoad.js";
 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, admissionBlockedOnBudget, 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 { readConfirmedDispatchPolicy, resolveDispatchExclusion, readOptionalJsonFile, readValidatedRepoSessionIntent, stagedAndUntracked, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DISPATCH_PROMPT_HANDOFF_NOTE, renderHostScratchNote, hostScratchDir, renderQuotaCoverageNudge, renderTokenBudgetView, coerceJsonObjectArg, driveRolling, resolveLedgerBudgets, setQuotaStateDir, detectHostDispatchWall, admissionBlockedOnBudget, reconcileAdmissionLeasesFromQuotaFile, buildQuotaPausedTerminal, interpretFreeFormIntent, advance, decideFrictionTriage, buildFrictionTriageBlock, planHybridDispatch, readSettledPools, addSettledPool, sourceByPoolId, classifyProvider, selectDispatchDriver, renderDispatchDriverInstruction, HostSessionQuotaSource, buildProviderModelKey, captureStepBoundaryFriction, captureCostDriftFriction, captureCreditExhaustionFriction, captureQuotaUnclassifiedFriction, captureModelUnavailableFriction, capturePacketTooLargeFriction, LENSES, SEVERITIES, resolveHostProviderName, resolveConversationHostProvider, resolveHostDispatchCapability as sharedResolveHostDispatchCapability, resolveAutonomousMode, 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";
@@ -51,23 +52,6 @@ export function resolveHostDispatchCapability(options) {
         env: options.env,
     });
 }
-/**
- * Whether the run is unattended (autonomous). Host-agnostic — ONE flag drives
- * the whole path. Resolution order: sessionConfig.autonomous_mode →
- * REMEDIATE_AUTONOMOUS env → false (attended/interactive default, so the review
- * gate halts for a human unless autonomy is explicitly requested).
- */
-export function resolveAutonomousMode(options = {}) {
-    if (options.sessionConfig?.autonomous_mode !== undefined) {
-        return options.sessionConfig.autonomous_mode;
-    }
-    const envValue = (options.env ?? process.env).REMEDIATE_AUTONOMOUS;
-    if (envValue === "true")
-        return true;
-    if (envValue === "false")
-        return false;
-    return false;
-}
 /**
  * Whether the rolling dispatch engine drives the implement phase. Defaults to TRUE:
  * both rolling drivers on the shared `acceptNodeWorktree` core (per-node worktree →
@@ -536,6 +520,8 @@ export async function driveRollingDispatch(levels, options) {
         ...(options.onCostDrift ? { onCostDrift: options.onCostDrift } : {}),
         ...(options.onCreditExhausted ? { onCreditExhausted: options.onCreditExhausted } : {}),
         ...(options.onQuotaUnclassified ? { onQuotaUnclassified: options.onQuotaUnclassified } : {}),
+        ...(options.onModelUnavailable ? { onModelUnavailable: options.onModelUnavailable } : {}),
+        ...(options.onPacketTooLarge ? { onPacketTooLarge: options.onPacketTooLarge } : {}),
         // Single-flight (CE-001) is enforced by the unified driver.
         rebuildBetweenLevels: options.rebuildSharedBetweenLevels,
         // Host-session escalation: feed recordLimit (write) at the rate_limited observation
@@ -573,6 +559,10 @@ const IN_PROCESS_DISPATCH_PROVIDERS = new Set([
     "subprocess-template",
     "worker-command",
     "agy",
+    // The proxied isolated Claude-harness worker (commit 3b/3c) — headless in-process
+    // launch from its claude-worker source (mirrors audit's IN_PROCESS_AUDIT_PROVIDERS;
+    // both draws must classify the new worker kind or its pools confirm but never route).
+    "claude-worker",
 ]);
 function resolvesToInProcessDispatchProvider(sessionConfig) {
     const provider = sessionConfig?.provider;
@@ -687,6 +677,11 @@ export async function driveRollingImplementDispatch(options) {
         hostModels: options.waveOptions?.hostModels,
         hostModelId: options.waveOptions?.hostModelId,
         hostSession,
+        // The operator's Gate-0 exclusions, applied as a set-difference over freshly
+        // gathered reach. Read here because this layer owns `root`; self-spawn-blocked is
+        // recomputed against THIS process's env rather than inherited from the auditor
+        // that wrote the confirmation.
+        excludedBackends: resolveDispatchExclusion(await readConfirmedDispatchPolicy(options.root)),
     });
     // The live per-node worker: the configured provider, launched with the node's
     // worktree-rooted prompt and cwd = its worktree. Tests inject `options.dispatchNode`
@@ -820,6 +815,17 @@ export async function driveRollingImplementDispatch(options) {
         onQuotaUnclassified: (info) => {
             captureQuotaUnclassifiedFriction(artifactsDir, runId, info, "remediate-code");
         },
+        // Model-unavailable exclusion (availability analog of cost drift): the engine
+        // has already permanently excluded the 404ing pool; surface it so the operator
+        // reconciles the stale registry row (registry rows are leads, not reach).
+        onModelUnavailable: (info) => {
+            captureModelUnavailableFriction(artifactsDir, runId, info, "remediate-code");
+        },
+        // Packet-too-large (per-packet sizing fault, HTTP 413): the engine skips THIS
+        // pool for THIS packet only — no exclusion, no cooldown; surface each pair.
+        onPacketTooLarge: (info) => {
+            capturePacketTooLargeFriction(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
@@ -1175,8 +1181,13 @@ async function presentReportStep(root, artifactsDir, state) {
 }
 async function buildImplementDispatchStep(ctx) {
     const { root, artifactsDir, state, options, store } = ctx;
-    const loadedSessionConfig = options.sessionConfig ??
-        await readValidatedSessionConfig(join(root, ".remediation-artifacts", "session-config.json")) ?? await readValidatedSessionConfig(join(root, "session-config.json"));
+    // The effective config comes from the single remediate loader — always resolved
+    // against the ambient descriptor (see there for why `null` is not an option).
+    const loadedSessionConfig = await loadRemediateSessionConfig({
+        root,
+        override: options.sessionConfig,
+        artifactsFirst: true,
+    });
     // B1: fold the `--host-provider` override onto `host_provider` so every
     // downstream host resolver keys the fan-out to the ACTUAL conversation host.
     // "auto" is treated as unset (fall through to env auto-detection).
@@ -1326,6 +1337,9 @@ async function buildImplementDispatchStep(ctx) {
             // skipped (attended host) — demote the configured primary backend into the
             // source-pool set so the split fans across host + backend + NIM.
             demotePrimaryInProcess: demoteBackendToSource,
+            // The operator's Gate-0 exclusions, applied as a set-difference over freshly
+            // gathered reach; self-spawn-blocked recomputed against THIS process's env.
+            excludedBackends: resolveDispatchExclusion(await readConfirmedDispatchPolicy(root)),
         });
         const backendPools = confirmedPools.filter(isInProcessPool);
         let rolling;
@@ -1396,6 +1410,8 @@ async function buildImplementDispatchStep(ctx) {
             const settledOutcomeBlocks = new Set(inProcessOutcome.nodes
                 .filter((n) => n.outcome === "rate_limited" ||
                 n.outcome === "credit_exhausted" ||
+                n.outcome === "model_unavailable" ||
+                n.outcome === "packet_too_large" ||
                 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));
@@ -1410,7 +1426,7 @@ async function buildImplementDispatchStep(ctx) {
                 void captureStepBoundaryFriction(artifactsDir, runId, {
                     eventType: "quota_escalation",
                     discriminator: blockId,
-                    note: "A-8 hybrid in-process node rate-limited / credit-exhausted / quota-unclassified; its backend pool was settled for this run.",
+                    note: "A-8 hybrid in-process node rate-limited / credit-exhausted / model-unavailable / packet-too-large / quota-unclassified; its backend pool was settled for this run.",
                     severity: "high",
                     category: "trap",
                     area: "dispatch/quota",
@@ -2347,9 +2363,11 @@ async function handleReadyIntakeContractPipeline(root, artifactsDir, options) {
     // flag. Threaded into the contract pipeline so the adversarial 'critique' /
     // 'critic' prompts MANDATE an independent sub-agent reviewer when the host can
     // dispatch one (fail-safe: mandate by default).
-    const sessionConfigForDispatch = options?.sessionConfig ??
-        (await readValidatedSessionConfig(join(root, ".remediation-artifacts", "session-config.json"))) ??
-        (await readValidatedSessionConfig(join(root, "session-config.json")));
+    const sessionConfigForDispatch = await loadRemediateSessionConfig({
+        root,
+        override: options?.sessionConfig,
+        artifactsFirst: true,
+    });
     const hostCanDispatchSubagents = resolveHostDispatchCapability({
         hostCanDispatchSubagents: options?.hostCanDispatchSubagents,
         sessionConfig: sessionConfigForDispatch,
@@ -3087,8 +3105,10 @@ export async function decideNextStep(options = {}) {
     // validated load (with `.remediation-artifacts/` path precedence + operator
     // warning surface) happens inside the loop, so suppress warnings here to avoid
     // emitting the same warning twice per invocation. Errors still throw.
+    // Only reads `observability.run_log` (an INTENT field), so the raw intent suffices —
+    // no descriptor resolve needed here.
     const sessionConfig = normalizedOptions.sessionConfig ??
-        (await readValidatedSessionConfig(join(root, "session-config.json"), {
+        (await readValidatedRepoSessionIntent(join(root, "session-config.json"), {
             onWarnings: () => { },
         }));
     const runLogger = new RunLogger(join(artifactsDir, "run.log.jsonl"), {