auditor-lambda 0.2.8 → 0.2.10

package/dist/io/artifacts.js

@@ -1,129 +1,92 @@
 import { cp, rm, unlink } from "node:fs/promises";
 import { join } from "node:path";
-import { writeJsonFile, readOptionalJsonFile, readOptionalNdjsonFile, readOptionalTextFile, writeNdjsonFile, writeTextFile, } from "./json.js";
-export const ARTIFACT_FILE_TO_BUNDLE_KEY = {
-    "repo_manifest.json": "repo_manifest",
-    "file_disposition.json": "file_disposition",
-    "auto_fixes_applied.json": "auto_fixes_applied",
-    "unit_manifest.json": "unit_manifest",
-    "graph_bundle.json": "graph_bundle",
-    "surface_manifest.json": "surface_manifest",
-    "critical_flows.json": "critical_flows",
-    "flow_coverage.json": "flow_coverage",
-    "risk_register.json": "risk_register",
-    "coverage_matrix.json": "coverage_matrix",
-    "runtime_validation_tasks.json": "runtime_validation_tasks",
-    "runtime_validation_report.json": "runtime_validation_report",
-    "external_analyzer_results.json": "external_analyzer_results",
-    "audit_results.jsonl": "audit_results",
-    "audit_tasks.json": "audit_tasks",
-    "requeue_tasks.json": "requeue_tasks",
-    "audit-report.md": "audit_report",
-    "audit_state.json": "audit_state",
-    "artifact_metadata.json": "artifact_metadata",
+import { isFileMissingError, readOptionalJsonFile, readOptionalNdjsonFile, readOptionalTextFile, writeJsonFile, writeNdjsonFile, writeTextFile, } from "./json.js";
+function jsonArtifact(fileName, phase) {
+    return {
+        fileName,
+        phase,
+        read: (path) => readOptionalJsonFile(path),
+        write: (path, value) => writeJsonFile(path, value),
+    };
+}
+function ndjsonArtifact(fileName, phase) {
+    return {
+        fileName,
+        phase,
+        read: (path) => readOptionalNdjsonFile(path),
+        write: (path, value) => writeNdjsonFile(path, value),
+    };
+}
+function textArtifact(fileName, phase) {
+    return {
+        fileName,
+        phase,
+        read: (path) => readOptionalTextFile(path),
+        write: (path, value) => writeTextFile(path, value),
+    };
+}
+export const ARTIFACT_DEFINITIONS = {
+    repo_manifest: jsonArtifact("repo_manifest.json", "intake"),
+    file_disposition: jsonArtifact("file_disposition.json", "intake"),
+    auto_fixes_applied: jsonArtifact("auto_fixes_applied.json", "intake"),
+    unit_manifest: jsonArtifact("unit_manifest.json", "analysis"),
+    graph_bundle: jsonArtifact("graph_bundle.json", "analysis"),
+    surface_manifest: jsonArtifact("surface_manifest.json", "analysis"),
+    critical_flows: jsonArtifact("critical_flows.json", "analysis"),
+    flow_coverage: jsonArtifact("flow_coverage.json", "analysis"),
+    risk_register: jsonArtifact("risk_register.json", "analysis"),
+    coverage_matrix: jsonArtifact("coverage_matrix.json", "execution"),
+    runtime_validation_tasks: jsonArtifact("runtime_validation_tasks.json", "execution"),
+    runtime_validation_report: jsonArtifact("runtime_validation_report.json", "execution"),
+    external_analyzer_results: jsonArtifact("external_analyzer_results.json", "execution"),
+    audit_results: ndjsonArtifact("audit_results.jsonl", "execution"),
+    audit_tasks: jsonArtifact("audit_tasks.json", "execution"),
+    requeue_tasks: jsonArtifact("requeue_tasks.json", "execution"),
+    audit_report: textArtifact("audit-report.md", "reporting"),
+    audit_state: jsonArtifact("audit_state.json", "supervisor"),
+    artifact_metadata: jsonArtifact("artifact_metadata.json", "supervisor"),
 };
-const _bundleKeyCoverage = true;
+const ARTIFACT_ENTRIES = Object.entries(ARTIFACT_DEFINITIONS);
+export const ARTIFACT_FILE_TO_BUNDLE_KEY = Object.fromEntries(ARTIFACT_ENTRIES.map(([key, definition]) => [definition.fileName, key]));
 export function getArtifactValue(bundle, artifactName) {
-    const map = ARTIFACT_FILE_TO_BUNDLE_KEY;
-    const key = map[artifactName];
+    const key = ARTIFACT_FILE_TO_BUNDLE_KEY[artifactName];
     return key ? bundle[key] : undefined;
 }
 export async function loadArtifactBundle(root) {
     const bundle = {};
-    bundle.repo_manifest = await readOptionalJsonFile(`${root}/repo_manifest.json`);
-    bundle.file_disposition = await readOptionalJsonFile(`${root}/file_disposition.json`);
-    bundle.auto_fixes_applied = await readOptionalJsonFile(`${root}/auto_fixes_applied.json`);
-    bundle.unit_manifest = await readOptionalJsonFile(`${root}/unit_manifest.json`);
-    bundle.graph_bundle = await readOptionalJsonFile(`${root}/graph_bundle.json`);
-    bundle.surface_manifest = await readOptionalJsonFile(`${root}/surface_manifest.json`);
-    bundle.critical_flows = await readOptionalJsonFile(`${root}/critical_flows.json`);
-    bundle.flow_coverage = await readOptionalJsonFile(`${root}/flow_coverage.json`);
-    bundle.risk_register = await readOptionalJsonFile(`${root}/risk_register.json`);
-    bundle.coverage_matrix = await readOptionalJsonFile(`${root}/coverage_matrix.json`);
-    bundle.runtime_validation_tasks =
-        await readOptionalJsonFile(`${root}/runtime_validation_tasks.json`);
-    bundle.runtime_validation_report =
-        await readOptionalJsonFile(`${root}/runtime_validation_report.json`);
-    bundle.external_analyzer_results =
-        await readOptionalJsonFile(`${root}/external_analyzer_results.json`);
-    bundle.audit_results = await readOptionalNdjsonFile(`${root}/audit_results.jsonl`);
-    bundle.audit_tasks = await readOptionalJsonFile(`${root}/audit_tasks.json`);
-    bundle.requeue_tasks = await readOptionalJsonFile(`${root}/requeue_tasks.json`);
-    bundle.audit_report = await readOptionalTextFile(`${root}/audit-report.md`);
-    bundle.audit_state = await readOptionalJsonFile(`${root}/audit_state.json`);
-    bundle.artifact_metadata = await readOptionalJsonFile(`${root}/artifact_metadata.json`);
+    const bundleRecord = bundle;
+    for (const entry of ARTIFACT_ENTRIES) {
+        const [key, definition] = entry;
+        const value = await definition.read(join(root, definition.fileName));
+        if (value !== undefined) {
+            bundleRecord[key] = value;
+        }
+    }
     return bundle;
 }
 export async function writeCoreArtifacts(root, bundle) {
-    if (bundle.repo_manifest)
-        await writeJsonFile(`${root}/repo_manifest.json`, bundle.repo_manifest);
-    if (bundle.file_disposition)
-        await writeJsonFile(`${root}/file_disposition.json`, bundle.file_disposition);
-    if (bundle.auto_fixes_applied)
-        await writeJsonFile(`${root}/auto_fixes_applied.json`, bundle.auto_fixes_applied);
-    if (bundle.unit_manifest)
-        await writeJsonFile(`${root}/unit_manifest.json`, bundle.unit_manifest);
-    if (bundle.graph_bundle)
-        await writeJsonFile(`${root}/graph_bundle.json`, bundle.graph_bundle);
-    if (bundle.surface_manifest)
-        await writeJsonFile(`${root}/surface_manifest.json`, bundle.surface_manifest);
-    if (bundle.critical_flows)
-        await writeJsonFile(`${root}/critical_flows.json`, bundle.critical_flows);
-    if (bundle.flow_coverage)
-        await writeJsonFile(`${root}/flow_coverage.json`, bundle.flow_coverage);
-    if (bundle.risk_register)
-        await writeJsonFile(`${root}/risk_register.json`, bundle.risk_register);
-    if (bundle.coverage_matrix)
-        await writeJsonFile(`${root}/coverage_matrix.json`, bundle.coverage_matrix);
-    if (bundle.runtime_validation_tasks)
-        await writeJsonFile(`${root}/runtime_validation_tasks.json`, bundle.runtime_validation_tasks);
-    if (bundle.runtime_validation_report)
-        await writeJsonFile(`${root}/runtime_validation_report.json`, bundle.runtime_validation_report);
-    if (bundle.external_analyzer_results)
-        await writeJsonFile(`${root}/external_analyzer_results.json`, bundle.external_analyzer_results);
-    if (bundle.audit_results)
-        await writeNdjsonFile(`${root}/audit_results.jsonl`, bundle.audit_results);
-    if (bundle.audit_tasks)
-        await writeJsonFile(`${root}/audit_tasks.json`, bundle.audit_tasks);
-    if (bundle.requeue_tasks)
-        await writeJsonFile(`${root}/requeue_tasks.json`, bundle.requeue_tasks);
-    if (bundle.audit_report !== undefined)
-        await writeTextFile(`${root}/audit-report.md`, bundle.audit_report);
-    if (bundle.audit_state)
-        await writeJsonFile(`${root}/audit_state.json`, bundle.audit_state);
-    if (bundle.artifact_metadata)
-        await writeJsonFile(`${root}/artifact_metadata.json`, bundle.artifact_metadata);
+    const bundleRecord = bundle;
+    for (const entry of ARTIFACT_ENTRIES) {
+        const [key, definition] = entry;
+        const value = bundleRecord[key];
+        if (value !== undefined) {
+            await definition.write(join(root, definition.fileName), value);
+        }
+    }
 }
-const INTERMEDIATE_ARTIFACTS = [
-    "repo_manifest.json",
-    "file_disposition.json",
-    "auto_fixes_applied.json",
-    "unit_manifest.json",
-    "graph_bundle.json",
-    "surface_manifest.json",
-    "critical_flows.json",
-    "flow_coverage.json",
-    "risk_register.json",
-    "coverage_matrix.json",
-    "runtime_validation_tasks.json",
-    "runtime_validation_report.json",
-    "external_analyzer_results.json",
-    "audit_results.jsonl",
-    "audit_tasks.json",
-    "requeue_tasks.json",
-    "artifact_metadata.json",
-    "audit_state.json",
-    "audit-report.md",
-];
 export async function cleanupIntermediateArtifacts(root) {
     const deleted = [];
-    for (const name of INTERMEDIATE_ARTIFACTS) {
+    for (const [, definition] of ARTIFACT_ENTRIES) {
+        const path = join(root, definition.fileName);
         try {
-            await unlink(join(root, name));
-            deleted.push(name);
+            await unlink(path);
+            deleted.push(definition.fileName);
         }
-        catch {
-            // file absent — nothing to delete
+        catch (error) {
+            if (isFileMissingError(error)) {
+                continue;
+            }
+            throw error;
         }
     }
     return deleted;

package/dist/io/json.js

@@ -3,6 +3,17 @@ import { dirname } from "node:path";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function ioError(action, path, error) {
+    return new Error(`Failed to ${action} ${path}: ${errorMessage(error)}`);
+}
+async function ensureParentDirectory(path) {
+    try {
+        await mkdir(dirname(path), { recursive: true });
+    }
+    catch (error) {
+        throw ioError("prepare parent directory", path, error);
+    }
+}
 export function isFileMissingError(error) {
     return (typeof error === "object" &&
         error !== null &&
@@ -28,31 +39,41 @@ export async function readJsonFile(path) {
     }
 }
 export async function writeJsonFile(path, value) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, JSON.stringify(value, null, 2) + "\n", "utf8");
+    await ensureParentDirectory(path);
+    try {
+        await writeFile(path, JSON.stringify(value, null, 2) + "\n", "utf8");
+    }
+    catch (error) {
+        throw ioError("write", path, error);
+    }
 }
 export async function appendNdjsonFile(path, value) {
-    await mkdir(dirname(path), { recursive: true });
-    await appendFile(path, JSON.stringify(value) + "\n", "utf8");
+    await ensureParentDirectory(path);
+    try {
+        await appendFile(path, JSON.stringify(value) + "\n", "utf8");
+    }
+    catch (error) {
+        throw ioError("append", path, error);
+    }
 }
 export async function readNdjsonFile(path) {
     try {
         const content = await readFile(path, "utf8");
-        if (content.trim().length === 0) {
-            return [];
-        }
-        return content
-            .trim()
-            .split(/\r?\n/)
-            .filter(Boolean)
-            .map((line, index) => {
+        const values = [];
+        let sawContent = false;
+        for (const [index, line] of content.split(/\r?\n/).entries()) {
+            if (line.trim().length === 0) {
+                continue;
+            }
+            sawContent = true;
             try {
-                return JSON.parse(line);
+                values.push(JSON.parse(line));
             }
             catch (error) {
                 throw new Error(`Invalid NDJSON in ${path} at line ${index + 1}: ${errorMessage(error)}`);
             }
-        });
+        }
+        return sawContent ? values : [];
     }
     catch (error) {
         if (isFileMissingError(error)) {
@@ -87,12 +108,17 @@ export async function readOptionalNdjsonFile(path) {
     }
 }
 export async function writeNdjsonFile(path, values) {
-    await mkdir(dirname(path), { recursive: true });
-    if (values.length === 0) {
-        await writeFile(path, "", "utf8");
-        return;
+    await ensureParentDirectory(path);
+    try {
+        if (values.length === 0) {
+            await writeFile(path, "", "utf8");
+            return;
+        }
+        await writeFile(path, values.map((v) => JSON.stringify(v)).join("\n") + "\n", "utf8");
+    }
+    catch (error) {
+        throw ioError("write", path, error);
     }
-    await writeFile(path, values.map((v) => JSON.stringify(v)).join("\n") + "\n", "utf8");
 }
 export async function readOptionalTextFile(path) {
     try {
@@ -106,6 +132,11 @@ export async function readOptionalTextFile(path) {
     }
 }
 export async function writeTextFile(path, value) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, value, "utf8");
+    await ensureParentDirectory(path);
+    try {
+        await writeFile(path, value, "utf8");
+    }
+    catch (error) {
+        throw ioError("write", path, error);
+    }
 }

package/dist/io/runArtifacts.d.ts

@@ -9,7 +9,7 @@ export interface RunPaths {
     stderrPath: string;
     statusPath: string;
 }
-export declare function buildRunId(obligationId: string | null, index: number): string;
+export declare function buildRunId(obligationId: string | null, index: number, now?: Date): string;
 export declare function getRunPaths(artifactsDir: string, runId: string): RunPaths;
 export declare function ensureSupervisorDirs(artifactsDir: string): Promise<void>;
 export declare function writeWorkerTaskFiles(task: WorkerTask, prompt: string, paths: RunPaths, artifactsDir: string, currentTasks?: AuditTask[]): Promise<void>;

package/dist/io/runArtifacts.js

@@ -5,9 +5,32 @@ import { writeJsonFile } from "./json.js";
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(moduleDir, "..", "..");
 const auditResultSchemaPath = join(packageRoot, "schemas", "audit_result.schema.json");
-export function buildRunId(obligationId, index) {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const obligation = (obligationId ?? "terminal").replace(/[^a-zA-Z0-9_-]/g, "-");
+function pad(value, size = 2) {
+    return String(value).padStart(size, "0");
+}
+function formatRunTimestamp(value) {
+    return [
+        pad(value.getUTCFullYear(), 4),
+        pad(value.getUTCMonth() + 1),
+        pad(value.getUTCDate()),
+        "T",
+        pad(value.getUTCHours()),
+        pad(value.getUTCMinutes()),
+        pad(value.getUTCSeconds()),
+        pad(value.getUTCMilliseconds(), 3),
+        "Z",
+    ].join("");
+}
+function normalizeRunIdSegment(value) {
+    const normalized = (value ?? "terminal")
+        .trim()
+        .replace(/[^a-zA-Z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return normalized.length > 0 ? normalized : "terminal";
+}
+export function buildRunId(obligationId, index, now = new Date()) {
+    const timestamp = formatRunTimestamp(now);
+    const obligation = normalizeRunIdSegment(obligationId);
     return `${timestamp}_${obligation}_${String(index).padStart(3, "0")}`;
 }
 export function getRunPaths(artifactsDir, runId) {

package/dist/orchestrator/advance.js

@@ -4,6 +4,19 @@ import { computeArtifactMetadata } from "./artifactMetadata.js";
 import { runIntakeExecutor, runStructureExecutor, runPlanningExecutor, runResultIngestionExecutor, runRuntimeValidationExecutor, runRuntimeValidationUpdateExecutor, runSynthesisExecutor, runExternalAnalyzerImportExecutor, } from "./internalExecutors.js";
 import { runAutoFixExecutor } from "./autoFixExecutor.js";
 import { runSyntaxResolutionExecutor } from "./syntaxResolutionExecutor.js";
+function cloneState(state) {
+    return {
+        ...state,
+        blockers: [...(state.blockers ?? [])],
+        obligations: state.obligations.map((obligation) => ({ ...obligation })),
+    };
+}
+function formatExecutorFailure(selectedExecutor, selectedObligation, error) {
+    const detail = error instanceof Error ? error.message : String(error ?? "unknown error");
+    return new Error(`advanceAudit ${selectedExecutor} failed while resolving ${selectedObligation ?? "the current obligation"}: ${detail}`, {
+        cause: error instanceof Error ? error : undefined,
+    });
+}
 export async function advanceAudit(bundle, options = {}) {
     const decision = decideNextStep(bundle);
     const forcedExecutor = options.preferredExecutor ?? null;
@@ -12,9 +25,12 @@ export async function advanceAudit(bundle, options = {}) {
         ? `forced:${forcedExecutor}`
         : decision.selected_obligation;
     if (!selectedExecutor) {
-        const state = deriveAuditState(bundle);
-        // Do not overwrite last_executor when no executor was selected — preserve prior value
-        state.last_obligation = selectedObligation ?? undefined;
+        const state = cloneState(decision.state);
+        state.last_executor = bundle.audit_state?.last_executor ?? state.last_executor;
+        state.last_obligation =
+            selectedObligation ??
+                bundle.audit_state?.last_obligation ??
+                state.last_obligation;
         return {
             audit_state: state,
             selected_obligation: selectedObligation,
@@ -27,65 +43,70 @@ 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":
-            if (!options.root)
-                throw new Error("advanceAudit planning_executor requires root");
-            run = await runPlanningExecutor(bundle, options.root, options.lineIndex ?? {});
-            break;
-        case "result_ingestion_executor":
-            run = runResultIngestionExecutor(bundle, options.auditResults ?? bundle.audit_results ?? []);
-            break;
-        case "runtime_validation_executor":
-            if (!options.root)
-                throw new Error("advanceAudit runtime_validation_executor requires root");
-            run = await runRuntimeValidationExecutor(bundle, options.root);
-            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":
+                if (!options.root)
+                    throw new Error("advanceAudit planning_executor requires root");
+                run = await runPlanningExecutor(bundle, options.root, options.lineIndex ?? {});
+                break;
+            case "result_ingestion_executor":
+                run = runResultIngestionExecutor(bundle, options.auditResults ?? bundle.audit_results ?? []);
+                break;
+            case "runtime_validation_executor":
+                if (!options.root)
+                    throw new Error("advanceAudit runtime_validation_executor requires root");
+                run = await runRuntimeValidationExecutor(bundle, options.root);
+                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 (error) {
+        throw formatExecutorFailure(selectedExecutor, selectedObligation, error);
     }
     const metadata = computeArtifactMetadata(run.updated, bundle.artifact_metadata);
     const metadataBundle = { ...run.updated, artifact_metadata: metadata };

package/dist/orchestrator/autoFixExecutor.js

@@ -1,13 +1,9 @@
-import { execSync } from "node:child_process";
+import { join } from "node:path";
 import { isAuditExcludedStatus } from "../extractors/disposition.js";
-function tryRunConfiguredFormatter(root, command) {
-    try {
-        execSync(command, { cwd: root, stdio: "ignore", windowsHide: true });
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
+import { resolveNodeTool, runFirstAvailableCommand, } from "./localCommands.js";
+function tryRunConfiguredFormatter(root, candidates) {
+    const result = runFirstAvailableCommand(root, candidates);
+    return result !== null && !result.error && result.exitCode === 0;
 }
 export function runAutoFixExecutor(bundle, root) {
     if (!bundle.file_disposition) {
@@ -28,24 +24,45 @@ export function runAutoFixExecutor(bundle, root) {
         extensions.has("js") ||
         extensions.has("tsx") ||
         extensions.has("jsx")) {
-        if (tryRunConfiguredFormatter(root, "npx prettier --write ."))
+        if (tryRunConfiguredFormatter(root, [
+            ...resolveNodeTool(root, join("node_modules", "prettier", "bin", "prettier.cjs"), ["--write", "."], "prettier --write ."),
+            { command: "prettier", args: ["--write", "."], display: "prettier --write ." },
+        ]))
             executedTools.push("prettier");
-        if (tryRunConfiguredFormatter(root, "npx eslint --fix ."))
+        if (tryRunConfiguredFormatter(root, [
+            ...resolveNodeTool(root, join("node_modules", "eslint", "bin", "eslint.js"), ["--fix", "."], "eslint --fix ."),
+            { command: "eslint", args: ["--fix", "."], display: "eslint --fix ." },
+        ]))
             executedTools.push("eslint");
     }
     // Python
     if (extensions.has("py")) {
-        if (tryRunConfiguredFormatter(root, "black .") ||
-            tryRunConfiguredFormatter(root, "python -m black .")) {
+        if (tryRunConfiguredFormatter(root, [
+            { command: "black", args: ["."], display: "black ." },
+            { command: "python", args: ["-m", "black", "."], display: "python -m black ." },
+        ])) {
             executedTools.push("black");
         }
-        if (tryRunConfiguredFormatter(root, "autopep8 --in-place --recursive .")) {
+        if (tryRunConfiguredFormatter(root, [
+            {
+                command: "autopep8",
+                args: ["--in-place", "--recursive", "."],
+                display: "autopep8 --in-place --recursive .",
+            },
+            {
+                command: "python",
+                args: ["-m", "autopep8", "--in-place", "--recursive", "."],
+                display: "python -m autopep8 --in-place --recursive .",
+            },
+        ])) {
             executedTools.push("autopep8");
         }
     }
     // Go
     if (extensions.has("go")) {
-        if (tryRunConfiguredFormatter(root, "gofmt -w ."))
+        if (tryRunConfiguredFormatter(root, [
+            { command: "gofmt", args: ["-w", "."], display: "gofmt -w ." },
+        ]))
             executedTools.push("gofmt");
     }
     const resultsArtifact = {

package/dist/orchestrator/flowCoverage.js

@@ -10,11 +10,17 @@ function lensSetForFlow(concerns) {
     return concerns.filter((concern) => allowed.includes(concern));
 }
 export function buildFlowCoverage(criticalFlows, coverageMatrix) {
+    const coverageByPath = new Map(coverageMatrix.files.map((file) => [file.path, file]));
     const flows = criticalFlows.flows.map((flow) => {
-        const required = lensSetForFlow(flow.concerns);
+        const flowPaths = Array.isArray(flow.paths)
+            ? flow.paths.filter((path) => typeof path === "string")
+            : [];
+        const required = lensSetForFlow(Array.isArray(flow.concerns)
+            ? flow.concerns.filter((concern) => typeof concern === "string")
+            : []);
         const completed = new Set();
-        for (const path of flow.paths) {
-            const record = coverageMatrix.files.find((file) => file.path === path);
+        for (const path of flowPaths) {
+            const record = coverageByPath.get(path);
             if (!record || record.audit_status === "excluded") {
                 continue;
             }
@@ -33,11 +39,11 @@ export function buildFlowCoverage(criticalFlows, coverageMatrix) {
                 : "pending";
         return {
             flow_id: flow.id,
-            paths: flow.paths,
+            paths: flowPaths,
             required_lenses: required,
             completed_lenses,
             status,
-            notes: [`Derived from ${flow.paths.length} path(s).`],
+            notes: [`Derived from ${flowPaths.length} path(s).`],
         };
     });
     return { flows };

package/dist/orchestrator/flowPlanning.d.ts

@@ -1,3 +1,8 @@
-import type { AuditTask } from "../types.js";
+import type { Lens } from "../types.js";
 import type { CriticalFlowManifest } from "../types/flows.js";
-export declare function buildFlowAwareTaskAugmentations(existingTasks: AuditTask[], criticalFlows: CriticalFlowManifest, _lineIndex: Record<string, number>): AuditTask[];
+export interface FlowReviewBlock {
+    flow_id: string;
+    lens: Lens;
+    file_paths: string[];
+}
+export declare function claimFlowReviewBlocks(criticalFlows: CriticalFlowManifest, pendingByLens: Map<Lens, Set<string>>, assigned: Set<string>): FlowReviewBlock[];