audit-tools 0.28.0

package/dist/audit/contracts/workerSchemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerSchemas.d.ts","sourceRoot":"","sources":["../../../src/audit/contracts/workerSchemas.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,kFAAkF;AAClF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;EAG7B,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQrB,CAAC;AAEZ,wFAAwF;AACxF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBvB,CAAC;AAMZ;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAazB,CAAC;AAEZ,qEAAqE;AACrE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAA0C,CAAC;AAEhF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CACxC,MAAM,EACN;IAAE,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAaxC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkBhF"}

package/dist/audit/contracts/workerSchemas.js

@@ -0,0 +1,117 @@
+// A6 — worker-facing contract schemas, derived from the canonical zod sources.
+//
+// The worker-facing JSON schemas shipped to dispatch workers (finding.schema.json,
+// lens.schema.json, audit_task.schema.json, audit_result.schema.json,
+// audit_results.schema.json) are STRICTER projections of the base contract zod
+// schemas: a worker MUST provide evidence, cite at least one affected file, use a
+// canonical lens, and emit no extra keys. Those constraints live here as explicit
+// refinements of the single-source base schemas (`audit-tools/shared` for the
+// finding/lens vocabulary, `../types.js` for audit task/result), so the JSON
+// schemas can be GENERATED from them and never drift from the TypeScript types.
+//
+// `renderWorkerJsonSchema` emits the committed JSON; the drift-guard test
+// (tests/worker-schema-generation.test.mjs) regenerates and compares.
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { FindingSchema, FindingLocationSchema, FindingGroundingSchema, LensSchema, } from "audit-tools/shared";
+import { AuditTaskSchema, AuditResultSchema, AuditVerificationSchema, } from "../types.js";
+/** A cited span as a worker must emit it: bounded line numbers, no extra keys. */
+export const WorkerFindingLocationSchema = FindingLocationSchema.extend({
+    line_start: z.number().int().min(1).optional(),
+    line_end: z.number().int().min(1).optional(),
+}).strict();
+/**
+ * A finding as a dispatch worker must emit it. Stricter than the pipeline
+ * {@link FindingSchema}: a canonical lens, a non-empty category, at least one
+ * affected file, non-empty evidence, and no unknown keys.
+ */
+export const WorkerFindingSchema = FindingSchema.extend({
+    category: z.string().min(1),
+    lens: LensSchema,
+    affected_files: z.array(WorkerFindingLocationSchema).min(1),
+    evidence: z.array(z.string()).min(1),
+    reproduction: z.array(z.string()).min(1).optional(),
+    related_findings: z.array(z.string()).min(1).optional(),
+    grounding: FindingGroundingSchema.strict().optional(),
+}).strict();
+/** An audit task as it appears in worker contracts (canonical lens, bounded ranges). */
+export const WorkerAuditTaskSchema = AuditTaskSchema.extend({
+    lens: LensSchema,
+    file_paths: z.array(z.string()).min(1),
+    file_line_counts: z.record(z.string(), z.number().int().min(0)).optional(),
+    line_ranges: z
+        .array(z
+        .object({
+        path: z.string(),
+        start: z.number().int().min(1),
+        end: z.number().int().min(1),
+    })
+        .strict())
+        .optional(),
+    token_estimate: z.number().min(0).optional(),
+    risk_estimate: z.number().min(0).max(1).optional(),
+    tags: z.array(z.string()).min(1).optional(),
+}).strict();
+const WorkerAuditVerificationSchema = AuditVerificationSchema.extend({
+    followup_tasks: z.array(WorkerAuditTaskSchema).optional(),
+}).strict();
+/**
+ * One AuditResult as a worker must emit it. Note `followup_tasks` is a string[]
+ * of task ids at the top level (the prior hand-written schema wrongly typed it as
+ * AuditTask[] — corrected here by single-sourcing from the TS type).
+ */
+export const WorkerAuditResultSchema = AuditResultSchema.extend({
+    lens: LensSchema,
+    file_coverage: z
+        .array(z
+        .object({ path: z.string(), total_lines: z.number().int().min(0) })
+        .strict())
+        .min(1),
+    findings: z.array(WorkerFindingSchema),
+    followup_tasks: z.array(z.string()).optional(),
+    verification: WorkerAuditVerificationSchema.optional(),
+    submitted_at: z.string().datetime().optional(),
+}).strict();
+/** The full worker submission: a non-empty array of AuditResults. */
+export const WorkerAuditResultsSchema = z.array(WorkerAuditResultSchema).min(1);
+/**
+ * Registry of the worker-facing JSON schema files and the zod source each is
+ * generated from. The keys are the committed filenames under `schemas/`.
+ */
+export const WORKER_SCHEMA_SOURCES = {
+    "lens.schema.json": { schema: LensSchema, title: "Lens" },
+    "finding.schema.json": { schema: WorkerFindingSchema, title: "Audit Finding" },
+    "audit_task.schema.json": { schema: WorkerAuditTaskSchema, title: "Audit Task" },
+    "audit_result.schema.json": {
+        schema: WorkerAuditResultSchema,
+        title: "Audit Result",
+    },
+    "audit_results.schema.json": {
+        schema: WorkerAuditResultsSchema,
+        title: "Audit Results",
+    },
+};
+/**
+ * Render the committed JSON-schema document for a worker-facing schema file.
+ * Self-contained (refs inlined) so a worker can validate against the single file.
+ */
+export function renderWorkerJsonSchema(filename) {
+    const entry = WORKER_SCHEMA_SOURCES[filename];
+    if (!entry) {
+        throw new Error(`No worker schema source registered for "${filename}"`);
+    }
+    const generated = zodToJsonSchema(entry.schema, {
+        $refStrategy: "none",
+        target: "jsonSchema7",
+    });
+    // zod-to-json-schema emits a top-level `$schema`; normalize the document head
+    // to the stable identity fields the prior hand-authored schemas carried.
+    delete generated.$schema;
+    return {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        $id: filename,
+        title: entry.title,
+        ...generated,
+    };
+}
+//# sourceMappingURL=workerSchemas.js.map

