auditor-lambda 0.1.0

package/dist/extractors/surfaces.js

@@ -0,0 +1,40 @@
+import { isAuditExcludedStatus } from "./disposition.js";
+function methodsForPath(path) {
+    const normalized = path.toLowerCase();
+    if (normalized.includes("api") || normalized.includes("route")) {
+        return ["GET", "POST"];
+    }
+    return undefined;
+}
+export function buildSurfaceManifest(repoManifest, disposition) {
+    const surfaces = [];
+    const dispositionMap = new Map(disposition?.files.map((item) => [item.path, item.status]) ?? []);
+    for (const file of repoManifest.files) {
+        const status = dispositionMap.get(file.path);
+        if (status && isAuditExcludedStatus(status)) {
+            continue;
+        }
+        const normalized = file.path.toLowerCase();
+        if (normalized.includes("api/") ||
+            normalized.includes("route") ||
+            normalized.includes("controller") ||
+            normalized.includes("worker") ||
+            normalized.includes("job") ||
+            normalized.includes("command") ||
+            normalized.includes("cli")) {
+            surfaces.push({
+                id: `surface:${file.path}`,
+                kind: normalized.includes("worker") || normalized.includes("job")
+                    ? "background"
+                    : "interface",
+                entrypoint: file.path,
+                exposure: normalized.includes("api") || normalized.includes("route")
+                    ? "network"
+                    : "local",
+                methods: methodsForPath(file.path),
+                notes: ["Heuristic surface detection."],
+            });
+        }
+    }
+    return { surfaces };
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+import "./cli.js";

package/dist/index.js

@@ -0,0 +1 @@
+import "./cli.js";

package/dist/io/artifacts.d.ts

@@ -0,0 +1,38 @@
+import type { AuditResult, AuditTask, CoverageMatrix, RepoManifest, UnitManifest } from "../types.js";
+import type { AuditState } from "../types/auditState.js";
+import type { ArtifactMetadataManifest } from "../types/artifactMetadata.js";
+import type { FileDisposition } from "../types/disposition.js";
+import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
+import type { FlowCoverageManifest } from "../types/flowCoverage.js";
+import type { CriticalFlowManifest } from "../types/flows.js";
+import type { GraphBundle } from "../types/graph.js";
+import type { RiskRegister } from "../types/risk.js";
+import type { RuntimeValidationReport, RuntimeValidationTaskManifest } from "../types/runtimeValidation.js";
+import type { SurfaceManifest } from "../types/surfaces.js";
+export interface ArtifactBundle {
+    repo_manifest?: RepoManifest;
+    file_disposition?: FileDisposition;
+    auto_fixes_applied?: unknown;
+    unit_manifest?: UnitManifest;
+    graph_bundle?: GraphBundle;
+    surface_manifest?: SurfaceManifest;
+    critical_flows?: CriticalFlowManifest;
+    flow_coverage?: FlowCoverageManifest;
+    risk_register?: RiskRegister;
+    coverage_matrix?: CoverageMatrix;
+    runtime_validation_tasks?: RuntimeValidationTaskManifest;
+    runtime_validation_report?: RuntimeValidationReport;
+    external_analyzer_results?: ExternalAnalyzerResults;
+    audit_results?: AuditResult[];
+    audit_tasks?: AuditTask[];
+    requeue_tasks?: AuditTask[];
+    merged_findings?: unknown;
+    root_cause_clusters?: unknown;
+    synthesis_report?: unknown;
+    audit_state?: AuditState;
+    artifact_metadata?: ArtifactMetadataManifest;
+}
+export declare const ARTIFACT_FILE_TO_BUNDLE_KEY: Record<string, keyof ArtifactBundle>;
+export declare function getArtifactValue(bundle: ArtifactBundle, artifactName: string): unknown;
+export declare function loadArtifactBundle(root: string): Promise<ArtifactBundle>;
+export declare function writeCoreArtifacts(root: string, bundle: ArtifactBundle): Promise<void>;

package/dist/io/artifacts.js

@@ -0,0 +1,100 @@
+import { writeJsonFile, readOptionalJsonFile, readOptionalNdjsonFile, writeNdjsonFile, } 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",
+    "merged_findings.json": "merged_findings",
+    "root_cause_clusters.json": "root_cause_clusters",
+    "synthesis_report.json": "synthesis_report",
+    "audit_state.json": "audit_state",
+    "artifact_metadata.json": "artifact_metadata",
+};
+export function getArtifactValue(bundle, 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.merged_findings = await readOptionalJsonFile(`${root}/merged_findings.json`);
+    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`);
+    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.merged_findings)
+        await writeJsonFile(`${root}/merged_findings.json`, bundle.merged_findings);
+    if (bundle.root_cause_clusters)
+        await writeJsonFile(`${root}/root_cause_clusters.json`, bundle.root_cause_clusters);
+    if (bundle.synthesis_report)
+        await writeJsonFile(`${root}/synthesis_report.json`, bundle.synthesis_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);
+}

package/dist/io/json.d.ts

@@ -0,0 +1,8 @@
+export declare function isFileMissingError(error: unknown): boolean;
+export declare function readJsonFile<T>(path: string): Promise<T>;
+export declare function writeJsonFile(path: string, value: unknown): Promise<void>;
+export declare function appendNdjsonFile(path: string, value: unknown): Promise<void>;
+export declare function readNdjsonFile<T>(path: string): Promise<T[]>;
+export declare function readOptionalJsonFile<T>(path: string): Promise<T | undefined>;
+export declare function readOptionalNdjsonFile<T>(path: string): Promise<T[] | undefined>;
+export declare function writeNdjsonFile(path: string, values: unknown[]): Promise<void>;

package/dist/io/json.js

@@ -0,0 +1,96 @@
+import { mkdir, readFile, writeFile, appendFile } from "node:fs/promises";
+import { dirname } from "node:path";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function isFileMissingError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+export async function readJsonFile(path) {
+    let content;
+    try {
+        content = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isFileMissingError(error)) {
+            throw error;
+        }
+        throw new Error(`Failed to read ${path}: ${errorMessage(error)}`);
+    }
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in ${path}: ${errorMessage(error)}`);
+    }
+}
+export async function writeJsonFile(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+export async function appendNdjsonFile(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(value) + "\n", "utf8");
+}
+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) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch (error) {
+                throw new Error(`Invalid NDJSON in ${path} at line ${index + 1}: ${errorMessage(error)}`);
+            }
+        });
+    }
+    catch (error) {
+        if (isFileMissingError(error)) {
+            throw error;
+        }
+        if (error instanceof Error && error.message.includes(path)) {
+            throw error;
+        }
+        throw new Error(`Failed to read ${path}: ${errorMessage(error)}`);
+    }
+}
+export async function readOptionalJsonFile(path) {
+    try {
+        return await readJsonFile(path);
+    }
+    catch (error) {
+        if (isFileMissingError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function readOptionalNdjsonFile(path) {
+    try {
+        return await readNdjsonFile(path);
+    }
+    catch (error) {
+        if (isFileMissingError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function writeNdjsonFile(path, values) {
+    await mkdir(dirname(path), { recursive: true });
+    if (values.length === 0) {
+        await writeFile(path, "", "utf8");
+        return;
+    }
+    await writeFile(path, values.map((v) => JSON.stringify(v)).join("\n") + "\n", "utf8");
+}

package/dist/io/runArtifacts.d.ts

@@ -0,0 +1,14 @@
+import type { WorkerTask } from "../types/workerSession.js";
+export interface RunPaths {
+    runDir: string;
+    taskPath: string;
+    promptPath: string;
+    resultPath: string;
+    stdoutPath: string;
+    stderrPath: string;
+    statusPath: string;
+}
+export declare function buildRunId(obligationId: string | null, index: number): 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): Promise<void>;

package/dist/io/runArtifacts.js

@@ -0,0 +1,37 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { writeJsonFile } from "./json.js";
+export function buildRunId(obligationId, index) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const obligation = obligationId ?? "terminal";
+    return `${timestamp}_${obligation}_${String(index).padStart(3, "0")}`;
+}
+export function getRunPaths(artifactsDir, runId) {
+    const runDir = join(artifactsDir, "runs", runId);
+    return {
+        runDir,
+        taskPath: join(runDir, "task.json"),
+        promptPath: join(runDir, "prompt.md"),
+        resultPath: join(runDir, "result.json"),
+        stdoutPath: join(runDir, "stdout.log"),
+        stderrPath: join(runDir, "stderr.log"),
+        statusPath: join(runDir, "status.json"),
+    };
+}
+export async function ensureSupervisorDirs(artifactsDir) {
+    await mkdir(join(artifactsDir, "dispatch"), { recursive: true });
+    await mkdir(join(artifactsDir, "worker-results"), { recursive: true });
+    await mkdir(join(artifactsDir, "worker-logs"), { recursive: true });
+    await mkdir(join(artifactsDir, "runs"), { recursive: true });
+}
+export async function writeWorkerTaskFiles(task, prompt, paths, artifactsDir) {
+    await mkdir(paths.runDir, { recursive: true });
+    await writeJsonFile(paths.taskPath, task);
+    await writeFile(paths.promptPath, prompt, "utf8");
+    await writeJsonFile(paths.statusPath, {
+        run_id: task.run_id,
+        status: "dispatched",
+    });
+    await writeJsonFile(join(artifactsDir, "dispatch", "current-task.json"), task);
+    await writeFile(join(artifactsDir, "dispatch", "current-prompt.md"), prompt, "utf8");
+}

package/dist/orchestrator/advance.d.ts

@@ -0,0 +1,24 @@
+import type { ArtifactBundle } from "../io/artifacts.js";
+import type { AuditState } from "../types/auditState.js";
+import type { AuditResult } from "../types.js";
+import type { RuntimeValidationReport } from "../types/runtimeValidation.js";
+import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
+export interface AdvanceAuditOptions {
+    root?: string;
+    lineIndex?: Record<string, number>;
+    auditResults?: AuditResult[];
+    runtimeValidationUpdates?: RuntimeValidationReport;
+    externalAnalyzerResults?: ExternalAnalyzerResults;
+    preferredExecutor?: string;
+}
+export interface AdvanceAuditResult {
+    audit_state: AuditState;
+    selected_obligation: string | null;
+    selected_executor: string | null;
+    progress_made: boolean;
+    artifacts_written: string[];
+    progress_summary: string;
+    next_likely_step: string | null;
+    updated_bundle: ArtifactBundle;
+}
+export declare function advanceAudit(bundle: ArtifactBundle, options?: AdvanceAuditOptions): Promise<AdvanceAuditResult>;

package/dist/orchestrator/advance.js

@@ -0,0 +1,104 @@
+import { decideNextStep } from "./nextStep.js";
+import { deriveAuditState } from "./state.js";
+import { computeArtifactMetadata } from "./artifactMetadata.js";
+import { runIntakeExecutor, runStructureExecutor, runPlanningExecutor, runResultIngestionExecutor, runRuntimeValidationUpdateExecutor, runSynthesisExecutor, runExternalAnalyzerImportExecutor, } from "./internalExecutors.js";
+import { runAutoFixExecutor } from "./autoFixExecutor.js";
+import { runSyntaxResolutionExecutor } from "./syntaxResolutionExecutor.js";
+export async function advanceAudit(bundle, options = {}) {
+    const decision = decideNextStep(bundle);
+    const forcedExecutor = options.preferredExecutor ?? null;
+    const selectedExecutor = forcedExecutor ?? decision.selected_executor;
+    const selectedObligation = forcedExecutor
+        ? `forced:${forcedExecutor}`
+        : decision.selected_obligation;
+    if (!selectedExecutor) {
+        const state = deriveAuditState(bundle);
+        state.last_executor = selectedExecutor ?? undefined;
+        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: decision.reason,
+            next_likely_step: null,
+            updated_bundle: { ...bundle, audit_state: state },
+        };
+    }
+    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 },
+            };
+    }
+    const metadata = computeArtifactMetadata(run.updated, bundle.artifact_metadata);
+    const metadataBundle = { ...run.updated, artifact_metadata: metadata };
+    const updatedState = deriveAuditState(metadataBundle);
+    updatedState.last_executor = selectedExecutor;
+    updatedState.last_obligation = selectedObligation ?? undefined;
+    const finalizedBundle = { ...metadataBundle, audit_state: updatedState };
+    const followupDecision = decideNextStep(finalizedBundle);
+    return {
+        audit_state: updatedState,
+        selected_obligation: selectedObligation,
+        selected_executor: selectedExecutor,
+        progress_made: true,
+        artifacts_written: [
+            ...run.artifacts_written,
+            "artifact_metadata.json",
+            "audit_state.json",
+        ],
+        progress_summary: run.progress_summary,
+        next_likely_step: followupDecision.selected_obligation,
+        updated_bundle: finalizedBundle,
+    };
+}

