audit-tools 0.32.43 → 0.32.45

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, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DISPATCH_PROMPT_HANDOFF_NOTE, renderQuotaCoverageNudge, renderTokenBudgetView, coerceJsonObjectArg, driveRolling, resolveLedgerBudgets, setQuotaStateDir, interpretFreeFormIntent, advance, decideFrictionTriage, buildFrictionTriageBlock, planHybridDispatch, readSettledPools, addSettledPool, sourceByPoolId, classifyProvider, selectDispatchDriver, renderDispatchDriverInstruction, HostSessionQuotaSource, buildProviderModelKey, captureStepBoundaryFriction, LENSES, SEVERITIES, resolveHostProviderName, resolveConversationHostProvider, resolveHostDispatchCapability as sharedResolveHostDispatchCapability, shouldDemotePrimaryInProcess, DEFAULT_CONTEXT_TOKENS } from "audit-tools/shared";
+import { readOptionalJsonFile, readValidatedSessionConfig, stagedAndUntracked, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DISPATCH_PROMPT_HANDOFF_NOTE, renderQuotaCoverageNudge, renderTokenBudgetView, coerceJsonObjectArg, driveRolling, resolveLedgerBudgets, setQuotaStateDir, 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 { readRemediationAccessMemory, computeBlockContinuityScores } from "../state/accessMemory.js";
 import { applyPlanPipeline, buildCoverageLedger } from "../phases/plan.js";
 import { groundExtractedFindings } from "../phases/grounding.js";
@@ -14,7 +14,7 @@ import { makeProviderNodeDispatcher } from "./providerNodeDispatch.js";
 import { prepareHostRollingDispatch, nodeClaimRegistry, nodeSettledPoolsPath } from "./rollingSession.js";
 import { ClaimRegistry } from "../../shared/quota/claimRegistry.js";
 import { claimWithBackoff, withClaimHeartbeat } from "../../shared/quota/claimLease.js";
-import { nodeClaimsPath, remediationArtifactsDir } from "../../shared/io/auditToolsPaths.js";
+import { AUDIT_FINDINGS_FILENAME, AUDIT_REPORT_FILENAME, auditArtifactsDir, auditFindingsPath, auditReportPath, auditToolsDir, nodeClaimsPath, promotedAuditFindingsPath, promotedAuditReportPath, remediationArtifactsDir, } from "../../shared/io/auditToolsPaths.js";
 import { resolveRepoRoot } from "../../shared/io/repoRoot.js";
 import { writeCurrentStep } from "./stepWriter.js";
 import { dependencyVerifiedComplete } from "./stepUtils.js";
@@ -24,13 +24,13 @@ 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 { evaluateFastPath, buildLeanExtractedPlan, distinctAffectedFiles, interpretLeanLightReviewVerdict, LEAN_LIGHT_REVIEW_SCHEMA_VERSION, } from "./leanFastPath.js";
+import { buildLeanExtractedPlan, interpretLeanLightReviewVerdict, LEAN_LIGHT_REVIEW_SCHEMA_VERSION, } from "./leanFastPath.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, } from "../riskSignal.js";
+import { ensureIntakeRiskSignal, readIntakeRiskSignal, writeIntakeRiskSignal, escalateRiskSignal, findingRiskEvidence, distinctAffectedFiles, } 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
@@ -81,17 +81,12 @@ export function resolveAutonomousMode(options = {}) {
  * sessionConfig.dispatch.rolling_engine → REMEDIATE_ROLLING_ENGINE env → true.
  */
 export function resolveRollingEngineEnabled(options) {
-    if (options.rollingEngine !== undefined)
-        return options.rollingEngine;
-    const cfg = options.sessionConfig?.dispatch?.rolling_engine;
-    if (cfg !== undefined)
-        return cfg;
-    const envValue = (options.env ?? process.env).REMEDIATE_ROLLING_ENGINE;
-    if (envValue === "true")
-        return true;
-    if (envValue === "false")
-        return false;
-    return true;
+    return resolveRollingEngineFlag({
+        explicit: options.rollingEngine,
+        sessionConfig: options.sessionConfig,
+        envVarName: "REMEDIATE_ROLLING_ENGINE",
+        env: options.env,
+    });
 }
 /** Conservative context-window floor, applied ONLY at true first contact (nothing persisted). */
 const HOST_CONTEXT_TOKENS_FLOOR = DEFAULT_CONTEXT_TOKENS;
@@ -189,13 +184,14 @@ function defaultInputCandidates(root) {
     // both sides of the audit -> remediate pipeline, and feeding it triggers the
     // lossless structured hand-off in the plan phase instead of a lossy LLM
     // re-extraction from the markdown render that sits beside it.
+    const auditDir = auditArtifactsDir(root);
     return [
-        join(root, ".audit-tools", "audit-findings.json"),
-        join(root, ".audit-tools", "audit", "audit-findings.json"),
-        join(root, "audit-findings.json"),
-        join(root, ".audit-tools", "audit-report.md"),
-        join(root, ".audit-tools", "audit", "audit-report.md"),
-        join(root, "audit-report.md"),
+        promotedAuditFindingsPath(auditDir),
+        auditFindingsPath(auditDir),
+        join(root, AUDIT_FINDINGS_FILENAME),
+        promotedAuditReportPath(auditDir),
+        auditReportPath(auditDir),
+        join(root, AUDIT_REPORT_FILENAME),
     ];
 }
 function inputValues(input) {
@@ -792,16 +788,8 @@ export async function driveRollingImplementDispatch(options) {
         // Reactive cost verification: a declared-free source pool observed charging has
         // been demoted by the engine; surface it as reviewable friction so the operator
         // reconciles the stale `cost_per_mtok:0` (single step-boundary chokepoint).
-        onCostDrift: ({ poolId, observedCostUsd, declaredCostPerMtok }) => {
-            void captureStepBoundaryFriction(artifactsDir, runId, {
-                eventType: "declared_cost_drift",
-                discriminator: poolId,
-                note: `pool "${poolId}" was declared free (cost_per_mtok=${declaredCostPerMtok}) ` +
-                    `but reported cost=${observedCostUsd} — demoted out of free-first ordering; ` +
-                    `reconcile the source's declared cost.`,
-                severity: "medium",
-                area: "dispatch/cost",
-            }, "remediate-code");
+        onCostDrift: (info) => {
+            captureCostDriftFriction(artifactsDir, runId, info, "remediate-code");
         },
     });
     // Piece D — persist the rolling engine's partial-completion terminal onto state
@@ -1090,6 +1078,18 @@ async function forceReplanFromExistingIntake(root, artifactsDir, previous, store
         status: "pending",
         started_at: previous.started_at,
         step_count: previous.step_count,
+        // Carry the run-lifetime staging-manifest fields across a force-replan.
+        // Dropping run_start_dirty here would make handlePendingExtractedPlan's
+        // capture-once guard re-capture AFTER edits have landed, misclassifying
+        // the run's own hand-applied edits as pre-existing dirt (silently
+        // under-staged at close); applied_edit_surface is git-proven ground truth
+        // that must survive replanning for the same reason.
+        ...(previous.run_start_dirty
+            ? { run_start_dirty: previous.run_start_dirty }
+            : {}),
+        ...(previous.applied_edit_surface
+            ? { applied_edit_surface: previous.applied_edit_surface }
+            : {}),
     };
     const extractedPlan = await readExtractedPlanIfPresent(artifactsDir);
     if (!extractedPlan) {
@@ -1681,6 +1681,17 @@ async function handlePendingExtractedPlan(root, artifactsDir, existing, extracte
             throw new Error("Every extracted finding cited only phantom paths; re-extract with real repo-relative paths.");
         }
         const pipelined = await applyPlanPipeline(plan, { root, artifactsDir });
+        // Run-start dirty snapshot for the V2 staging manifest, capture-once: the
+        // extracted-plan join runs at plan time (before any remediation edit), so
+        // the dirty set here is pre-existing user dirt — the close phase excludes
+        // it from DECLARED-surface staging. runPlanPhase captures the same field on
+        // the structured-audit path; whichever join runs first wins.
+        if (!existing.run_start_dirty) {
+            existing = {
+                ...existing,
+                run_start_dirty: [...stagedAndUntracked(root)].sort(),
+            };
+        }
         const reviewDecision = await readOptionalJsonFile(reviewDecisionPath(artifactsDir));
         // Coverage ledger. Path A (structured_audit): the single filter pass ran at
         // intake over the ORIGINAL findings and persisted its dispositions — build
@@ -2010,12 +2021,12 @@ async function emitAutonomousLeftoverDeliverable(root, artifactsDir, leftovers)
     });
     // Prefer the canonical `.audit-tools/` location (defaultInputCandidates[0]);
     // fall back to the artifacts dir's parent when artifactsDir is non-standard.
-    const auditToolsDir = join(root, ".audit-tools");
-    const outDir = existsSync(auditToolsDir) ? auditToolsDir : dirname(artifactsDir);
+    const canonicalOutDir = auditToolsDir(root);
+    const outDir = existsSync(canonicalOutDir) ? canonicalOutDir : dirname(artifactsDir);
     await mkdir(outDir, { recursive: true });
     await Promise.all([
-        writeJsonFile(join(outDir, "audit-findings.json"), pair.findings_report),
-        writeTextFile(join(outDir, "audit-report.md"), pair.report_markdown),
+        writeJsonFile(join(outDir, AUDIT_FINDINGS_FILENAME), pair.findings_report),
+        writeTextFile(join(outDir, AUDIT_REPORT_FILENAME), pair.report_markdown),
     ]);
 }
 // ── Path-A filter dispositions (persisted for the coverage ledger) ──────────────
@@ -2114,21 +2125,37 @@ async function handleReadyIntakeContractPipeline(root, artifactsDir, options) {
                 }
                 // Persist the filter dispositions so coverage is built over the originals.
                 await persistReviewFilterDispositions(artifactsDir, originals, filter);
-                // A1 — conservative lean fast path. When the approved set is a handful
-                // of grounded, high-confidence, localized, non-cross-cutting findings,
-                // the run skips the heavy contract DESIGN loop and synthesizes the
-                // extracted plan directly; 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 (structured_audit), the only intake
-                // with a pre-existing finding set to judge.
+                // 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
+                // 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
+                // (structured_audit), the only intake with a pre-existing finding set to judge.
                 //
-                // T1 slice 3b — the fast path is NOT zero-scrutiny: an eligible run first
-                // runs a bounded LIGHT adversarial review over the approved findings (the
-                // floor, never off). A clear verdict proceeds to the lean plan; a verdict
-                // that surfaces a real concern escalates the risk signal (evidence the
-                // work is harder than assessed) and routes to the full pipeline below.
-                const fast = evaluateFastPath(gate.approved);
-                if (fast.eligible) {
+                // First fold the APPROVED set's finding-level risk (grounding / confidence /
+                // coupling / systemic / architecture / count — the finding-QUALITY dimension the
+                // intake path/breadth/intent signal doesn't see) INTO the shared risk signal as
+                // escalate-on-evidence. This makes the tier the SINGLE classifier: there is no
+                // separate fast-path boolean that can DISAGREE with it (a grounded handful
+                // touching a risk subsystem stays `high` and takes the full pipeline, instead of
+                // bypassing it as the old parallel `evaluateFastPath` allowed).
+                const findingEvidence = findingRiskEvidence(gate.approved);
+                let riskSignal = await readIntakeRiskSignal(artifactsDir);
+                if (findingEvidence && riskSignal) {
+                    const raised = escalateRiskSignal(riskSignal, findingEvidence);
+                    // escalateRiskSignal returns the SAME reference when the evidence does not
+                    // raise the tier — only persist on an actual change (no byte-identical rewrite).
+                    if (raised !== riskSignal) {
+                        riskSignal = raised;
+                        await writeIntakeRiskSignal(artifactsDir, riskSignal);
+                    }
+                }
+                // T1 slice 3b — the lean tier is NOT zero-scrutiny: a `low`-tier run first runs
+                // a bounded LIGHT adversarial review over the approved findings (the floor,
+                // never off — `adversarialDepthForTier("low") === "light"`). A clear verdict
+                // proceeds to the lean plan; a verdict that surfaces a real concern escalates
+                // the risk signal and routes to the full pipeline below.
+                if (gate.approved.length > 0 && riskSignal?.tier === "low") {
                     const review = await runLeanLightReviewGate(root, artifactsDir, gate.approved);
                     if (review.kind === "halt") {
                         return review.step;
@@ -2137,20 +2164,17 @@ async function handleReadyIntakeContractPipeline(root, artifactsDir, options) {
                         // Escalate-on-evidence: raise the signal to at least `medium` so the
                         // full pipeline's adversarial depth is `full` (see slice 3a), then
                         // fall through to the full pipeline.
-                        const current = await readIntakeRiskSignal(artifactsDir);
-                        if (current) {
-                            await writeIntakeRiskSignal(artifactsDir, escalateRiskSignal(current, {
-                                tier: "medium",
-                                reason: `lean light review surfaced a concern: ${review.concerns.join("; ")}`,
-                            }));
-                        }
+                        await writeIntakeRiskSignal(artifactsDir, escalateRiskSignal(riskSignal, {
+                            tier: "medium",
+                            reason: `lean light review surfaced a concern: ${review.concerns.join("; ")}`,
+                        }));
                         process.stderr.write(`[remediate-code] Lean light review escalated (${review.concerns.join("; ")}); routing to the full contract pipeline.\n`);
                     }
                     else {
                         // Clear verdict → proceed with the lean plan.
                         const leanPlan = buildLeanExtractedPlan(gate.approved, randomRunId("LEAN"));
                         await writeJsonFile(intakePaths(artifactsDir).extractedPlan, leanPlan);
-                        process.stderr.write(`[remediate-code] Lean fast path: ${fast.reason}; light review clear. Routing to plan→implement.\n`);
+                        process.stderr.write(`[remediate-code] Lean fast path (risk tier low): ${riskSignal.rationale.join("; ")}; light review clear. Routing to plan→implement.\n`);
                         const planned = await handlePendingExtractedPlan(root, artifactsDir, { status: "pending" }, leanPlan);
                         if (planned) {
                             return planned;