package/dist/audit/contracts/workerSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerSchemas.js","sourceRoot":"","sources":["../../../src/audit/contracts/workerSchemas.ts"],"names":[],"mappings":"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"}

package/dist/audit/contracts/wrapperResponse.d.ts

@@ -0,0 +1,316 @@
+import { z } from "zod";
+export declare const AuditCodeResponseSchema: z.ZodObject<{
+    contract_version: z.ZodLiteral<"audit-code/v1alpha1">;
+    audit_state: z.ZodObject<{
+        status: z.ZodEnum<["not_started", "active", "blocked", "complete"]>;
+        last_executor: z.ZodOptional<z.ZodString>;
+        last_obligation: z.ZodOptional<z.ZodString>;
+        blockers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        obligations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            state: z.ZodEnum<["missing", "present", "stale", "blocked", "satisfied"]>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            state: "blocked" | "satisfied" | "missing" | "present" | "stale";
+            reason?: string | undefined;
+        }, {
+            id: string;
+            state: "blocked" | "satisfied" | "missing" | "present" | "stale";
+            reason?: string | undefined;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        status: "blocked" | "complete" | "not_started" | "active";
+        obligations: {
+            id: string;
+            state: "blocked" | "satisfied" | "missing" | "present" | "stale";
+            reason?: string | undefined;
+        }[];
+        last_obligation?: string | undefined;
+        last_executor?: string | undefined;
+        blockers?: string[] | undefined;
+    }, {
+        status: "blocked" | "complete" | "not_started" | "active";
+        obligations: {
+            id: string;
+            state: "blocked" | "satisfied" | "missing" | "present" | "stale";
+            reason?: string | undefined;
+        }[];
+        last_obligation?: string | undefined;
+        last_executor?: string | undefined;
+        blockers?: string[] | undefined;
+    }>;
+    selected_obligation: z.ZodNullable<z.ZodString>;
+    selected_executor: z.ZodNullable<z.ZodString>;
+    progress_made: z.ZodBoolean;
+    artifacts_written: z.ZodArray<z.ZodString, "many">;
+    progress_summary: z.ZodString;
+    next_likely_step: z.ZodNullable<z.ZodString>;
+    handoff: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<["not_started", "active", "blocked", "complete"]>;
+        repo_root: z.ZodString;
+        artifacts_dir: z.ZodString;
+        provider: z.ZodNullable<z.ZodString>;
+        summary: z.ZodString;
+        pending_obligations: z.ZodArray<z.ZodString, "many">;
+        suggested_inputs: z.ZodArray<z.ZodObject<{
+            flag: z.ZodEnum<["--results", "--batch-results", "--updates", "--external-analyzer-results"]>;
+            suggested_path: z.ZodString;
+            description: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            description: string;
+            flag: "--batch-results" | "--results" | "--updates" | "--external-analyzer-results";
+            suggested_path: string;
+        }, {
+            description: string;
+            flag: "--batch-results" | "--results" | "--updates" | "--external-analyzer-results";
+            suggested_path: string;
+        }>, "many">;
+        suggested_commands: z.ZodArray<z.ZodString, "many">;
+        interactive_provider_hint: z.ZodNullable<z.ZodString>;
+        active_review_run: z.ZodOptional<z.ZodObject<{
+            run_id: z.ZodString;
+            task_path: z.ZodString;
+            prompt_path: z.ZodString;
+            pending_audit_tasks_path: z.ZodOptional<z.ZodString>;
+            audit_results_path: z.ZodString;
+            worker_command: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            worker_command: string[];
+            run_id: string;
+            audit_results_path: string;
+            task_path: string;
+            prompt_path: string;
+            pending_audit_tasks_path?: string | undefined;
+        }, {
+            worker_command: string[];
+            run_id: string;
+            audit_results_path: string;
+            task_path: string;
+            prompt_path: string;
+            pending_audit_tasks_path?: string | undefined;
+        }>>;
+        artifact_paths: z.ZodObject<{
+            incoming_dir: z.ZodString;
+            operator_handoff_json: z.ZodString;
+            operator_handoff_markdown: z.ZodString;
+            session_config: z.ZodString;
+            run_ledger: z.ZodString;
+            current_task: z.ZodNullable<z.ZodString>;
+            current_prompt: z.ZodNullable<z.ZodString>;
+            current_tasks: z.ZodNullable<z.ZodString>;
+            audit_tasks: z.ZodNullable<z.ZodString>;
+            runtime_validation_tasks: z.ZodNullable<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            current_prompt: string | null;
+            session_config: string;
+            runtime_validation_tasks: string | null;
+            audit_tasks: string | null;
+            incoming_dir: string;
+            operator_handoff_json: string;
+            operator_handoff_markdown: string;
+            run_ledger: string;
+            current_task: string | null;
+            current_tasks: string | null;
+        }, {
+            current_prompt: string | null;
+            session_config: string;
+            runtime_validation_tasks: string | null;
+            audit_tasks: string | null;
+            incoming_dir: string;
+            operator_handoff_json: string;
+            operator_handoff_markdown: string;
+            run_ledger: string;
+            current_task: string | null;
+            current_tasks: string | null;
+        }>;
+        quick_start: z.ZodOptional<z.ZodString>;
+        file_map: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strict", z.ZodTypeAny, {
+        status: "blocked" | "complete" | "not_started" | "active";
+        summary: string;
+        provider: string | null;
+        repo_root: string;
+        artifacts_dir: string;
+        artifact_paths: {
+            current_prompt: string | null;
+            session_config: string;
+            runtime_validation_tasks: string | null;
+            audit_tasks: string | null;
+            incoming_dir: string;
+            operator_handoff_json: string;
+            operator_handoff_markdown: string;
+            run_ledger: string;
+            current_task: string | null;
+            current_tasks: string | null;
+        };
+        pending_obligations: string[];
+        suggested_inputs: {
+            description: string;
+            flag: "--batch-results" | "--results" | "--updates" | "--external-analyzer-results";
+            suggested_path: string;
+        }[];
+        suggested_commands: string[];
+        interactive_provider_hint: string | null;
+        active_review_run?: {
+            worker_command: string[];
+            run_id: string;
+            audit_results_path: string;
+            task_path: string;
+            prompt_path: string;
+            pending_audit_tasks_path?: string | undefined;
+        } | undefined;
+        quick_start?: string | undefined;
+        file_map?: Record<string, string> | undefined;
+    }, {
+        status: "blocked" | "complete" | "not_started" | "active";
+        summary: string;
+        provider: string | null;
+        repo_root: string;
+        artifacts_dir: string;
+        artifact_paths: {
+            current_prompt: string | null;
+            session_config: string;
+            runtime_validation_tasks: string | null;
+            audit_tasks: string | null;
+            incoming_dir: string;
+            operator_handoff_json: string;
+            operator_handoff_markdown: string;
+            run_ledger: string;
+            current_task: string | null;
+            current_tasks: string | null;
+        };
+        pending_obligations: string[];
+        suggested_inputs: {
+            description: string;
+            flag: "--batch-results" | "--results" | "--updates" | "--external-analyzer-results";
+            suggested_path: string;
+        }[];
+        suggested_commands: string[];
+        interactive_provider_hint: string | null;
+        active_review_run?: {
+            worker_command: string[];
+            run_id: string;
+            audit_results_path: string;
+            task_path: string;
+            prompt_path: string;
+            pending_audit_tasks_path?: string | undefined;
+        } | undefined;
+        quick_start?: string | undefined;
+        file_map?: Record<string, string> | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    contract_version: "audit-code/v1alpha1";
+    audit_state: {
+        status: "blocked" | "complete" | "not_started" | "active";
+        obligations: {
+            id: string;
+            state: "blocked" | "satisfied" | "missing" | "present" | "stale";
+            reason?: string | undefined;
+        }[];
+        last_obligation?: string | undefined;
+        last_executor?: string | undefined;
+        blockers?: string[] | undefined;
+    };
+    artifacts_written: string[];
+    progress_summary: string;
+    selected_obligation: string | null;
+    selected_executor: string | null;
+    progress_made: boolean;
+    next_likely_step: string | null;
+    handoff?: {
+        status: "blocked" | "complete" | "not_started" | "active";
+        summary: string;
+        provider: string | null;
+        repo_root: string;
+        artifacts_dir: string;
+        artifact_paths: {
+            current_prompt: string | null;
+            session_config: string;
+            runtime_validation_tasks: string | null;
+            audit_tasks: string | null;
+            incoming_dir: string;
+            operator_handoff_json: string;
+            operator_handoff_markdown: string;
+            run_ledger: string;
+            current_task: string | null;
+            current_tasks: string | null;
+        };
+        pending_obligations: string[];
+        suggested_inputs: {
+            description: string;
+            flag: "--batch-results" | "--results" | "--updates" | "--external-analyzer-results";
+            suggested_path: string;
+        }[];
+        suggested_commands: string[];
+        interactive_provider_hint: string | null;
+        active_review_run?: {
+            worker_command: string[];
+            run_id: string;
+            audit_results_path: string;
+            task_path: string;
+            prompt_path: string;
+            pending_audit_tasks_path?: string | undefined;
+        } | undefined;
+        quick_start?: string | undefined;
+        file_map?: Record<string, string> | undefined;
+    } | undefined;
+}, {
+    contract_version: "audit-code/v1alpha1";
+    audit_state: {
+        status: "blocked" | "complete" | "not_started" | "active";
+        obligations: {
+            id: string;
+            state: "blocked" | "satisfied" | "missing" | "present" | "stale";
+            reason?: string | undefined;
+        }[];
+        last_obligation?: string | undefined;
+        last_executor?: string | undefined;
+        blockers?: string[] | undefined;
+    };
+    artifacts_written: string[];
+    progress_summary: string;
+    selected_obligation: string | null;
+    selected_executor: string | null;
+    progress_made: boolean;
+    next_likely_step: string | null;
+    handoff?: {
+        status: "blocked" | "complete" | "not_started" | "active";
+        summary: string;
+        provider: string | null;
+        repo_root: string;
+        artifacts_dir: string;
+        artifact_paths: {
+            current_prompt: string | null;
+            session_config: string;
+            runtime_validation_tasks: string | null;
+            audit_tasks: string | null;
+            incoming_dir: string;
+            operator_handoff_json: string;
+            operator_handoff_markdown: string;
+            run_ledger: string;
+            current_task: string | null;
+            current_tasks: string | null;
+        };
+        pending_obligations: string[];
+        suggested_inputs: {
+            description: string;
+            flag: "--batch-results" | "--results" | "--updates" | "--external-analyzer-results";
+            suggested_path: string;
+        }[];
+        suggested_commands: string[];
+        interactive_provider_hint: string | null;
+        active_review_run?: {
+            worker_command: string[];
+            run_id: string;
+            audit_results_path: string;
+            task_path: string;
+            prompt_path: string;
+            pending_audit_tasks_path?: string | undefined;
+        } | undefined;
+        quick_start?: string | undefined;
+        file_map?: Record<string, string> | undefined;
+    } | undefined;
+}>;
+export type AuditCodeResponse = z.infer<typeof AuditCodeResponseSchema>;
+//# sourceMappingURL=wrapperResponse.d.ts.map