package/dist/orchestrator/artifactMetadata.d.ts

@@ -0,0 +1,4 @@
+import type { ArtifactMetadataManifest } from "../types/artifactMetadata.js";
+import type { ArtifactBundle } from "../io/artifacts.js";
+export declare function present(bundle: ArtifactBundle, artifactName: string): boolean;
+export declare function computeArtifactMetadata(bundle: ArtifactBundle, previous?: ArtifactMetadataManifest): ArtifactMetadataManifest;

package/dist/orchestrator/artifactMetadata.js

@@ -0,0 +1,111 @@
+import { createHash } from "node:crypto";
+import { ARTIFACT_DEPENDENCY_MAP } from "./dependencyMap.js";
+import { getArtifactValue } from "../io/artifacts.js";
+function stableStringify(value) {
+    if (value === undefined) {
+        return "null";
+    }
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item ?? null)).join(",")}]`;
+    }
+    const entries = Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+}
+function hashValue(value) {
+    return createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function normalizeForMetadataHash(artifactName, value) {
+    if (artifactName === "repo_manifest.json" &&
+        value &&
+        typeof value === "object" &&
+        !Array.isArray(value)) {
+        const record = value;
+        const { generated_at: _generatedAt, ...rest } = record;
+        return rest;
+    }
+    return value;
+}
+function buildReverseDependencyMap() {
+    const reverse = {};
+    for (const [upstream, downstreamList] of Object.entries(ARTIFACT_DEPENDENCY_MAP)) {
+        reverse[upstream] ??= [];
+        for (const downstream of downstreamList) {
+            reverse[downstream] ??= [];
+            reverse[downstream].push(upstream);
+        }
+    }
+    return reverse;
+}
+const REVERSE_DEPENDENCY_MAP = buildReverseDependencyMap();
+function computeDependencyFirstOrder(artifactNames) {
+    const target = new Set(artifactNames);
+    const ordered = [];
+    const temporary = new Set();
+    const permanent = new Set();
+    const visit = (artifactName) => {
+        if (permanent.has(artifactName))
+            return;
+        if (temporary.has(artifactName))
+            return;
+        temporary.add(artifactName);
+        const dependencies = (REVERSE_DEPENDENCY_MAP[artifactName] ?? [])
+            .filter((dependencyName) => target.has(dependencyName))
+            .sort();
+        for (const dependencyName of dependencies) {
+            visit(dependencyName);
+        }
+        temporary.delete(artifactName);
+        permanent.add(artifactName);
+        ordered.push(artifactName);
+    };
+    for (const artifactName of Array.from(target).sort()) {
+        visit(artifactName);
+    }
+    return ordered;
+}
+export function present(bundle, artifactName) {
+    const value = getArtifactValue(bundle, artifactName);
+    return value !== undefined && value !== null;
+}
+export function computeArtifactMetadata(bundle, previous) {
+    const artifacts = {};
+    const presentArtifacts = Object.keys(REVERSE_DEPENDENCY_MAP).filter((artifactName) => artifactName !== "artifact_metadata.json" &&
+        present(bundle, artifactName));
+    const orderedArtifacts = computeDependencyFirstOrder(presentArtifacts);
+    for (const artifactName of orderedArtifacts) {
+        if (artifactName === "artifact_metadata.json")
+            continue;
+        const value = getArtifactValue(bundle, artifactName);
+        if (value === undefined || value === null)
+            continue;
+        const contentHash = hashValue(normalizeForMetadataHash(artifactName, value));
+        const previousEntry = previous?.artifacts[artifactName];
+        const dependencyRevisions = Object.fromEntries((REVERSE_DEPENDENCY_MAP[artifactName] ?? [])
+            .filter((dependencyName) => dependencyName !== "artifact_metadata.json")
+            .sort()
+            .map((dependencyName) => [
+            dependencyName,
+            artifacts[dependencyName]?.revision ??
+                previous?.artifacts[dependencyName]?.revision ??
+                0,
+        ]));
+        const sameContent = previousEntry?.content_hash === contentHash;
+        const sameDependencies = previousEntry &&
+            stableStringify(previousEntry.dependency_revisions) ===
+                stableStringify(dependencyRevisions);
+        const revision = sameContent && sameDependencies
+            ? previousEntry.revision
+            : (previousEntry?.revision ?? 0) + 1;
+        artifacts[artifactName] = {
+            revision,
+            content_hash: contentHash,
+            dependency_revisions: dependencyRevisions,
+        };
+    }
+    return { artifacts };
+}

package/dist/orchestrator/autoFixExecutor.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactBundle } from "../io/artifacts.js";
+import type { ExecutorRunResult } from "./internalExecutors.js";
+export declare function runAutoFixExecutor(bundle: ArtifactBundle, root: string): ExecutorRunResult;

package/dist/orchestrator/autoFixExecutor.js

@@ -0,0 +1,63 @@
+import { execSync } from "node:child_process";
+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;
+    }
+}
+export function runAutoFixExecutor(bundle, root) {
+    if (!bundle.file_disposition) {
+        throw new Error("Cannot run auto fix executor without file_disposition");
+    }
+    const extensions = new Set();
+    for (const file of bundle.file_disposition.files) {
+        if (!isAuditExcludedStatus(file.status)) {
+            const match = file.path.match(/\.([^.]+)$/);
+            if (match) {
+                extensions.add(match[1].toLowerCase());
+            }
+        }
+    }
+    const executedTools = [];
+    // TS / JS
+    if (extensions.has("ts") ||
+        extensions.has("js") ||
+        extensions.has("tsx") ||
+        extensions.has("jsx")) {
+        if (tryRunConfiguredFormatter(root, "npx prettier --write ."))
+            executedTools.push("prettier");
+        if (tryRunConfiguredFormatter(root, "npx eslint --fix ."))
+            executedTools.push("eslint");
+    }
+    // Python
+    if (extensions.has("py")) {
+        if (tryRunConfiguredFormatter(root, "black .") ||
+            tryRunConfiguredFormatter(root, "python -m black .")) {
+            executedTools.push("black");
+        }
+        if (tryRunConfiguredFormatter(root, "autopep8 --in-place --recursive .")) {
+            executedTools.push("autopep8");
+        }
+    }
+    // Go
+    if (extensions.has("go")) {
+        if (tryRunConfiguredFormatter(root, "gofmt -w ."))
+            executedTools.push("gofmt");
+    }
+    const resultsArtifact = {
+        executed_tools: executedTools,
+        timestamp: new Date().toISOString(),
+    };
+    return {
+        updated: {
+            ...bundle,
+            auto_fixes_applied: resultsArtifact,
+        },
+        artifacts_written: ["auto_fixes_applied.json"],
+        progress_summary: `Phase 1 Deterministic Auto-Fix complete. Formatters executed: ${executedTools.length > 0 ? executedTools.join(", ") : "None"}.`,
+    };
+}

package/dist/orchestrator/chunking.d.ts

@@ -0,0 +1,5 @@
+export interface LineRange {
+    start: number;
+    end: number;
+}
+export declare function chunkLineCount(totalLines: number, chunkSize?: number): LineRange[];