audit-tools 0.32.46 → 0.32.47

package/dist/remediate/phases/close.js

@@ -337,15 +337,15 @@ const AUDIT_TOOLS_EXCLUDE_PATTERN = /^\.audit-tools\//;
  * RUN-START-DIRTY GUARD on source (2) ONLY: declared surfaces are plan-time
  * DECLARATIONS (write-access grants) / audit evidence — never verified against
  * an actual diff. A declared file that was ALREADY dirty when the run started
- * (`state.run_start_dirty`, captured in `runPlanPhase` before any remediation
- * edit exists) cannot be the run's edit, so it is excluded here — otherwise a
- * resolved item declaring a file the run never actually touched would sweep
- * pre-existing user WIP into the closing commit (the exact over-inclusion class
- * this manifest exists to close). Ground-truth entries from source (1) are
- * NEVER excluded by the snapshot: git proved the run landed those paths, and a
- * tool-merged edit to a file the user ALSO had dirty at run start is a path the
- * tool legitimately owns. A state without `run_start_dirty` (pre-field, or a
- * plan flow that bypasses `runPlanPhase`) means no exclusions.
+ * (`state.run_start_dirty`, captured at the extracted-plan join site before any
+ * remediation edit exists) cannot be the run's edit, so it is excluded here —
+ * otherwise a resolved item declaring a file the run never actually touched
+ * would sweep pre-existing user WIP into the closing commit (the exact
+ * over-inclusion class this manifest exists to close). Ground-truth entries
+ * from source (1) are NEVER excluded by the snapshot: git proved the run
+ * landed those paths, and a tool-merged edit to a file the user ALSO had dirty
+ * at run start is a path the tool legitimately owns. A state without
+ * `run_start_dirty` (pre-field) means no exclusions.
  *
  * Both sources empty is legitimate (e.g. a run that only produced
  * `resolved_no_change` / skipped items) and correctly yields an empty

package/dist/remediate/phases/plan.d.ts

@@ -1,8 +1,5 @@
-import { RemediationState } from "../state/store.js";
-import { OrchestratorOptions } from "../types/options.js";
 import { RemediationPlan, Finding, RemediationBlock, RemediationItemState, CoverageLedger } from "../state/types.js";
 import type { AuditFindingsReport, FindingTheme } from "audit-tools/shared";
-import { runTracked } from "audit-tools/shared";
 /**
  * Parse the auditor's canonical `audit-findings.json` (the machine contract) into
  * remediation findings, work blocks, and synthesis themes. The auditor emits this
@@ -22,21 +19,6 @@ export declare function parseAuditFindingsReport(report: AuditFindingsReport): {
  * contract_version is rejected here rather than silently trusted.
  */
 export declare function isAuditFindingsReport(value: unknown): value is AuditFindingsReport;