package/dist/audit/contracts/wrapperResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapperResponse.d.ts","sourceRoot":"","sources":["../../../src/audit/contracts/wrapperResponse.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoFxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYzB,CAAC;AAEZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/audit/contracts/wrapperResponse.js

@@ -0,0 +1,96 @@
+// A6 — the audit-code wrapper CLI response envelope, single-sourced as zod.
+//
+// `audit-code next-step` (the .mjs wrapper) emits this JSON contract to the host
+// agent. It has no other TypeScript producer, so the schema lives here as the
+// single source of truth and the wrapper contract test validates against it
+// directly (replacing the former hand-authored audit-code-v1alpha1.schema.json).
+import { z } from "zod";
+const AuditStateStatusSchema = z.enum([
+    "not_started",
+    "active",
+    "blocked",
+    "complete",
+]);
+const ObligationViewSchema = z
+    .object({
+    id: z.string(),
+    state: z.enum(["missing", "present", "stale", "blocked", "satisfied"]),
+    reason: z.string().optional(),
+})
+    .strict();
+const AuditStateViewSchema = z
+    .object({
+    status: AuditStateStatusSchema,
+    last_executor: z.string().optional(),
+    last_obligation: z.string().optional(),
+    blockers: z.array(z.string()).optional(),
+    obligations: z.array(ObligationViewSchema),
+})
+    .strict();
+const SuggestedInputSchema = z
+    .object({
+    flag: z.enum([
+        "--results",
+        "--batch-results",
+        "--updates",
+        "--external-analyzer-results",
+    ]),
+    suggested_path: z.string(),
+    description: z.string(),
+})
+    .strict();
+const ActiveReviewRunSchema = z
+    .object({
+    run_id: z.string(),
+    task_path: z.string(),
+    prompt_path: z.string(),
+    pending_audit_tasks_path: z.string().optional(),
+    audit_results_path: z.string(),
+    worker_command: z.array(z.string()).min(1),
+})
+    .strict();
+const HandoffArtifactPathsSchema = z
+    .object({
+    incoming_dir: z.string(),
+    operator_handoff_json: z.string(),
+    operator_handoff_markdown: z.string(),
+    session_config: z.string(),
+    run_ledger: z.string(),
+    current_task: z.string().nullable(),
+    current_prompt: z.string().nullable(),
+    current_tasks: z.string().nullable(),
+    audit_tasks: z.string().nullable(),
+    runtime_validation_tasks: z.string().nullable(),
+})
+    .strict();
+const HandoffSchema = z
+    .object({
+    status: AuditStateStatusSchema,
+    repo_root: z.string(),
+    artifacts_dir: z.string(),
+    provider: z.string().nullable(),
+    summary: z.string(),
+    pending_obligations: z.array(z.string()),
+    suggested_inputs: z.array(SuggestedInputSchema),
+    suggested_commands: z.array(z.string()),
+    interactive_provider_hint: z.string().nullable(),
+    active_review_run: ActiveReviewRunSchema.optional(),
+    artifact_paths: HandoffArtifactPathsSchema,
+    quick_start: z.string().optional(),
+    file_map: z.record(z.string(), z.string()).optional(),
+})
+    .strict();
+export const AuditCodeResponseSchema = z
+    .object({
+    contract_version: z.literal("audit-code/v1alpha1"),
+    audit_state: AuditStateViewSchema,
+    selected_obligation: z.string().nullable(),
+    selected_executor: z.string().nullable(),
+    progress_made: z.boolean(),
+    artifacts_written: z.array(z.string()),
+    progress_summary: z.string(),
+    next_likely_step: z.string().nullable(),
+    handoff: HandoffSchema.optional(),
+})
+    .strict();
+//# sourceMappingURL=wrapperResponse.js.map

