auditor-lambda 0.2.6 → 0.2.9

package/dist/io/artifacts.d.ts

@@ -9,53 +9,68 @@ 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;
+type ArtifactPayloadMap = {
+    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[];
+    audit_report: string;
+    audit_state: AuditState;
+    artifact_metadata: ArtifactMetadataManifest;
+};
+/**
+ * Audit artifacts accumulate phase-by-phase as the orchestrator advances.
+ * Missing keys mean the corresponding artifact has not been produced yet.
+ */
+export type ArtifactBundle = Partial<ArtifactPayloadMap>;
+export type ArtifactBundleKey = keyof ArtifactPayloadMap;
+type ArtifactPhase = "intake" | "analysis" | "execution" | "reporting" | "supervisor";
+interface ArtifactDefinition<K extends ArtifactBundleKey = ArtifactBundleKey> {
+    fileName: string;
+    phase: ArtifactPhase;
+    read: (path: string) => Promise<ArtifactPayloadMap[K] | undefined>;
+    write: (path: string, value: ArtifactPayloadMap[K]) => Promise<void>;
 }
-export declare const ARTIFACT_FILE_TO_BUNDLE_KEY: {
-    readonly "repo_manifest.json": "repo_manifest";
-    readonly "file_disposition.json": "file_disposition";
-    readonly "auto_fixes_applied.json": "auto_fixes_applied";
-    readonly "unit_manifest.json": "unit_manifest";
-    readonly "graph_bundle.json": "graph_bundle";
-    readonly "surface_manifest.json": "surface_manifest";
-    readonly "critical_flows.json": "critical_flows";
-    readonly "flow_coverage.json": "flow_coverage";
-    readonly "risk_register.json": "risk_register";
-    readonly "coverage_matrix.json": "coverage_matrix";
-    readonly "runtime_validation_tasks.json": "runtime_validation_tasks";
-    readonly "runtime_validation_report.json": "runtime_validation_report";
-    readonly "external_analyzer_results.json": "external_analyzer_results";
-    readonly "audit_results.jsonl": "audit_results";
-    readonly "audit_tasks.json": "audit_tasks";
-    readonly "requeue_tasks.json": "requeue_tasks";
-    readonly "merged_findings.json": "merged_findings";
-    readonly "root_cause_clusters.json": "root_cause_clusters";
-    readonly "synthesis_report.json": "synthesis_report";
-    readonly "audit_state.json": "audit_state";
-    readonly "artifact_metadata.json": "artifact_metadata";
+export declare const ARTIFACT_DEFINITIONS: {
+    readonly repo_manifest: ArtifactDefinition<"repo_manifest">;
+    readonly file_disposition: ArtifactDefinition<"file_disposition">;
+    readonly auto_fixes_applied: ArtifactDefinition<"auto_fixes_applied">;
+    readonly unit_manifest: ArtifactDefinition<"unit_manifest">;
+    readonly graph_bundle: ArtifactDefinition<"graph_bundle">;
+    readonly surface_manifest: ArtifactDefinition<"surface_manifest">;
+    readonly critical_flows: ArtifactDefinition<"critical_flows">;
+    readonly flow_coverage: ArtifactDefinition<"flow_coverage">;
+    readonly risk_register: ArtifactDefinition<"risk_register">;
+    readonly coverage_matrix: ArtifactDefinition<"coverage_matrix">;
+    readonly runtime_validation_tasks: ArtifactDefinition<"runtime_validation_tasks">;
+    readonly runtime_validation_report: ArtifactDefinition<"runtime_validation_report">;
+    readonly external_analyzer_results: ArtifactDefinition<"external_analyzer_results">;
+    readonly audit_results: ArtifactDefinition<"audit_results">;
+    readonly audit_tasks: ArtifactDefinition<"audit_tasks">;
+    readonly requeue_tasks: ArtifactDefinition<"requeue_tasks">;
+    readonly audit_report: ArtifactDefinition<"audit_report">;
+    readonly audit_state: ArtifactDefinition<"audit_state">;
+    readonly artifact_metadata: ArtifactDefinition<"artifact_metadata">;
 };
+export declare const ARTIFACT_FILE_TO_BUNDLE_KEY: Record<string, ArtifactBundleKey>;
 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>;
 export declare function cleanupIntermediateArtifacts(root: string): Promise<string[]>;
+export declare function promoteFinalAuditReport(params: {
+    artifactsDir: string;
+    repoRoot: string;
+}): Promise<void>;
+export {};

package/dist/io/artifacts.js

@@ -1,139 +1,99 @@
-import { unlink } from "node:fs/promises";
+import { cp, rm, unlink } from "node:fs/promises";
 import { join } from "node:path";
-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",
+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.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`);
+    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.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);
+    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);
+        }
+    }
 }
-// Intermediate files deleted after synthesis completes. The final outputs
-// (synthesis_report.json, merged_findings.json, root_cause_clusters.json,
-// audit_state.json) are retained.
-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",
-];
 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;
 }
+export async function promoteFinalAuditReport(params) {
+    const source = join(params.artifactsDir, "audit-report.md");
+    const destination = join(params.repoRoot, "audit-report.md");
+    await cp(source, destination, { force: true });
+    await rm(params.artifactsDir, { recursive: true, force: true });
+}

package/dist/io/json.d.ts

@@ -6,3 +6,5 @@ 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>;
+export declare function readOptionalTextFile(path: string): Promise<string | undefined>;
+export declare function writeTextFile(path: string, value: string): Promise<void>;

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,10 +108,35 @@ 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);
+    }
+}
+export async function readOptionalTextFile(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isFileMissingError(error)) {
+            return undefined;
+        }
+        throw new Error(`Failed to read ${path}: ${errorMessage(error)}`);
+    }
+}
+export async function writeTextFile(path, value) {
+    await ensureParentDirectory(path);
+    try {
+        await writeFile(path, value, "utf8");
+    }
+    catch (error) {
+        throw ioError("write", path, error);
     }
-    await writeFile(path, values.map((v) => JSON.stringify(v)).join("\n") + "\n", "utf8");
 }

package/dist/io/runArtifacts.d.ts

@@ -9,7 +9,8 @@ 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>;
+export declare function clearDispatchFiles(artifactsDir: string): Promise<void>;

package/dist/io/runArtifacts.js

@@ -1,9 +1,36 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { writeJsonFile } from "./json.js";
-export function buildRunId(obligationId, index) {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const obligation = (obligationId ?? "terminal").replace(/[^a-zA-Z0-9_-]/g, "-");
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(moduleDir, "..", "..");
+const auditResultSchemaPath = join(packageRoot, "schemas", "audit_result.schema.json");
+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) {
@@ -20,8 +47,6 @@ export function getRunPaths(artifactsDir, runId) {
 }
 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, currentTasks) {
@@ -35,4 +60,16 @@ export async function writeWorkerTaskFiles(task, prompt, paths, artifactsDir, cu
     await writeJsonFile(join(artifactsDir, "dispatch", "current-task.json"), task);
     await writeFile(join(artifactsDir, "dispatch", "current-prompt.md"), prompt, "utf8");
     await writeJsonFile(join(artifactsDir, "dispatch", "current-tasks.json"), currentTasks ?? []);
+    await writeFile(join(artifactsDir, "dispatch", "audit-result.schema.json"), await readFile(auditResultSchemaPath, "utf8"), "utf8");
+}
+export async function clearDispatchFiles(artifactsDir) {
+    const targets = [
+        "current-task.json",
+        "current-prompt.md",
+        "current-tasks.json",
+        "audit-result.schema.json",
+    ];
+    for (const name of targets) {
+        await rm(join(artifactsDir, "dispatch", name), { force: true });
+    }
 }

package/dist/mcp/server.d.ts

@@ -0,0 +1 @@
+export declare function runAuditCodeMcpServer(argv: string[]): Promise<void>;