-interface PlanPhaseDeps {
-    enumerateTestFiles?: (root: string) => string[];
-    runCommand?: typeof runTracked;
-    now?: () => number;
-    /** Test seam: replaces the provider-backed free-form extraction worker. */
-    extractFindings?: (content: string, options: OrchestratorOptions) => Promise<{
-        findings: Finding[];
-        blocks: RemediationBlock[];
-    }>;
-    /** Test seam: replaces the provider-backed bounded path-repair worker. */
-    repairExtractedFindingPaths?: (requests: {
-        finding: Finding;
-        phantomPaths: string[];
-    }[]) => Promise<Map<string, string[]>>;
-}
 export declare function deriveBlocksFromTestGraph(findings: Finding[], testFiles: string[]): {
     blocks: RemediationBlock[];
     useful: boolean;
@@ -103,21 +85,11 @@ export declare function mergeBlocksSharingFiles(blocks: RemediationBlock[], find
  *   2. splitBlocksByContextBudget — keeps each block within the agent context window
  *   3. snapshotAffectedFileHashes — records baseline hashes for integrity checks
  *
- * Extracted so that both runPlanPhase (fast-path JSON reports) and
- * handlePendingExtractedPlan (LLM-extracted plans) run identical post-dedup
- * logic and the two paths cannot drift apart.
+ * Sole caller is handlePendingExtractedPlan (LLM-extracted plans join site);
+ * kept as its own function so the post-dedup logic has one home.
  */
 export declare function applyPlanPipeline(plan: RemediationPlan, options: {
     root: string;
     artifactsDir?: string;
 }): Promise<RemediationPlan>;
-/**
- * Prune blocks so that every item reference is still in the kept-findings set,
- * and drop blocks whose item list becomes empty after pruning.
- * Used in runPlanPhase wherever a reduction step drops some findings.
- * Extracted to eliminate the three formerly-duplicated inline occurrences of
- * blocks.map(b => ({...b, items: b.items.filter(id => keptIds.has(id))})).filter(...)
- */
-export declare function pruneBlocksForKeptFindings(blocks: RemediationBlock[], keptFindings: Finding[]): RemediationBlock[];
-export declare function runPlanPhase(state: RemediationState, options: OrchestratorOptions, deps?: PlanPhaseDeps): Promise<RemediationState>;
 //# sourceMappingURL=plan.d.ts.map

package/dist/remediate/phases/plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/remediate/phases/plan.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/remediate/phases/plan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,OAAO,EACP,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAe5E;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,mBAAmB,GAAG;IACrE,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB,CAgBA;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,mBAAmB,CAE9B;AAuBD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,OAAO,EAAE,EACnB,SAAS,EAAE,MAAM,EAAE,GAClB;IAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAiDjD;AAKD,OAAO,EACL,gCAAgC,IAAI,2BAA2B,EAC/D,8BAA8B,IAAI,iCAAiC,GACpE,MAAM,oBAAoB,CAAC;AAoH5B,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,OAAO,EAAE,EACnB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAMnC,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,CAeR;AA2BD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,gBAAgB,EAAE,EAC1B,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GACpB,gBAAgB,EAAE,CA+FpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,iFAAiF;IACjF,mBAAmB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC5C,oEAAoE;IACpE,mBAAmB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC5C;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;CAC7C,GAAG,cAAc,CAwFjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,gBAAgB,EAAE,EAC1B,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,SAAM,GACT,gBAAgB,EAAE,CA2DpB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/C,OAAO,CAAC,eAAe,CAAC,CAkB1B"}

package/dist/remediate/phases/plan.js

@@ -1,55 +1,9 @@
-import { writeFile, readFile } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
-import { isValidAuditFindingsReport, findingNeedsVerificationBeforeFix, interpretFreeFormIntent, } from "audit-tools/shared";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { isValidAuditFindingsReport } from "audit-tools/shared";
+import { readdirSync, statSync } from "node:fs";
 import { snapshotAffectedFileHashes } from "../utils/fileIntegrity.js";
-import { groundExtractedFindings, } from "./grounding.js";
-import { readOptionalJsonFile, readValidatedSessionConfig, writeJsonFile, readJsonFile, formatValidationIssues, stagedAndUntracked, discoverProjectCommands, resolveContextBudget, estimateTokensFromBytes, ESTIMATED_PROMPT_OVERHEAD_TOKENS, ESTIMATED_ITEM_OVERHEAD_TOKENS, chunkByBudget, runTracked, } from "audit-tools/shared";
-import { createFreshSessionProvider } from "../providers/index.js";
+import { readValidatedSessionConfig, resolveContextBudget, estimateTokensFromBytes, ESTIMATED_PROMPT_OVERHEAD_TOKENS, ESTIMATED_ITEM_OVERHEAD_TOKENS, chunkByBudget, } from "audit-tools/shared";
 import { canonicalizeFilePath } from "../dispatch/ownershipRegistry.js";
-import { deduplicateCrossLensFindings, fixupBlocksAfterDedup, } from "../dedup/crossLensDedup.js";
-import { filterFindingsByCheckpoint } from "../intent/checkpointFilter.js";
-import { applyIntentOrdering } from "../intent/intentOrdering.js";
-import { validateRemediationPlan, } from "../validation/remediationState.js";
-import { createLaunchInputForTask, createRemediationWorkerTask, } from "./workerTasks.js";
-function enumerateTestFiles(root) {
-    if (!existsSync(join(root, "package.json"))) {
-        return [];
-    }
-    // Try vitest first, then jest, and return the list of test file paths
-    const vitestResult = runTracked(["npx", "vitest", "--reporter=verbose", "--run", "--passWithNoTests", "list"], {
-        cwd: root,
-        encoding: "utf8",
-        timeout: 15000,
-    });
-    if (vitestResult.status === 0 && vitestResult.stdout) {
-        const files = vitestResult.stdout
-            .toString()
-            .split(/\r?\n/)
-            .map((l) => l.trim())
-            .filter((l) => l.length > 0 &&
-            !l.startsWith("✓") &&
-            !l.startsWith("×") &&
-            l.includes("."));
-        if (files.length > 0)
-            return files;
-    }
-    const jestResult = runTracked(["npx", "jest", "--listTests", "--no-coverage"], {
-        cwd: root,
-        encoding: "utf8",
-        timeout: 15000,
-    });
-    if (jestResult.status === 0 && jestResult.stdout) {
-        const files = jestResult.stdout
-            .toString()
-            .split(/\r?\n/)
-            .map((l) => l.trim())
-            .filter((l) => l.length > 0);
-        if (files.length > 0)
-            return files;
-    }
-    return [];
-}
 /**
  * Parse the auditor's canonical `audit-findings.json` (the machine contract) into
  * remediation findings, work blocks, and synthesis themes. The auditor emits this
@@ -83,16 +37,6 @@ export function parseAuditFindingsReport(report) {
 export function isAuditFindingsReport(value) {
     return isValidAuditFindingsReport(value);
 }
-/** Parse JSON content into an audit-findings report, or undefined if it is not one. */
-function tryParseFindingsReport(content) {
-    try {
-        const parsed = JSON.parse(content);
-        return isAuditFindingsReport(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 function createBlockId(counter) {
     return `B-${String(counter).padStart(3, "0")}`;
 }
@@ -153,63 +97,6 @@ export function deriveBlocksFromTestGraph(findings, testFiles) {
         useful: blocks.length < findings.length,
     };
 }
-function collectFileCommits(findings, root, commandRunner) {
-    const fileCommits = new Map();
-    for (const finding of findings) {
-        for (const file of finding.affected_files) {
-            if (fileCommits.has(file.path))
-                continue;
-            try {
-                const result = commandRunner(["git", "log", "--format=%H", "--", file.path], { cwd: root, encoding: "utf8" });
-                fileCommits.set(file.path, result.status === 0 && result.stdout
-                    ? new Set(result.stdout
-                        .toString()
-                        .split("\n")
-                        .map((s) => s.trim())
-                        .filter((s) => s.length > 0))
-                    : new Set());
-            }
-            catch {
-                fileCommits.set(file.path, new Set());
-            }
-        }
-    }
-    return fileCommits;
-}
-function deriveBlocksFromGitCocommit(findings, fileCommits) {
-    const blocks = [];
-    const fileToBlock = new Map();
-    let blockCounter = 1;
-    for (const finding of findings) {
-        let assignedBlock = null;
-        for (const file of finding.affected_files) {
-            if (fileToBlock.has(file.path)) {
-                assignedBlock = fileToBlock.get(file.path);
-                break;
-            }
-            const commitsA = fileCommits.get(file.path) ?? new Set();
-            for (const [existingFile, existingBlock] of fileToBlock.entries()) {
-                const commitsB = fileCommits.get(existingFile) ?? new Set();
-                let intersection = 0;
-                for (const c of commitsA)
-                    if (commitsB.has(c))
-                        intersection++;
-                const union = commitsA.size + commitsB.size - intersection;
-                if (union > 0 && intersection / union > 0.5) {
-                    assignedBlock = existingBlock;
-                    break;
-                }
-            }
-            if (assignedBlock)
-                break;
-        }
-        if (!assignedBlock) {
-            assignedBlock = createBlockId(blockCounter++);
-        }
-        assignFindingToBlock(finding, assignedBlock, blocks, fileToBlock);
-    }
-    return blocks;
-}
 // Block-sizing constants: now single-sourced from audit-tools/shared.
 // Re-exported under their legacy names so any callers outside this package
 // (and dispatch.ts) can migrate to the shared constants at their own pace.
@@ -443,32 +330,6 @@ export function splitBlocksByContextBudget(blocks, findings, root, contextBudget
     }
     return result;
 }
-function deriveFallbackBlocks(findings, options, deps) {
-    if (findings.length === 0)
-        return { blocks: [] };
-    const testFiles = deps.enumerateTestFiles?.(options.root) ?? enumerateTestFiles(options.root);
-    if (testFiles.length > 0) {
-        const testGraph = deriveBlocksFromTestGraph(findings, testFiles);
-        if (testGraph.useful) {
-            return { blocks: testGraph.blocks, blockStrategy: "test_graph" };
-        }
-    }
-    const fileCommits = collectFileCommits(findings, options.root, deps.runCommand ?? runTracked);
-    const gitBlocks = deriveBlocksFromGitCocommit(findings, fileCommits);
-    if (gitBlocks.some((b) => b.items.length > 1)) {
-        return { blocks: gitBlocks, blockStrategy: "git_cocommit" };
-    }
-    return {
-        blocks: findings.map((finding, index) => ({
-            block_id: createBlockId(index + 1),
-            items: [finding.id],
-            parallel_safe: true,
-            // One finding per block — declare its affected files as the block surface.
-            touched_files: finding.affected_files.map((af) => af.path),
-        })),
-        blockStrategy: "file_overlap",
-    };
-}
 /**
  * Account for every finding the plan received: each is marked `planned` (kept and
  * mapped to a block), `folded_into` (merged into a survivor by cross-lens dedup),
@@ -645,9 +506,8 @@ export function mergeBlocksSharingFiles(blocks, findings, root = ".") {
  *   2. splitBlocksByContextBudget — keeps each block within the agent context window
  *   3. snapshotAffectedFileHashes — records baseline hashes for integrity checks
  *
- * Extracted so that both runPlanPhase (fast-path JSON reports) and
- * handlePendingExtractedPlan (LLM-extracted plans) run identical post-dedup
- * logic and the two paths cannot drift apart.
+ * Sole caller is handlePendingExtractedPlan (LLM-extracted plans join site);
+ * kept as its own function so the post-dedup logic has one home.
  */
 export async function applyPlanPipeline(plan, options) {
     const { findings } = plan;
@@ -662,353 +522,4 @@ export async function applyPlanPipeline(plan, options) {
     snapshotAffectedFileHashes(options.root, findings);
     return { ...plan, blocks };
 }
-/**
- * Prune blocks so that every item reference is still in the kept-findings set,
- * and drop blocks whose item list becomes empty after pruning.
- * Used in runPlanPhase wherever a reduction step drops some findings.
- * Extracted to eliminate the three formerly-duplicated inline occurrences of
- * blocks.map(b => ({...b, items: b.items.filter(id => keptIds.has(id))})).filter(...)
- */
-export function pruneBlocksForKeptFindings(blocks, keptFindings) {
-    const keptIds = new Set(keptFindings.map((f) => f.id));
-    return blocks
-        .map((b) => ({ ...b, items: (b.items ?? []).filter((id) => keptIds.has(id)) }))
-        .filter((b) => (b.items ?? []).length > 0);
-}
-export async function runPlanPhase(state, options, deps = {}) {
-    console.log("Running Plan Phase...");
-    let findings = [];
-    let blocks = [];
-    let themes = [];
-    let extractedFromProse = false;
-    if (options.input && existsSync(options.input)) {
-        const content = await readFile(options.input, "utf8");
-        // Canonical hand-off: the auditor's audit-findings.json (the machine
-        // contract). Parsed directly; any other input is free-form and flows
-        // through the LLM extractor.
-        const findingsReport = tryParseFindingsReport(content);
-        if (findingsReport) {
-            console.log(`Consuming audit-findings report: ${options.input}`);
-            const parsed = parseAuditFindingsReport(findingsReport);
-            findings = parsed.findings;
-            blocks = parsed.blocks;
-            themes = parsed.themes;
-            // G1 + INV-GND-02: the auditor's grounding pass (S7) marks each finding
-            // grounded or ungrounded; a finding with NO grounding verdict is treated
-            // as ungrounded (verify-before-fix), never silently trusted. Surface the
-            // not-positively-grounded findings here so the operator sees them; the
-            // implement prompt additionally instructs the worker to verify such a
-            // finding against the cited code before applying any fix (see
-            // implementPrompt's grounding bullet). Findings are not dropped for being
-            // ungrounded — they are flagged for verification, not blindly fixed.
-            const needVerification = findings.filter((f) => findingNeedsVerificationBeforeFix(f));
-            if (needVerification.length > 0) {
-                console.warn(`Plan: ${needVerification.length} of ${findings.length} audit finding(s) are ungrounded or carry no grounding verdict; they will be verified-before-fix, not blindly applied: ${needVerification
-                    .map((f) => f.id)
-                    .join(", ")}`);
-            }
-        }
-        else {
-            console.log(`Extracting findings from input via LLM: ${options.input}`);
-            const extracted = await (deps.extractFindings
-                ? deps.extractFindings(content, options)
-                : extractFindingsWithProvider(content, state, options, deps));
-            findings = extracted.findings;
-            blocks = extracted.blocks;
-            extractedFromProse = true;
-        }
-    }
-    else {
-        console.log("No input provided or file does not exist. Halting Plan phase.");
-        throw new Error("Missing valid input for Plan phase.");
-    }
-    // Coverage accounting: snapshot the findings the plan received before any
-    // reduction, so the ledger below can mark every source finding as
-    // planned / folded / dropped — never silently lost.
-    const sourceFindings = [...findings];
-    // Deterministic grounding for LLM-extracted findings ONLY: strip phantom
-    // affected_files paths, give all-phantom findings one bounded repair attempt,
-    // drop the unrepaired, and classify evidence as grounded/ungrounded. The
-    // structured audit-findings path above is exempt — auditor paths are already
-    // grounded, and a since-deleted path there is the integrity check's replan
-    // concern, not a reason to drop the finding.
-    let grounding;
-    if (extractedFromProse) {
-        grounding = await groundExtractedFindings(findings, {
-            root: options.root,
-            repairZeroPathFindings: deps.repairExtractedFindingPaths ??
-                ((requests) => repairExtractedFindingPathsWithProvider(requests, options, deps)),
-        });
-        findings = grounding.findings;
-        if (grounding.phantomPathsByFinding.size > 0) {
-            const strippedTotal = [...grounding.phantomPathsByFinding.values()].flat();
-            console.warn(`Plan: grounding stripped ${strippedTotal.length} phantom path(s) across ${grounding.phantomPathsByFinding.size} extracted finding(s): ${strippedTotal.join(", ")}`);
-        }
-        if (grounding.dropped.length > 0) {
-            console.warn(`Plan: dropped ${grounding.dropped.length} extracted finding(s) with no real cited path after repair: ${grounding.dropped.map((d) => d.finding.id).join(", ")}`);
-            blocks = pruneBlocksForKeptFindings(blocks, findings);
-        }
-        if (grounding.ungroundedFindingIds.length > 0) {
-            console.warn(`Plan: ${grounding.ungroundedFindingIds.length} extracted finding(s) have no evidence citing a real repo path (downgraded to low confidence): ${grounding.ungroundedFindingIds.join(", ")}`);
-        }
-    }
-    // Robustness: a finding with empty evidence fails the plan validator and would
-    // abort the entire run. Skip such malformed findings (and prune them from
-    // blocks) with a warning instead of crashing — findings are advisory, so one
-    // bad finding must not block the whole report.
-    const findingsWithoutEvidence = findings
-        .filter((f) => !Array.isArray(f.evidence) || f.evidence.length === 0)
-        .map((f) => f.id);
-    if (findingsWithoutEvidence.length > 0) {
-        console.warn(`Plan: skipping ${findingsWithoutEvidence.length} finding(s) with no evidence: ${findingsWithoutEvidence.join(", ")}`);
-        findings = findings.filter((f) => Array.isArray(f.evidence) && f.evidence.length > 0);
-        blocks = pruneBlocksForKeptFindings(blocks, findings);
-    }
-    // Cross-lens dedup: merge findings that different audit lenses flagged independently
-    const dedup = deduplicateCrossLensFindings(findings);
-    findings = dedup.findings;
-    blocks = fixupBlocksAfterDedup(blocks, dedup.mergeMap);
-    // Intent checkpoint: drop findings the host filtered out (by severity / lens /
-    // package / theme) or excluded by path, so only the requested work is planned.
-    // Dropped findings are recorded in the coverage ledger and the final report.
-    let intentCheckpoint;
-    try {
-        intentCheckpoint = await readOptionalJsonFile(join(options.artifactsDir, "intent_checkpoint.json"));
-    }
-    catch {
-        console.warn("Plan: intent_checkpoint.json was unreadable; ignoring checkpoint filters.");
-    }
-    const { kept: keptFindings, droppedIds: droppedByCheckpoint } = filterFindingsByCheckpoint(findings, intentCheckpoint);
-    if (droppedByCheckpoint.length > 0) {
-        console.warn(`Plan: intent checkpoint dropped ${droppedByCheckpoint.length} finding(s) from remediation.`);
-        findings = keptFindings;
-        blocks = pruneBlocksForKeptFindings(blocks, findings);
-    }
-    // Fallback blocks computation if none provided
-    let blockStrategy;
-    if (blocks.length === 0 && findings.length > 0) {
-        const fallback = deriveFallbackBlocks(findings, options, deps);
-        blocks = fallback.blocks;
-        blockStrategy = fallback.blockStrategy;
-    }
-    // Apply the shared post-dedup pipeline (file-overlap merge, context-budget
-    // split, and baseline file-hash snapshot). Extracted into applyPlanPipeline
-    // so the LLM-extracted-plan path runs the exact same logic.
-    ({
-        blocks,
-        findings,
-    } = await applyPlanPipeline({
-        plan_id: "",
-        findings,
-        blocks,
-        project_type: "unknown",
-        candidate_closing_actions: ["none"],
-    }, options));
-    // DC-1: fold the confirmed checkpoint's structured free_form_intent into block
-    // and finding ORDERING (never filtering — that already happened above via the
-    // checkpoint filters). The raw string is interpreted ONCE by the single shared
-    // interpreter into lens/priority/scope signals (INV-S04: the verbatim string is
-    // never read here and never reaches a worker prompt); emphasised work sorts
-    // first. A blank/absent free_form_intent is a strict no-op.
-    if (intentCheckpoint?.confirmed_by === "host" &&
-        typeof intentCheckpoint.free_form_intent === "string" &&
-        intentCheckpoint.free_form_intent.trim().length > 0) {
-        const interpreted = interpretFreeFormIntent(intentCheckpoint.free_form_intent);
-        ({ findings, blocks } = applyIntentOrdering(findings, blocks, interpreted));
-    }
-    // Project command discovery (shared; now also covers Go and Python). The
-    // RemediationPlan stores commands as strings, so argv arrays are joined.
-    const commands = discoverProjectCommands(options.root);
-    const testCommand = commands.test ? commands.test.join(" ") : undefined;
-    const e2eCommand = commands.e2e ? commands.e2e.join(" ") : undefined;
-    let projectType = "unknown";
-    if (existsSync(join(options.root, "package.json"))) {
-        projectType = "typescript-node";
-    }
-    else if (existsSync(join(options.root, "go.mod"))) {
-        projectType = "go";
-    }
-    else if (existsSync(join(options.root, "pyproject.toml")) ||
-        existsSync(join(options.root, "pytest.ini"))) {
-        projectType = "python";
-    }
-    const plan = {
-        plan_id: "PLAN-" + (deps.now?.() ?? Date.now()),
-        findings,
-        blocks,
-        project_type: projectType,
-        test_command: testCommand,
-        ...(e2eCommand ? { e2e_command: e2eCommand } : {}),
-        candidate_closing_actions: ["none"],
-        ...(blockStrategy ? { block_strategy: blockStrategy } : {}),
-        ...(themes.length > 0 ? { themes } : {}),
-    };
-    const items = {};
-    for (const finding of findings) {
-        const block = blocks.find((b) => b.items.includes(finding.id));
-        items[finding.id] = {
-            finding_id: finding.id,
-            status: "pending",
-            block_id: block ? block.block_id : "UNKNOWN",
-        };
-    }
-    // Coverage ledger: make every source finding's disposition auditable, so a
-    // large source set consolidated into fewer items is recorded rather than lost.
-    const coverage = buildCoverageLedger({
-        planId: plan.plan_id,
-        sourceFindings,
-        droppedNoEvidence: findingsWithoutEvidence,
-        droppedByCheckpoint,
-        droppedPhantomPaths: new Map((grounding?.dropped ?? []).map((d) => [d.finding.id, d.phantomPaths])),
-        phantomPathsRemoved: grounding?.phantomPathsByFinding,
-        mergeMap: dedup.mergeMap,
-        items,
-    });
-    console.log(`Plan coverage: ${coverage.planned_count} planned, ${coverage.folded_count} folded, ${coverage.dropped_count} dropped (of ${coverage.source_finding_count} source finding(s)).`);
-    const planIssues = validateRemediationPlan(plan);
-    if (planIssues.length > 0) {
-        console.error(`Plan validation issues:\n${formatValidationIssues(planIssues)}`);
-        const errors = planIssues.filter((i) => i.severity === "error");
-        if (errors.length > 0) {
-            throw new Error(`Plan phase produced an invalid plan:\n${formatValidationIssues(errors)}`);
-        }
-    }
-    // Emit remediation_plan.json
-    await writeJsonFile(join(options.artifactsDir, "remediation_plan.json"), plan);
-    // Run-start dirty snapshot (V2 staging-manifest fix, finding 1): capture the
-    // files that are ALREADY dirty before any remediation edit exists. The close
-    // phase excludes these from the DECLARED (fallback) staging-manifest sources —
-    // a file dirty before the run started cannot be one of the run's edits, so a
-    // plan-time declaration (item_spec.touched_files / affected_files) can never
-    // sweep pre-existing user WIP into the closing commit. Captured ONCE: a replan
-    // (force-replan after edits landed) must NOT re-capture, or the run's own
-    // hand-applied edits would be misclassified as pre-existing dirt.
-    const runStartDirty = state.run_start_dirty ?? [...stagedAndUntracked(options.root)].sort();
-    return {
-        ...state,
-        status: "planning",
-        plan,
-        items,
-        plan_coverage: coverage,
-        run_start_dirty: runStartDirty,
-    };
-}
-/**
- * Launch one bounded plan-phase LLM worker and read its result JSON. Shared by
- * the free-form extraction pass and the single bounded path-repair pass; the
- * label keys the per-task artifact files (task/prompt/result/stdout/stderr).
- */
-async function runPlanWorkerTask(params) {
-    const { label, obligationId, buildPrompt, options, deps } = params;
-    const sessionConfig = (await readValidatedSessionConfig(join(options.root, "session-config.json"))) || {};
-    const provider = createFreshSessionProvider(undefined, sessionConfig);
-    const workerTimeoutMs = sessionConfig.timeout_ms;
-    const taskPath = join(options.artifactsDir, `task_${label}.json`);
-    const resultPath = join(options.artifactsDir, `result_${label}.json`);
-    const promptPath = join(options.artifactsDir, `prompt_${label}.md`);
-    const stdoutPath = join(options.artifactsDir, `stdout_${label}.txt`);
-    const stderrPath = join(options.artifactsDir, `stderr_${label}.txt`);
-    await writeFile(promptPath, buildPrompt({ taskPath, resultPath }), "utf8");
-    const task = createRemediationWorkerTask({
-        runId: "PLAN-" + (deps.now?.() ?? Date.now()),
-        options,
-        obligationId,
-        preferredExecutor: provider.name,
-        resultPath,
-        timeoutMs: workerTimeoutMs,
-    });
-    await writeJsonFile(taskPath, task);
-    await provider.launch(createLaunchInputForTask(options, task, {
-        promptPath,
-        taskPath,
-        stdoutPath,
-        stderrPath,
-    }));
-    return readJsonFile(resultPath);
-}
-async function extractFindingsWithProvider(content, _state, options, deps) {
-    try {
-        const extracted = await runPlanWorkerTask({
-            label: "plan",
-            obligationId: "extract-plan",
-            options,
-            deps,
-            buildPrompt: ({ taskPath, resultPath }) => `
-You are the Remediation Assistant. Your task is to extract findings and work blocks from the provided document.
-Produce a JSON output matching the remediation plan structure (specifically the findings and blocks arrays).
-
-Grounding requirements (a deterministic validator checks every path you cite):
-- Each \`affected_files[].path\` must be a repo-relative path that exists on disk. Verify before citing; never guess paths from prose.
-- If you cannot identify a real file for a finding, emit an empty \`affected_files\` array instead of inventing one — discovery happens later.
-- Each \`evidence\` entry should cite a real \`path:line\` location when one exists (e.g. "src/auth.ts:42 — token is never revoked"). Quote the source document only when no code location applies.
-
-Document Content:
-${content}
-
-Your task JSON is at: ${taskPath}
-Write your result JSON to exactly this path: ${resultPath}
-Use the Write tool to create or overwrite that file.
-Do not write to any other path.
-    `.trim(),
-        });
-        return {
-            findings: extracted.findings || [],
-            blocks: extracted.blocks || [],
-        };
-    }
-    catch (e) {
-        console.error("Failed to extract plan via LLM:", e);
-        throw new Error("Plan extraction failed.");
-    }
-}
-/**
- * The single bounded repair attempt for extracted findings whose cited paths
- * were all phantom (WS1). Re-prompts the worker with the phantom paths named;
- * the worker either supplies real repo-relative paths or withdraws the finding.
- * The caller re-validates every returned path — repair output is untrusted.
- */
-async function repairExtractedFindingPathsWithProvider(requests, options, deps) {
-    const findingSections = requests
-        .map(({ finding, phantomPaths }) => `
-### ${finding.id} — ${finding.title}
-
-- Summary: ${finding.summary}
-- Evidence: ${(finding.evidence ?? []).join(" | ")}
-- Phantom paths cited (do NOT exist in the repository): ${phantomPaths.join(", ")}`)
-        .join("\n");
-    const repaired = await runPlanWorkerTask({
-        label: "plan_path_repair",
-        obligationId: "repair-extracted-paths",
-        options,
-        deps,
-        buildPrompt: ({ taskPath, resultPath }) => `
-You are the Remediation Assistant. Earlier extraction cited file paths that do not exist in the repository. For each finding below, locate the REAL repo-relative path(s) the finding is about (search the repository), or withdraw the finding if it does not apply to this codebase.
-${findingSections}
-
-Rules:
-- Cite only repo-relative paths that exist on disk; verify each one before writing it.
-- To withdraw a finding, return it with an empty \`affected_files\` array (or omit it).
-- Do not edit source files.
-
-Your task JSON is at: ${taskPath}
-Write your result JSON to exactly this path: ${resultPath}
-
-\`\`\`json
-{
-  "repairs": [
-    { "finding_id": "FINDING-001", "affected_files": ["real/path/to/file.ts"] }
-  ]
-}
-\`\`\`
-`.trim(),
-    });
-    return new Map((repaired.repairs ?? [])
-        .filter((entry) => typeof entry?.finding_id === "string")
-        .map((entry) => [
-        entry.finding_id,
-        Array.isArray(entry.affected_files)
-            ? entry.affected_files.filter((p) => typeof p === "string")
-            : [],
-    ]));
-}
 //# sourceMappingURL=plan.js.map