package/dist/audit/contracts/wrapperResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapperResponse.js","sourceRoot":"","sources":["../../../src/audit/contracts/wrapperResponse.ts"],"names":[],"mappings":"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"}

package/dist/audit/coverage.d.ts

@@ -0,0 +1,11 @@
+import type { ClassificationStatus, CoverageFileRecord, CoverageMatrix, FileCoverageRecord } from "./types.js";
+export declare function createCoverageMatrix(paths: string[]): CoverageMatrix;
+export declare function markExcludedPath(matrix: CoverageMatrix, path: string, classificationStatus: ClassificationStatus): void;
+export declare function applyUnitCoverage(matrix: CoverageMatrix, path: string, unitId: string, requiredLenses: string[]): void;
+export declare function applyFileCoverage(matrix: CoverageMatrix, fileCoverage: FileCoverageRecord[]): void;
+export declare function findUncoveredFiles(matrix: CoverageMatrix): CoverageFileRecord[];
+export declare function buildRequeueTargets(matrix: CoverageMatrix): Array<{
+    path: string;
+    missing_lenses: string[];
+}>;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/audit/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/audit/coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAEnB,MAAM,YAAY,CAAC;AAMpB,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,cAAc,CAWpE;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,EACZ,oBAAoB,EAAE,oBAAoB,GACzC,IAAI,CASN;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,EAAE,GACvB,IAAI,CAYN;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,kBAAkB,EAAE,GACjC,IAAI,CA0BN;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,cAAc,GACrB,kBAAkB,EAAE,CAKtB;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,KAAK,CAAC;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC,CAUD"}

