auditor-lambda 0.1.0 → 0.2.1

package/dist/cli.js

@@ -1,6 +1,6 @@
 import { mkdir } from "node:fs/promises";
 import { createReadStream } from "node:fs";
-import { resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { buildRepoManifest } from "./extractors/fileInventory.js";
 import { buildFileDisposition } from "./extractors/disposition.js";
 import { buildCriticalFlowManifest } from "./extractors/flows.js";
@@ -12,6 +12,7 @@ import { initializeCoverageFromPlan } from "./orchestrator/planning.js";
 import { loadArtifactBundle, writeCoreArtifacts, } from "./io/artifacts.js";
 import { readJsonFile, writeJsonFile } from "./io/json.js";
 import { validateArtifactBundle } from "./validation/artifacts.js";
+import { validateAuditResults, formatAuditResultIssues, } from "./validation/auditResults.js";
 import { validateConfiguredProviderEnvironment, validateSessionConfig, } from "./validation/sessionConfig.js";
 import { buildSynthesisReport } from "./reporting/synthesis.js";
 import { deriveAuditState } from "./orchestrator/state.js";
@@ -47,8 +48,41 @@ function getRootDir(argv) {
     return resolve(getFlag(argv, "--root", "."));
 }
 function getMaxRuns(argv) {
-    const raw = Number(getFlag(argv, "--max-runs", "25"));
-    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 25;
+    const raw = Number(getFlag(argv, "--max-runs", "1000"));
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 1000;
+}
+function getAgentBatchSize(argv, sessionConfig) {
+    const fromArg = getFlag(argv, "--agent-batch-size");
+    if (fromArg !== undefined) {
+        const parsed = Number(fromArg);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return Math.floor(parsed);
+    }
+    if (typeof sessionConfig.agent_task_batch_size === "number" &&
+        sessionConfig.agent_task_batch_size > 0) {
+        return Math.floor(sessionConfig.agent_task_batch_size);
+    }
+    return 1;
+}
+function getParallelWorkers(argv, sessionConfig) {
+    const fromArg = getFlag(argv, "--parallel");
+    if (fromArg !== undefined) {
+        const parsed = Number(fromArg);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return Math.floor(parsed);
+    }
+    if (typeof sessionConfig.parallel_workers === "number" &&
+        sessionConfig.parallel_workers > 0) {
+        return Math.floor(sessionConfig.parallel_workers);
+    }
+    return 1;
+}
+function chunkArray(arr, size) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size) {
+        chunks.push(arr.slice(i, i + size));
+    }
+    return chunks;
 }
 function getUiMode(argv, fallback = "headless") {
     const raw = getFlag(argv, "--ui");
@@ -160,6 +194,25 @@ async function buildLineIndex(root, repoManifest) {
     }
     return Object.fromEntries(entries);
 }
