audit-tools 0.35.1 → 0.35.5

package/dist/remediate/steps/nextStep.js

@@ -37,7 +37,7 @@ import { resolveIntakeStep } from "./intakeResolver.js";
 import { runToolOwnedFinalGate, applyCoarseReblock, readFinalGateSidecar, writeFinalGateSidecar, } from "./finalGate.js";
 import { buildNextContractPipelineStep, shouldEnterContractPipeline, writePathASeedFromFindings, buildLeanExtractedPlan, } from "./contractPipeline.js";
 import { contractArtifactExists, contractPipelineDir, } from "../contractPipeline/artifactStore.js";
-import { buildReviewRequest, applyReviewResolution, isResolutionForRequest, REVIEW_REQUEST_SCHEMA_VERSION, } from "../review/reviewGate.js";
+import { buildReviewRequest, applyReviewResolution, isResolutionForRequest, screenResolutionIds, REVIEW_REQUEST_SCHEMA_VERSION, } from "../review/reviewGate.js";
 import { buildAutonomousReviewDecision } from "../review/autonomousGate.js";
 import { runFindingFilterPass } from "../findingFilter.js";
 import { intakePaths, isIntakeReady, readIntakeArtifacts, resolveManifestSources, } from "../intake.js";
@@ -1074,13 +1074,11 @@ function stripPlanTimeBookkeeping(value) {
 function findingCarryForwardKey(finding) {
     return JSON.stringify(stripPlanTimeBookkeeping(finding));
 }
-// FIRST-wins on multi-block membership: `fixupBlocksAfterDedup` can leave a
-// dedup survivor in more than one block's items, and historically the two
-// consumers disagreed (saveStateForPlan scanned blocks first-wins while this
-// map overwrote last-wins), so the same plan could yield different block_ids
-// per path. First-wins is pinned as the single semantic. The root question —
-// whether a finding should ever belong to two blocks at all — is tracked in
-// docs/backlog/open-bugs.md.
+// Single-block membership is enforced by `fixupBlocksAfterDedup` (each finding
+// id appears in exactly one block's items after fixup), so this scan is a plain
+// projection. First-wins in block order is kept as the tie-break for defense in
+// depth — it is the same order fixup resolves ownership in, so the two can
+// never disagree even on a malformed plan.
 function blockIdsByFinding(plan) {
     const byFinding = new Map();
     for (const block of plan.blocks) {
@@ -2094,14 +2092,14 @@ function extractAuditFindings(parsed) {
     }
     return [];
 }
-async function handleWaitingForReviewApproval(root, artifactsDir, request) {
+async function handleWaitingForReviewApproval(root, artifactsDir, request, refusal) {
     return writeCurrentStep({
         stepKind: "collect_review_approval",
         status: "blocked",
         runId: randomRunId("REVIEW"),
         repoRoot: root,
         artifactsDir,
-        prompt: reviewApprovalPrompt(request, reviewResolutionPath(artifactsDir)),
+        prompt: reviewApprovalPrompt(request, reviewResolutionPath(artifactsDir), refusal),
         allowedCommands: [loaderCommand("next-step")],
         stopCondition: "Stop after presenting the findings for approval and collecting the user's approve/disapprove decision, unless the decision is already recorded and the prompt told you to continue.",
         artifactPaths: {
@@ -2110,6 +2108,31 @@ async function handleWaitingForReviewApproval(root, artifactsDir, request) {
         },
     });
 }
+/**
+ * Uniform id-join contract pre-screen for the review gate (both paths): a
+ * resolution naming an unknown finding id or tier is REFUSED whole — archived
+ * (never applied) and the gate re-halts with the refusal and the valid set in
+ * the re-prompt. The gate's default is approve, so the silent-drop alternative
+ * turns a typo'd decline into an approval. Returns the re-halt step, or null
+ * when the resolution's ids are clean. `applyReviewResolution` re-checks as the
+ * mechanical backstop.
+ */
+async function refuseUnknownIdResolution(root, artifactsDir, request, resolution, resolutionPath, requestPath) {
+    const screen = screenResolutionIds(request, resolution);
+    if (screen.unknown_finding_ids.length === 0 && screen.unknown_tiers.length === 0) {
+        return null;
+    }
+    await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.refused-${Date.now()}`));
+    await writeJsonFile(requestPath, request);
+    const parts = [];
+    if (screen.unknown_finding_ids.length > 0) {
+        parts.push(`finding id(s) not in the request: ${screen.unknown_finding_ids.map((i) => `\`${i}\``).join(", ")}`);
+    }
+    if (screen.unknown_tiers.length > 0) {
+        parts.push(`unknown tier(s): ${screen.unknown_tiers.map((t) => `\`${t}\``).join(", ")}`);
+    }
+    return handleWaitingForReviewApproval(root, artifactsDir, request, parts.join("; "));
+}
 /**
  * Run the review-approval gate over the SURVIVOR finding set (already passed
  * through the single filter pass: deduped, evidence-bearing, path-grounded,
@@ -2186,6 +2209,9 @@ async function runReviewApprovalGate(root, artifactsDir, survivors, autonomous =
                 step: await handleWaitingForReviewApproval(root, artifactsDir, request),
             };
         }
+        const refusalStep = await refuseUnknownIdResolution(root, artifactsDir, request, resolution, resolutionPath, requestPath);
+        if (refusalStep)
+            return { kind: "halt", step: refusalStep };
         const decision = applyReviewResolution(request, resolution);
         const record = {
             schema_version: REVIEW_DECISION_SCHEMA_VERSION,
@@ -2765,11 +2791,25 @@ function applyClarificationActionToItem(item, res, now) {
  * Mirrors the triage resolution consume: reject_finding → terminal,
  * clarified → re-open (pending) for implement dispatch. Archives the file.
  */
-async function applyPlanClarificationResolution(artifactsDir, state, store) {
+async function applyPlanClarificationResolution(root, artifactsDir, state, store) {
     if (!state.plan || !state.items)
-        return state;
+        return { kind: "applied", state };
     const resolutionPath = join(artifactsDir, "clarification_resolution.json");
     const resolutions = normalizePlanClarificationResolutions(await readOptionalJsonFile(resolutionPath));
+    // Uniform id-join contract: an unknown finding_id refuses the WHOLE
+    // resolution (archived, nothing applied) and re-halts with the unknown ids
+    // named — the silent-continue alternative drops the user's answer on a typo'd
+    // id and force-closes its item as abandoned at the fall-through below.
+    const unknownIds = resolutions
+        .map((r) => r.finding_id)
+        .filter((id) => !state.items?.[id]);
+    if (unknownIds.length > 0) {
+        await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.refused-${Date.now()}`));
+        return {
+            kind: "refused",
+            step: await handleWaitingForClarification(root, artifactsDir, state, `finding id(s) not in the plan: ${unknownIds.map((i) => `\`${i}\``).join(", ")}`),
+        };
+    }
     const now = new Date().toISOString();
     for (const res of resolutions) {
         const item = state.items[res.finding_id];
@@ -2795,9 +2835,9 @@ async function applyPlanClarificationResolution(artifactsDir, state, store) {
     state.clarifications = [];
     state.closing_plan ??= { action: "none" };
     await store.saveState(state);
-    return state;
+    return { kind: "applied", state };
 }
-async function handleWaitingForClarification(root, artifactsDir, state) {
+async function handleWaitingForClarification(root, artifactsDir, state, refusal) {
     const clarifications = state.clarifications ??
         (await readOptionalJsonFile(join(artifactsDir, "clarification_request.json"))) ??
         [];
@@ -2808,7 +2848,7 @@ async function handleWaitingForClarification(root, artifactsDir, state) {
         runId: stateRunId(state),
         repoRoot: root,
         artifactsDir,
-        prompt: clarificationPrompt(clarifications, resolutionPath),
+        prompt: clarificationPrompt(clarifications, resolutionPath, refusal),
         allowedCommands: [loaderCommand("next-step")],
         stopCondition: "Stop after asking the user for clarification answers, unless the answers are already available and the prompt told you to continue.",
         artifactPaths: {
@@ -2877,6 +2917,9 @@ async function runPlanningReviewGate(root, artifactsDir, state, store) {
         await writeJsonFile(requestPath, request);
         return handleWaitingForReviewApproval(root, artifactsDir, request);
     }
+    const refusalStep = await refuseUnknownIdResolution(root, artifactsDir, request, resolution, resolutionPath, requestPath);
+    if (refusalStep)
+        return refusalStep;
     const decision = applyReviewResolution(request, resolution);
     const record = {
         schema_version: REVIEW_DECISION_SCHEMA_VERSION,
@@ -2982,7 +3025,7 @@ async function runPlanAmbiguityGate(root, artifactsDir, state, store) {
             runId: stateRunId(state),
             repoRoot: root,
             artifactsDir,
-            prompt: ambiguityReviewPrompt(candidates, resolutionPath),
+            prompt: ambiguityReviewPrompt(candidates, resolutionPath, findings.map((f) => f.id)),
             allowedCommands: [loaderCommand("next-step")],
             stopCondition: "Stop after reviewing the candidate ambiguities (and asking the user any genuine ones), unless the resolution is already written and the prompt told you to continue.",
             artifactPaths: {
@@ -2994,6 +3037,33 @@ async function runPlanAmbiguityGate(root, artifactsDir, state, store) {
     // Resolution present: apply it to items, mark the gate done, archive inputs so
     // it cannot re-halt.
     const resolutions = normalizePlanClarificationResolutions(await readOptionalJsonFile(resolutionPath));
+    // Uniform id-join contract: a resolution naming a finding id outside the plan
+    // is REFUSED whole (archived, nothing applied) and the gate re-halts with the
+    // unknown ids named — the silent-continue alternative drops a host answer on a
+    // typo'd id, leaving its item to fall to mid-run triage unexplained.
+    const validIds = new Set(findings.map((f) => f.id));
+    const unknownIds = resolutions
+        .map((r) => r.finding_id)
+        .filter((id) => !validIds.has(id));
+    if (unknownIds.length > 0) {
+        await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.refused-${Date.now()}`));
+        const candidates = (await readOptionalJsonFile(requestPath)) ??
+            detectPlanAmbiguities(findings, state.items);
+        return writeCurrentStep({
+            stepKind: "collect_clarifications",
+            status: "blocked",
+            runId: stateRunId(state),
+            repoRoot: root,
+            artifactsDir,
+            prompt: ambiguityReviewPrompt(candidates, resolutionPath, findings.map((f) => f.id), `finding id(s) not in the plan: ${unknownIds.map((i) => `\`${i}\``).join(", ")}`),
+            allowedCommands: [loaderCommand("next-step")],
+            stopCondition: "Stop after re-submitting a corrected ambiguity resolution, unless it is already written and the prompt told you to continue.",
+            artifactPaths: {
+                ambiguity_request: requestPath,
+                ambiguity_resolution: resolutionPath,
+            },
+        });
+    }
     const now = new Date().toISOString();
     let changed = false;
     for (const res of resolutions) {
@@ -3861,8 +3931,10 @@ function buildMainObligations(ctx) {
             execute: async (state) => {
                 const s = requireState(state);
                 if (existsSync(clarificationResolutionPath)) {
-                    const next = await applyPlanClarificationResolution(artifactsDir, s, store);
-                    return { kind: "transition", state: next };
+                    const outcome = await applyPlanClarificationResolution(root, artifactsDir, s, store);
+                    if (outcome.kind === "refused")
+                        return { kind: "emit", step: outcome.step };
+                    return { kind: "transition", state: outcome.state };
                 }
                 return {
                     kind: "emit",