package/dist/audit/coverage.js

@@ -0,0 +1,78 @@
+function buildFileIndex(matrix) {
+    return new Map(matrix.files.map((f) => [f.path, f]));
+}
+export function createCoverageMatrix(paths) {
+    return {
+        files: paths.map((path) => ({
+            path,
+            unit_ids: [],
+            classification_status: "unclassified",
+            audit_status: "pending",
+            required_lenses: [],
+            completed_lenses: [],
+        })),
+    };
+}
+export function markExcludedPath(matrix, path, classificationStatus) {
+    const record = matrix.files.find((f) => f.path === path);
+    if (!record)
+        return;
+    record.classification_status = classificationStatus;
+    record.audit_status = "excluded";
+    record.required_lenses = [];
+    record.completed_lenses = [];
+    record.unit_ids = [];
+}
+export function applyUnitCoverage(matrix, path, unitId, requiredLenses) {
+    const record = matrix.files.find((f) => f.path === path);
+    if (!record || record.audit_status === "excluded")
+        return;
+    if (!record.unit_ids.includes(unitId)) {
+        record.unit_ids.push(unitId);
+    }
+    record.classification_status = "classified";
+    record.required_lenses = [
+        ...new Set([...record.required_lenses, ...requiredLenses]),
+    ];
+}
+export function applyFileCoverage(matrix, fileCoverage) {
+    const index = buildFileIndex(matrix);
+    for (const coverage of fileCoverage) {
+        const record = index.get(coverage.path);
+        if (!record || record.audit_status === "excluded")
+            continue;
+        if (coverage.lens &&
+            record.required_lenses.includes(coverage.lens) &&
+            !record.completed_lenses.includes(coverage.lens)) {
+            record.completed_lenses.push(coverage.lens);
+        }
+    }
+    for (const file of matrix.files) {
+        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.completed_lenses.length > 0) {
+            file.audit_status = "partial";
+        }
+    }
+}
+export function findUncoveredFiles(matrix) {
+    return matrix.files.filter((file) => {
+        if (file.audit_status === "excluded")
+            return false;
+        return file.audit_status !== "complete";
+    });
+}
+export function buildRequeueTargets(matrix) {
+    return matrix.files
+        .filter((file) => file.audit_status !== "excluded")
+        .map((file) => ({
+        path: file.path,
+        missing_lenses: file.required_lenses.filter((lens) => !file.completed_lenses.includes(lens)),
+    }))
+        .filter((item) => item.missing_lenses.length > 0);
+}
+//# sourceMappingURL=coverage.js.map

package/dist/audit/coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.js","sourceRoot":"","sources":["../../src/audit/coverage.ts"],"names":[],"mappings":"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"}

package/dist/audit/extractors/analyzers/css.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageAnalyzer } from "./types.js";
+export declare const cssAnalyzer: LanguageAnalyzer;
+//# sourceMappingURL=css.d.ts.map

package/dist/audit/extractors/analyzers/css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../../../src/audit/extractors/analyzers/css.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAmC,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAgHpF,eAAO,MAAM,WAAW,EAAE,gBAKzB,CAAC"}