+function resolveModelForTasks(tasks, sessionConfig) {
+    if (!sessionConfig.model_tiers)
+        return undefined;
+    const tiers = [
+        "capable",
+        "balanced",
+        "fast",
+    ];
+    for (const tier of tiers) {
+        if (tasks.some((t) => t.model_hint === tier)) {
+            return sessionConfig.model_tiers[tier];
+        }
+    }
+    return undefined;
+}
+function buildPendingAuditTasks(bundle) {
+    const completedTaskIds = new Set((bundle.audit_results ?? []).map((result) => result.task_id));
+    return (bundle.audit_tasks ?? []).filter((task) => !completedTaskIds.has(task.task_id));
+}
 async function runAuditStep(options) {
     const bundle = await loadArtifactBundle(options.artifactsDir);
     const auditResults = options.auditResultsPath
@@ -282,6 +335,8 @@ async function cmdRunToCompletion(argv) {
     const provider = createFreshSessionProvider(getFlag(argv, "--provider"), sessionConfig);
     const uiMode = getUiMode(argv, sessionConfig.ui_mode ?? "headless");
     const maxRuns = getMaxRuns(argv);
+    const agentBatchSize = getAgentBatchSize(argv, sessionConfig);
+    const parallelWorkers = getParallelWorkers(argv, sessionConfig);
     const timeoutMs = sessionConfig.timeout_ms ?? 30 * 60 * 1000;
     const selfCliPath = resolve(process.argv[1] ?? "");
     await mkdir(artifactsDir, { recursive: true });
@@ -328,6 +383,32 @@ async function cmdRunToCompletion(argv) {
                 ...bundle,
                 audit_state: blockedState,
             });
+            const blockRunId = buildRunId(obligationId, runCount + 1);
+            const blockPaths = getRunPaths(artifactsDir, blockRunId);
+            const blockPendingTasks = buildPendingAuditTasks(bundle).slice(0, agentBatchSize);
+            const blockPendingTasksPath = join(blockPaths.runDir, "pending-audit-tasks.json");
+            const blockAuditResultsPath = join(blockPaths.runDir, "audit-results.json");
+            const blockTask = {
+                contract_version: "audit-code-worker/v1alpha1",
+                run_id: blockRunId,
+                repo_root: root,
+                artifacts_dir: artifactsDir,
+                obligation_id: obligationId,
+                preferred_executor: preferredExecutor,
+                result_path: blockPaths.resultPath,
+                worker_command: [
+                    process.execPath,
+                    selfCliPath,
+                    "worker-run",
+                    "--task",
+                    blockPaths.taskPath,
+                ],
+                audit_results_path: blockAuditResultsPath,
+                pending_audit_tasks_path: blockPendingTasksPath,
+            };
+            const blockPrompt = renderWorkerPrompt(blockTask);
+            await writeWorkerTaskFiles(blockTask, blockPrompt, blockPaths, artifactsDir);
+            await writeJsonFile(blockPendingTasksPath, blockPendingTasks);
             await emitEnvelope({
                 root,
                 artifactsDir,
@@ -369,9 +450,143 @@ async function cmdRunToCompletion(argv) {
             });
             return;
         }
+        if (preferredExecutor === "agent" && parallelWorkers > 1) {
+            const allPendingTasks = buildPendingAuditTasks(bundle);
+            const taskGroups = chunkArray(allPendingTasks.slice(0, parallelWorkers * agentBatchSize), agentBatchSize);
+            const workerSlots = [];
+            for (const group of taskGroups) {
+                runCount += 1;
+                const slotRunId = buildRunId(obligationId, runCount);
+                const slotPaths = getRunPaths(artifactsDir, slotRunId);
+                const slotAuditResultsPath = join(slotPaths.runDir, "audit-results.json");
+                const slotPendingTasksPath = join(slotPaths.runDir, "pending-audit-tasks.json");
+                const slotTask = {
+                    contract_version: "audit-code-worker/v1alpha1",
+                    run_id: slotRunId,
+                    repo_root: root,
+                    artifacts_dir: artifactsDir,
+                    obligation_id: obligationId,
+                    preferred_executor: "agent",
+                    result_path: slotPaths.resultPath,
+                    worker_command: [
+                        process.execPath,
+                        selfCliPath,
+                        "worker-run",
+                        "--task",
+                        slotPaths.taskPath,
+                    ],
+                    audit_results_path: slotAuditResultsPath,
+                    pending_audit_tasks_path: slotPendingTasksPath,
+                    skip_worker_command: true,
+                };
+                const slotPrompt = renderWorkerPrompt(slotTask);
+                await writeWorkerTaskFiles(slotTask, slotPrompt, slotPaths, artifactsDir);
+                await writeJsonFile(slotPendingTasksPath, group);
+                workerSlots.push({
+                    runId: slotRunId,
+                    paths: slotPaths,
+                    auditResultsPath: slotAuditResultsPath,
+                    pendingTasksPath: slotPendingTasksPath,
+                    group,
+                });
+            }
+            const parallelStartedAt = new Date().toISOString();
+            await Promise.allSettled(workerSlots.map((slot) => provider.launch({
+                repoRoot: root,
+                runId: slot.runId,
+                obligationId,
+                promptPath: slot.paths.promptPath,
+                taskPath: slot.paths.taskPath,
+                resultPath: slot.paths.resultPath,
+                stdoutPath: slot.paths.stdoutPath,
+                stderrPath: slot.paths.stderrPath,
+                uiMode,
+                timeoutMs,
+                model: resolveModelForTasks(slot.group, sessionConfig),
+            })));
+            let batchProgress = false;
+            for (const slot of workerSlots) {
+                const parallelEndedAt = new Date().toISOString();
+                let slotStatus = "no_progress";
+                try {
+                    const auditResults = await readJsonFile(slot.auditResultsPath);
+                    const pendingTaskIds = new Set(slot.group.map((t) => t.task_id));
+                    const matchedCount = auditResults.filter((r) => pendingTaskIds.has(r.task_id)).length;
+                    if (slot.group.length > 0 && matchedCount === 0) {
+                        throw new Error("Worker did not emit any audit results for the assigned tasks.");
+                    }
+                    const issues = validateAuditResults(auditResults, slot.group);
+                    const errors = issues.filter((issue) => issue.severity === "error");
+                    const warnings = issues.filter((issue) => issue.severity === "warning");
+                    if (warnings.length > 0) {
+                        process.stderr.write(`audit-results validation: ${warnings.length} warning(s) for ${slot.runId}:\n` +
+                            formatAuditResultIssues(warnings) +
+                            "\n");
+                    }
+                    if (errors.length > 0) {
+                        throw new Error(`audit-results validation failed with ${errors.length} error(s):\n` +
+                            formatAuditResultIssues(errors));
+                    }
+                    const stepResult = await runAuditStep({
+                        root,
+                        artifactsDir,
+                        preferredExecutor: "result_ingestion_executor",
+                        auditResultsPath: slot.auditResultsPath,
+                    });
+                    slotStatus = stepResult.progress_made ? "completed" : "no_progress";
+                    batchProgress ||= stepResult.progress_made;
+                    if (stepResult.progress_made)
+                        anyProgress = true;
+                    for (const a of stepResult.artifacts_written)
+                        artifactsWritten.add(a);
+                }
+                catch {
+                    slotStatus = "failed";
+                }
+                await appendRunLedgerEntry(artifactsDir, {
+                    run_id: slot.runId,
+                    provider: provider.name,
+                    obligation_id: obligationId,
+                    selected_executor: "agent",
+                    status: slotStatus,
+                    started_at: parallelStartedAt,
+                    ended_at: parallelEndedAt,
+                    result_path: slot.paths.resultPath,
+                });
+                artifactsWritten.add("run-ledger.json");
+            }
+            if (!batchProgress) {
+                const bundleAfter = await loadArtifactBundle(artifactsDir);
+                const state = bundleAfter.audit_state ?? deriveAuditState(bundleAfter);
+                await emitEnvelope({
+                    root,
+                    artifactsDir,
+                    bundle: bundleAfter,
+                    audit_state: state,
+                    selected_obligation: obligationId,
+                    selected_executor: "agent",
+                    progress_made: anyProgress,
+                    artifacts_written: Array.from(artifactsWritten),
+                    progress_summary: "Parallel worker batch made no progress.",
+                    next_likely_step: obligationId,
+                    providerName: provider.name,
+                });
+                return;
+            }
+            continue;
+        }
         runCount += 1;
         const runId = buildRunId(obligationId, runCount);
         const paths = getRunPaths(artifactsDir, runId);
+        const pendingAuditTasks = preferredExecutor === "agent"
+            ? buildPendingAuditTasks(bundle).slice(0, agentBatchSize)
+            : undefined;
+        const pendingAuditTasksPath = preferredExecutor === "agent"
+            ? join(paths.runDir, "pending-audit-tasks.json")
+            : undefined;
+        const providerAuditResultsPath = preferredExecutor === "agent"
+            ? join(paths.runDir, "audit-results.json")
+            : auditResultsPath;
         const task = {
             contract_version: "audit-code-worker/v1alpha1",
             run_id: runId,
@@ -387,12 +602,16 @@ async function cmdRunToCompletion(argv) {
                 "--task",
                 paths.taskPath,
             ],
-            audit_results_path: auditResultsPath,
+            audit_results_path: providerAuditResultsPath,
+            pending_audit_tasks_path: pendingAuditTasksPath,
             runtime_updates_path: runtimeUpdatesPath,
             external_analyzer_results_path: externalAnalyzerPath,
         };
         const prompt = renderWorkerPrompt(task);
         await writeWorkerTaskFiles(task, prompt, paths, artifactsDir);
+        if (pendingAuditTasksPath && pendingAuditTasks) {
+            await writeJsonFile(pendingAuditTasksPath, pendingAuditTasks);
+        }
         const startedAt = new Date().toISOString();
         let workerResult;
         try {
@@ -407,6 +626,9 @@ async function cmdRunToCompletion(argv) {
                 stderrPath: paths.stderrPath,
                 uiMode,
                 timeoutMs,
+                model: pendingAuditTasks
+                    ? resolveModelForTasks(pendingAuditTasks, sessionConfig)
+                    : undefined,
             });
             const candidate = await readJsonFile(paths.resultPath);
             workerResult = isWorkerResult(candidate)
@@ -459,7 +681,7 @@ async function cmdRunToCompletion(argv) {
         artifactsWritten.add("run-ledger.json");
         if (externalAnalyzerPath)
             pendingExternalAnalyzerPath = undefined;
-        if (auditResultsPath)
+        if (providerAuditResultsPath)
             pendingAuditResultsPath = undefined;
         if (runtimeUpdatesPath)
             pendingRuntimeUpdatesPath = undefined;
@@ -509,10 +731,39 @@ async function cmdWorkerRun(argv) {
     const task = await readJsonFile(taskPath);
     let workerResult;
     try {
+        if (task.preferred_executor === "agent" && !task.audit_results_path) {
+            throw new Error("agent worker-run requires audit_results_path so provider-assisted review can be ingested.");
+        }
+        if (task.preferred_executor === "agent" && task.audit_results_path) {
+            const pendingTasks = task.pending_audit_tasks_path
+                ? await readJsonFile(task.pending_audit_tasks_path)
+                : [];
+            const auditResults = await readJsonFile(task.audit_results_path);
+            const pendingTaskIds = new Set(pendingTasks.map((item) => item.task_id));
+            const matchedResultCount = auditResults.filter((result) => pendingTaskIds.has(result.task_id)).length;
+            if (pendingTasks.length > 0 && matchedResultCount === 0) {
+                throw new Error("Provider-assisted review did not emit any audit results for the pending audit tasks.");
+            }
+            const issues = validateAuditResults(auditResults, pendingTasks);
+            const errors = issues.filter((issue) => issue.severity === "error");
+            const warnings = issues.filter((issue) => issue.severity === "warning");
+            if (warnings.length > 0) {
+                process.stderr.write(`audit-results validation: ${warnings.length} warning(s):\n` +
+                    formatAuditResultIssues(warnings) +
+                    "\n");
+            }
+            if (errors.length > 0) {
+                throw new Error(`audit-results validation failed with ${errors.length} error(s):\n` +
+                    formatAuditResultIssues(errors));
+            }
+        }
+        const preferredExecutor = task.preferred_executor === "agent"
+            ? "result_ingestion_executor"
+            : task.preferred_executor;
         const result = await runAuditStep({
             root: task.repo_root,
             artifactsDir: task.artifacts_dir,
-            preferredExecutor: task.preferred_executor,
+            preferredExecutor,
             auditResultsPath: task.audit_results_path,
             runtimeUpdatesPath: task.runtime_updates_path,
             externalAnalyzerPath: task.external_analyzer_results_path,
@@ -630,11 +881,7 @@ async function cmdValidate(argv) {
     const providerIssues = rawSessionConfig === undefined || sessionConfigIssues.length > 0
         ? []
         : prefixValidationIssues("session_config", validateConfiguredProviderEnvironment(rawSessionConfig));
-    const issues = [
-        ...artifactIssues,
-        ...sessionConfigIssues,
-        ...providerIssues,
-    ];
+    const issues = [...artifactIssues, ...sessionConfigIssues, ...providerIssues];
     const resolvedProvider = rawSessionConfig === undefined
         ? "local-subprocess"
         : sessionConfigIssues.length > 0

package/dist/coverage.d.ts

@@ -1,5 +1,4 @@
 import type { CoverageFileRecord, CoverageMatrix, Lens, ReviewedLineRange } from "./types.js";
-export declare function mergeRanges(ranges: ReviewedLineRange[]): ReviewedLineRange[];
 export declare function createCoverageMatrix(paths: string[]): CoverageMatrix;
 export declare function markExcludedPath(matrix: CoverageMatrix, path: string, classificationStatus: string): void;
 export declare function applyUnitCoverage(matrix: CoverageMatrix, path: string, unitId: string, requiredLenses: Lens[]): void;

package/dist/coverage.js

@@ -1,29 +1,3 @@
-function sortRanges(ranges) {
-    return [...ranges].sort((a, b) => {
-        if (a.path !== b.path)
-            return a.path.localeCompare(b.path);
-        if (a.start !== b.start)
-            return a.start - b.start;
-        return a.end - b.end;
-    });
-}
-export function mergeRanges(ranges) {
-    const sorted = sortRanges(ranges);
-    const merged = [];
-    for (const range of sorted) {
-        const last = merged[merged.length - 1];
-        if (!last || last.path !== range.path || range.start > last.end + 1) {
-            merged.push({ ...range });
-            continue;
-        }
-        last.end = Math.max(last.end, range.end);
-        last.pass_id = `${last.pass_id},${range.pass_id}`;
-        last.agent_role = [last.agent_role, range.agent_role]
-            .filter(Boolean)
-            .join(",");
-    }
-    return merged;
-}
 export function createCoverageMatrix(paths) {
     return {
         files: paths.map((path) => ({
@@ -33,7 +7,6 @@ export function createCoverageMatrix(paths) {
             audit_status: "pending",
             required_lenses: [],
             completed_lenses: [],
-            reviewed_line_ranges: [],
         })),
     };
 }
@@ -45,7 +18,6 @@ export function markExcludedPath(matrix, path, classificationStatus) {
     record.audit_status = "excluded";
     record.required_lenses = [];
     record.completed_lenses = [];
-    record.reviewed_line_ranges = [];
     record.unit_ids = [];
 }
 export function applyUnitCoverage(matrix, path, unitId, requiredLenses) {
@@ -65,21 +37,18 @@ export function applyReviewedRanges(matrix, reviewedRanges) {
         const record = matrix.files.find((file) => file.path === range.path);
         if (!record || record.audit_status === "excluded")
             continue;
-        record.reviewed_line_ranges.push(range);
-        record.reviewed_line_ranges = mergeRanges(record.reviewed_line_ranges);
         if (range.lens && !record.completed_lenses.includes(range.lens)) {
             record.completed_lenses.push(range.lens);
         }
     }
     for (const file of matrix.files) {
-        const hasAllRequired = file.required_lenses.every((lens) => file.completed_lenses.includes(lens));
-        if (file.audit_status === "excluded") {
+        if (file.audit_status === "excluded")
             continue;
-        }
+        const hasAllRequired = file.required_lenses.every((lens) => file.completed_lenses.includes(lens));
         if (hasAllRequired && file.required_lenses.length > 0) {
             file.audit_status = "complete";
         }
-        else if (file.reviewed_line_ranges.length > 0) {
+        else if (file.completed_lenses.length > 0) {
             file.audit_status = "partial";
         }
     }

package/dist/extractors/fileInventory.js

@@ -6,6 +6,8 @@ function inferLanguage(path) {
             return "typescript";
         case "js":
         case "jsx":
+        case "mjs":
+        case "cjs":
             return "javascript";
         case "py":
             return "python";

package/dist/io/artifacts.js

@@ -51,7 +51,8 @@ export async function loadArtifactBundle(root) {
     bundle.root_cause_clusters = await readOptionalJsonFile(`${root}/root_cause_clusters.json`);
     bundle.synthesis_report = await readOptionalJsonFile(`${root}/synthesis_report.json`);
     bundle.audit_state = await readOptionalJsonFile(`${root}/audit_state.json`);
-    bundle.artifact_metadata = await readOptionalJsonFile(`${root}/artifact_metadata.json`);
+    bundle.artifact_metadata =
+        await readOptionalJsonFile(`${root}/artifact_metadata.json`);
     return bundle;
 }
 export async function writeCoreArtifacts(root, bundle) {

package/dist/orchestrator/advance.js

@@ -27,58 +27,76 @@ export async function advanceAudit(bundle, options = {}) {
         };
     }
     let run;
-    switch (selectedExecutor) {
-        case "intake_executor":
-            if (!options.root)
-                throw new Error("advanceAudit intake_executor requires root");
-            run = await runIntakeExecutor(bundle, options.root);
-            break;
-        case "structure_executor":
-            run = runStructureExecutor(bundle);
-            break;
-        case "planning_executor":
-            run = runPlanningExecutor(bundle, options.lineIndex ?? {});
-            break;
-        case "result_ingestion_executor":
-            run = runResultIngestionExecutor(bundle, options.auditResults ?? bundle.audit_results ?? []);
-            break;
-        case "synthesis_executor":
-            run = runSynthesisExecutor(bundle, options.auditResults);
-            break;
-        case "runtime_validation_update_executor":
-            if (!options.runtimeValidationUpdates)
-                throw new Error("advanceAudit runtime_validation_update_executor requires runtimeValidationUpdates");
-            run = runRuntimeValidationUpdateExecutor(bundle, options.runtimeValidationUpdates);
-            break;
-        case "external_analyzer_import_executor":
-            if (!options.externalAnalyzerResults)
-                throw new Error("advanceAudit external_analyzer_import_executor requires externalAnalyzerResults");
-            run = runExternalAnalyzerImportExecutor(bundle, options.externalAnalyzerResults);
-            break;
-        case "auto_fix_executor":
-            if (!options.root)
-                throw new Error("advanceAudit auto_fix_executor requires root");
-            run = runAutoFixExecutor(bundle, options.root);
-            break;
-        case "syntax_resolution_executor":
-            if (!options.root)
-                throw new Error("advanceAudit syntax_resolution_executor requires root");
-            run = runSyntaxResolutionExecutor(bundle, options.root);
-            break;
-        default:
-            const state = deriveAuditState(bundle);
-            state.last_executor = selectedExecutor;
-            state.last_obligation = selectedObligation ?? undefined;
-            return {
-                audit_state: state,
-                selected_obligation: selectedObligation,
-                selected_executor: selectedExecutor,
-                progress_made: false,
-                artifacts_written: ["audit_state.json"],
-                progress_summary: `Executor ${selectedExecutor} is selected but not yet dispatched through advance-audit.`,
-                next_likely_step: selectedObligation,
-                updated_bundle: { ...bundle, audit_state: state },
-            };
+    try {
+        switch (selectedExecutor) {
+            case "intake_executor":
+                if (!options.root)
+                    throw new Error("advanceAudit intake_executor requires root");
+                run = await runIntakeExecutor(bundle, options.root);
+                break;
+            case "structure_executor":
+                run = runStructureExecutor(bundle);
+                break;
+            case "planning_executor":
+                run = runPlanningExecutor(bundle, options.lineIndex ?? {});
+                break;
+            case "result_ingestion_executor":
+                run = runResultIngestionExecutor(bundle, options.auditResults ?? bundle.audit_results ?? []);
+                break;
+            case "synthesis_executor":
+                run = runSynthesisExecutor(bundle, options.auditResults);
+                break;
+            case "runtime_validation_update_executor":
+                if (!options.runtimeValidationUpdates)
+                    throw new Error("advanceAudit runtime_validation_update_executor requires runtimeValidationUpdates");
+                run = runRuntimeValidationUpdateExecutor(bundle, options.runtimeValidationUpdates);
+                break;
+            case "external_analyzer_import_executor":
+                if (!options.externalAnalyzerResults)
+                    throw new Error("advanceAudit external_analyzer_import_executor requires externalAnalyzerResults");
+                run = runExternalAnalyzerImportExecutor(bundle, options.externalAnalyzerResults);
+                break;
+            case "auto_fix_executor":
+                if (!options.root)
+                    throw new Error("advanceAudit auto_fix_executor requires root");
+                run = runAutoFixExecutor(bundle, options.root);
+                break;
+            case "syntax_resolution_executor":
+                if (!options.root)
+                    throw new Error("advanceAudit syntax_resolution_executor requires root");
+                run = runSyntaxResolutionExecutor(bundle, options.root);
+                break;
+            default: {
+                const state = deriveAuditState(bundle);
+                state.last_executor = selectedExecutor;
+                state.last_obligation = selectedObligation ?? undefined;
+                return {
+                    audit_state: state,
+                    selected_obligation: selectedObligation,
+                    selected_executor: selectedExecutor,
+                    progress_made: false,
+                    artifacts_written: ["audit_state.json"],
+                    progress_summary: `Executor ${selectedExecutor} is selected but not yet dispatched through advance-audit.`,
+                    next_likely_step: selectedObligation,
+                    updated_bundle: { ...bundle, audit_state: state },
+                };
+            }
+        }
+    }
+    catch (err) {
+        const state = deriveAuditState(bundle);
+        state.last_executor = selectedExecutor;
+        state.last_obligation = selectedObligation ?? undefined;
+        return {
+            audit_state: state,
+            selected_obligation: selectedObligation,
+            selected_executor: selectedExecutor,
+            progress_made: false,
+            artifacts_written: [],
+            progress_summary: `Executor ${selectedExecutor} failed: ${err instanceof Error ? err.message : String(err)}`,
+            next_likely_step: selectedObligation,
+            updated_bundle: { ...bundle, audit_state: state },
+        };
     }
     const metadata = computeArtifactMetadata(run.updated, bundle.artifact_metadata);
     const metadataBundle = { ...run.updated, artifact_metadata: metadata };

package/dist/orchestrator/flowCoverage.js

@@ -10,11 +10,12 @@ function lensSetForFlow(concerns) {
     return concerns.filter((concern) => allowed.includes(concern));
 }
 export function buildFlowCoverage(criticalFlows, coverageMatrix) {
+    const fileIndex = new Map(coverageMatrix.files.map((file) => [file.path, file]));
     const flows = criticalFlows.flows.map((flow) => {
         const required = lensSetForFlow(flow.concerns);
         const completed = new Set();
         for (const path of flow.paths) {
-            const record = coverageMatrix.files.find((file) => file.path === path);
+            const record = fileIndex.get(path);
             if (!record || record.audit_status === "excluded") {
                 continue;
             }

package/dist/orchestrator/flowPlanning.d.ts

@@ -1,3 +1,3 @@
 import type { AuditTask } from "../types.js";
 import type { CriticalFlowManifest } from "../types/flows.js";
-export declare function buildFlowAwareTaskAugmentations(existingTasks: AuditTask[], criticalFlows: CriticalFlowManifest, lineIndex: Record<string, number>): AuditTask[];
+export declare function buildFlowAwareTaskAugmentations(existingTasks: AuditTask[], criticalFlows: CriticalFlowManifest, _lineIndex: Record<string, number>): AuditTask[];