audit-tools 0.28.0

package/dist/shared/types/finding.d.ts

@@ -0,0 +1,1463 @@
+import { z } from "zod";
+/** Canonical finding severity vocabulary (most-severe-first). */
+export declare const FindingSeveritySchema: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+export type FindingSeverity = z.infer<typeof FindingSeveritySchema>;
+/** Canonical finding confidence vocabulary (most-confident-first). */
+export declare const FindingConfidenceSchema: z.ZodEnum<["high", "medium", "low"]>;
+export type FindingConfidence = z.infer<typeof FindingConfidenceSchema>;
+export declare const FindingLocationSchema: z.ZodObject<{
+    path: z.ZodString;
+    line_start: z.ZodOptional<z.ZodNumber>;
+    line_end: z.ZodOptional<z.ZodNumber>;
+    symbol: z.ZodOptional<z.ZodString>;
+    /**
+     * Verbatim text copied from this span, exactly as it appears in the cited
+     * file. The tool re-reads the file and content-matches this quote
+     * (whitespace/CRLF-normalized, matched on content not line numbers) to ground
+     * the finding; a finding whose quote does not re-verify is marked ungrounded
+     * (S7 anti-hallucination — grounding the claim, not attesting the read).
+     */
+    quoted_text: z.ZodOptional<z.ZodString>;
+    /** Content hash of the file when the finding was planned (remediator). */
+    hash_at_plan_time: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    symbol?: string | undefined;
+    line_start?: number | undefined;
+    line_end?: number | undefined;
+    quoted_text?: string | undefined;
+    hash_at_plan_time?: string | undefined;
+}, {
+    path: string;
+    symbol?: string | undefined;
+    line_start?: number | undefined;
+    line_end?: number | undefined;
+    quoted_text?: string | undefined;
+    hash_at_plan_time?: string | undefined;
+}>;
+export type FindingLocation = z.infer<typeof FindingLocationSchema>;
+/**
+ * Result of re-verifying a finding's cited verbatim span against disk. Attached
+ * by the auditor's grounding pass at ingest; a hallucinated or stale finding
+ * (quote not found on disk, or no quote provided) is surfaced as `ungrounded`
+ * rather than silently admitted as a confirmed finding.
+ *
+ * - `grounded`: the cited verbatim span re-verified against disk (S7 tier-1) or
+ *   an executable anchor CONFIRMED the behavior claim (tier-2). Admitted as fact.
+ * - `ungrounded`: the cited span did not re-verify, or no span was provided —
+ *   surfaced-but-not-confirmed. Stays in the admitted findings, flagged.
+ * - `refuted`: an executable anchor DISPROVED the claim (tier-2; e.g. a
+ *   madge-disproven cycle). Distinct from `ungrounded` ("couldn't verify"):
+ *   the tool actively disproved it, so it is quarantined-EXCLUDED from the
+ *   admitted contract (see `AuditFindingsReport.quarantined_findings`).
+ */
+export declare const FindingGroundingSchema: z.ZodObject<{
+    status: z.ZodEnum<["grounded", "ungrounded", "refuted"]>;
+    /** When ungrounded/refuted, which cited span(s) failed and why. */
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "grounded" | "ungrounded" | "refuted";
+    reason?: string | undefined;
+}, {
+    status: "grounded" | "ungrounded" | "refuted";
+    reason?: string | undefined;
+}>;
+export type FindingGrounding = z.infer<typeof FindingGroundingSchema>;
+/**
+ * What outcome of an executable anchor's command CONFIRMS the finding's claim.
+ * The worker declares the falsifiable condition; the tool runs the command and
+ * checks it, so the confirmed bit is the tool's run, never the model's word.
+ * `text` is required for the output_* kinds (the substring to look for).
+ */
+export declare const AnchorExpectationSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"exit_zero">;
+}, "strip", z.ZodTypeAny, {
+    kind: "exit_zero";
+}, {
+    kind: "exit_zero";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"exit_nonzero">;
+}, "strip", z.ZodTypeAny, {
+    kind: "exit_nonzero";
+}, {
+    kind: "exit_nonzero";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"output_includes">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "output_includes";
+    text: string;
+}, {
+    kind: "output_includes";
+    text: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"output_excludes">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "output_excludes";
+    text: string;
+}, {
+    kind: "output_excludes";
+    text: string;
+}>]>;
+export type AnchorExpectation = z.infer<typeof AnchorExpectationSchema>;
+/**
+ * An executable anchor for a *behavior* claim ("throws" / "test fails" / "no
+ * cycle" / "unused symbol") — S7 tier-2. A read-only inspection command the tool
+ * runs to confirm or refute the claim; a refuting run quarantines the finding as
+ * ungrounded, exactly what disproved hallucinated cycle/symbol findings in the
+ * 452-self-audit. `command` is argv (run without a shell, from the repo root);
+ * the executable must be in the tool's inspection-only allowlist or the anchor is
+ * skipped (not auto-run). `confirm_if` is the falsifiable condition that, when
+ * the tool runs `command`, demonstrates the claim is true.
+ */
+export declare const ExecutableAnchorSchema: z.ZodObject<{
+    command: z.ZodArray<z.ZodString, "many">;
+    confirm_if: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"exit_zero">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "exit_zero";
+    }, {
+        kind: "exit_zero";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"exit_nonzero">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "exit_nonzero";
+    }, {
+        kind: "exit_nonzero";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"output_includes">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "output_includes";
+        text: string;
+    }, {
+        kind: "output_includes";
+        text: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"output_excludes">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "output_excludes";
+        text: string;
+    }, {
+        kind: "output_excludes";
+        text: string;
+    }>]>;
+    /** Optional human description of what running the command proves. */
+    claim: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: string[];
+    confirm_if: {
+        kind: "exit_zero";
+    } | {
+        kind: "exit_nonzero";
+    } | {
+        kind: "output_includes";
+        text: string;
+    } | {
+        kind: "output_excludes";
+        text: string;
+    };
+    claim?: string | undefined;
+}, {
+    command: string[];
+    confirm_if: {
+        kind: "exit_zero";
+    } | {
+        kind: "exit_nonzero";
+    } | {
+        kind: "output_includes";
+        text: string;
+    } | {
+        kind: "output_excludes";
+        text: string;
+    };
+    claim?: string | undefined;
+}>;
+export type ExecutableAnchor = z.infer<typeof ExecutableAnchorSchema>;
+export declare const FindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    /** Audit lens; the auditor narrows this to its `Lens` union. */
+    lens: z.ZodString;
+    summary: z.ZodString;
+    affected_files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        line_start: z.ZodOptional<z.ZodNumber>;
+        line_end: z.ZodOptional<z.ZodNumber>;
+        symbol: z.ZodOptional<z.ZodString>;
+        /**
+         * Verbatim text copied from this span, exactly as it appears in the cited
+         * file. The tool re-reads the file and content-matches this quote
+         * (whitespace/CRLF-normalized, matched on content not line numbers) to ground
+         * the finding; a finding whose quote does not re-verify is marked ungrounded
+         * (S7 anti-hallucination — grounding the claim, not attesting the read).
+         */
+        quoted_text: z.ZodOptional<z.ZodString>;
+        /** Content hash of the file when the finding was planned (remediator). */
+        hash_at_plan_time: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        symbol?: string | undefined;
+        line_start?: number | undefined;
+        line_end?: number | undefined;
+        quoted_text?: string | undefined;
+        hash_at_plan_time?: string | undefined;
+    }, {
+        path: string;
+        symbol?: string | undefined;
+        line_start?: number | undefined;
+        line_end?: number | undefined;
+        quoted_text?: string | undefined;
+        hash_at_plan_time?: string | undefined;
+    }>, "many">;
+    impact: z.ZodOptional<z.ZodString>;
+    likelihood: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    reproduction: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    systemic: z.ZodOptional<z.ZodBoolean>;
+    related_findings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Synthesis theme this finding belongs to (Phase 6). */
+    theme_id: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether at least one evidence entry cites a real repo path (and valid line)
+     * that exists on disk. Set by the remediator's deterministic grounding pass on
+     * LLM-extracted findings; absent on auditor-produced findings (already grounded).
+     */
+    evidence_grounded: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Result of the auditor's quote-and-verify grounding pass (S7): whether this
+     * finding's cited verbatim span re-verified against disk. Absent until the
+     * grounding pass runs at ingest.
+     */
+    grounding: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<["grounded", "ungrounded", "refuted"]>;
+        /** When ungrounded/refuted, which cited span(s) failed and why. */
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "grounded" | "ungrounded" | "refuted";
+        reason?: string | undefined;
+    }, {
+        status: "grounded" | "ungrounded" | "refuted";
+        reason?: string | undefined;
+    }>>;
+    /**
+     * Optional executable anchor for a behavior claim (S7 tier-2). The tool runs
+     * the read-only `command` at ingest and folds the verdict into `grounding`: a
+     * refuting run marks the finding ungrounded (quarantined) with the run as the
+     * reason, a confirming run grounds it; an inconclusive/skipped run leaves the
+     * quote-and-verify (tier-1) grounding in place. Absent for findings with no
+     * runnable behavior claim.
+     */
+    executable_anchor: z.ZodOptional<z.ZodObject<{
+        command: z.ZodArray<z.ZodString, "many">;
+        confirm_if: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"exit_zero">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "exit_zero";
+        }, {
+            kind: "exit_zero";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"exit_nonzero">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "exit_nonzero";
+        }, {
+            kind: "exit_nonzero";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"output_includes">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "output_includes";
+            text: string;
+        }, {
+            kind: "output_includes";
+            text: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"output_excludes">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "output_excludes";
+            text: string;
+        }, {
+            kind: "output_excludes";
+            text: string;
+        }>]>;
+        /** Optional human description of what running the command proves. */
+        claim: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command: string[];
+        confirm_if: {
+            kind: "exit_zero";
+        } | {
+            kind: "exit_nonzero";
+        } | {
+            kind: "output_includes";
+            text: string;
+        } | {
+            kind: "output_excludes";
+            text: string;
+        };
+        claim?: string | undefined;
+    }, {
+        command: string[];
+        confirm_if: {
+            kind: "exit_zero";
+        } | {
+            kind: "exit_nonzero";
+        } | {
+            kind: "output_includes";
+            text: string;
+        } | {
+            kind: "output_excludes";
+            text: string;
+        };
+        claim?: string | undefined;
+    }>>;
+    /** Contract-pipeline goal this generated remediation finding belongs to. */
+    contract_goal_id: z.ZodOptional<z.ZodString>;
+    /** Contract-pipeline obligation IDs this finding/task is intended to satisfy. */
+    contract_obligation_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Contract-pipeline verification obligation IDs this task must prove. */
+    verification_obligation_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Commands recommended by the implementation DAG for focused verification. */
+    targeted_commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    confidence: "high" | "low" | "medium";
+    title: string;
+    category: string;
+    severity: "high" | "low" | "critical" | "medium" | "info";
+    lens: string;
+    summary: string;
+    affected_files: {
+        path: string;
+        symbol?: string | undefined;
+        line_start?: number | undefined;
+        line_end?: number | undefined;
+        quoted_text?: string | undefined;
+        hash_at_plan_time?: string | undefined;
+    }[];
+    impact?: string | undefined;
+    likelihood?: string | undefined;
+    evidence?: string[] | undefined;
+    reproduction?: string[] | undefined;
+    systemic?: boolean | undefined;
+    related_findings?: string[] | undefined;
+    theme_id?: string | undefined;
+    evidence_grounded?: boolean | undefined;
+    grounding?: {
+        status: "grounded" | "ungrounded" | "refuted";
+        reason?: string | undefined;
+    } | undefined;
+    executable_anchor?: {
+        command: string[];
+        confirm_if: {
+            kind: "exit_zero";
+        } | {
+            kind: "exit_nonzero";
+        } | {
+            kind: "output_includes";
+            text: string;
+        } | {
+            kind: "output_excludes";
+            text: string;
+        };
+        claim?: string | undefined;
+    } | undefined;
+    contract_goal_id?: string | undefined;
+    contract_obligation_ids?: string[] | undefined;
+    verification_obligation_ids?: string[] | undefined;
+    targeted_commands?: string[] | undefined;
+}, {
+    id: string;
+    confidence: "high" | "low" | "medium";
+    title: string;
+    category: string;
+    severity: "high" | "low" | "critical" | "medium" | "info";
+    lens: string;
+    summary: string;
+    affected_files: {
+        path: string;
+        symbol?: string | undefined;
+        line_start?: number | undefined;
+        line_end?: number | undefined;
+        quoted_text?: string | undefined;
+        hash_at_plan_time?: string | undefined;
+    }[];
+    impact?: string | undefined;
+    likelihood?: string | undefined;
+    evidence?: string[] | undefined;
+    reproduction?: string[] | undefined;
+    systemic?: boolean | undefined;
+    related_findings?: string[] | undefined;
+    theme_id?: string | undefined;
+    evidence_grounded?: boolean | undefined;
+    grounding?: {
+        status: "grounded" | "ungrounded" | "refuted";
+        reason?: string | undefined;
+    } | undefined;
+    executable_anchor?: {
+        command: string[];
+        confirm_if: {
+            kind: "exit_zero";
+        } | {
+            kind: "exit_nonzero";
+        } | {
+            kind: "output_includes";
+            text: string;
+        } | {
+            kind: "output_excludes";
+            text: string;
+        };
+        claim?: string | undefined;
+    } | undefined;
+    contract_goal_id?: string | undefined;
+    contract_obligation_ids?: string[] | undefined;
+    verification_obligation_ids?: string[] | undefined;
+    targeted_commands?: string[] | undefined;
+}>;
+export type Finding = z.infer<typeof FindingSchema>;
+/** Report-level grouping of findings into parallelizable units of work. */
+export declare const WorkBlockSchema: z.ZodObject<{
+    id: z.ZodString;
+    finding_ids: z.ZodArray<z.ZodString, "many">;
+    unit_ids: z.ZodArray<z.ZodString, "many">;
+    owned_files: z.ZodArray<z.ZodString, "many">;
+    max_severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+    rationale: z.ZodString;
+    depends_on: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    finding_ids: string[];
+    unit_ids: string[];
+    owned_files: string[];
+    max_severity: "high" | "low" | "critical" | "medium" | "info";
+    rationale: string;
+    depends_on: string[];
+}, {
+    id: string;
+    finding_ids: string[];
+    unit_ids: string[];
+    owned_files: string[];
+    max_severity: "high" | "low" | "critical" | "medium" | "info";
+    rationale: string;
+    depends_on: string[];
+}>;
+export type WorkBlock = z.infer<typeof WorkBlockSchema>;
+/** A synthesis theme: a root cause spanning several findings (Phase 6). */
+export declare const FindingThemeSchema: z.ZodObject<{
+    theme_id: z.ZodString;
+    title: z.ZodString;
+    root_cause: z.ZodString;
+    finding_ids: z.ZodArray<z.ZodString, "many">;
+    suggested_fix_pattern: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    theme_id: string;
+    finding_ids: string[];
+    root_cause: string;
+    suggested_fix_pattern: string;
+}, {
+    title: string;
+    theme_id: string;
+    finding_ids: string[];
+    root_cause: string;
+    suggested_fix_pattern: string;
+}>;
+export type FindingTheme = z.infer<typeof FindingThemeSchema>;
+/**
+ * The optional LLM synthesis-narrative payload (Phase 6). Produced by a single
+ * cached host/provider pass over the deterministic findings and merged into
+ * `audit-findings.json`. Omitted entirely when no provider is available.
+ */
+export declare const SynthesisNarrativeSchema: z.ZodObject<{
+    themes: z.ZodArray<z.ZodObject<{
+        theme_id: z.ZodString;
+        title: z.ZodString;
+        root_cause: z.ZodString;
+        finding_ids: z.ZodArray<z.ZodString, "many">;
+        suggested_fix_pattern: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        theme_id: string;
+        finding_ids: string[];
+        root_cause: string;
+        suggested_fix_pattern: string;
+    }, {
+        title: string;
+        theme_id: string;
+        finding_ids: string[];
+        root_cause: string;
+        suggested_fix_pattern: string;
+    }>, "many">;
+    executive_summary: z.ZodOptional<z.ZodString>;
+    top_risks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    themes: {
+        title: string;
+        theme_id: string;
+        finding_ids: string[];
+        root_cause: string;
+        suggested_fix_pattern: string;
+    }[];
+    executive_summary?: string | undefined;
+    top_risks?: string[] | undefined;
+}, {
+    themes: {
+        title: string;
+        theme_id: string;
+        finding_ids: string[];
+        root_cause: string;
+        suggested_fix_pattern: string;
+    }[];
+    executive_summary?: string | undefined;
+    top_risks?: string[] | undefined;
+}>;
+export type SynthesisNarrative = z.infer<typeof SynthesisNarrativeSchema>;
+/**
+ * The canonical identity subset of a Finding — the fields that identify it
+ * across the audit→remediate pipeline without contract-pipeline overlays.
+ *
+ * INV-shared-core-05: consumers that need to identify a finding (deduplicate,
+ * compare, index) should use this type rather than stripping contract_* fields
+ * ad-hoc. `findingIdentity()` extracts it safely.
+ */
+export interface FindingIdentity {
+    id: string;
+    title: string;
+    severity: FindingSeverity;
+    lens: string;
+    affected_files: FindingLocation[];
+    summary: string;
+}
+/**
+ * Extract the canonical identity subset from a Finding, dropping any
+ * contract-pipeline overlay fields (contract_goal_id, contract_obligation_ids,
+ * verification_obligation_ids, targeted_commands). This is the stable,
+ * pipeline-portable representation of what a finding IS, separate from how it
+ * participates in a particular remediation run.
+ *
+ * INV-shared-core-05 invariant: the result must be derivable without knowing
+ * which contract-pipeline fields are present, and must round-trip through JSON
+ * without carrying any contract_* fields.
+ */
+export declare function findingIdentity(finding: Finding): FindingIdentity;
+export declare const AuditFindingsSummarySchema: z.ZodObject<{
+    finding_count: z.ZodNumber;
+    work_block_count: z.ZodNumber;
+    severity_breakdown: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    audited_file_count: z.ZodNumber;
+    excluded_file_count: z.ZodNumber;
+    runtime_validation_status_breakdown: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    lens_breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    /**
+     * Per-status counts of the auditor's grounding pass (S7): `grounded`
+     * (re-verified against disk or anchor-confirmed), `ungrounded`
+     * (surfaced-but-not-confirmed), `refuted` (anchor-DISPROVED →
+     * quarantined-excluded). Counted over ALL findings incl. the
+     * quarantined-refuted ones, so a non-zero `refuted` reflects findings that were
+     * dropped from the admitted set. Absent when no finding carried a verdict.
+     */
+    grounding_status_breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    /**
+     * Units/tasks stranded by a partial-completion terminal (empty-pool or
+     * livelock guard). Distinct from `budget_deferred_task_count` (planned
+     * deferrals) — these units could not be dispatched because the provider pool
+     * was exhausted before dispatch completed. Present only when a
+     * `partial_completion_terminal` was set on the active-dispatch artifact.
+     */
+    stranded_unit_count: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    finding_count: number;
+    work_block_count: number;
+    severity_breakdown: Record<string, number>;
+    audited_file_count: number;
+    excluded_file_count: number;
+    runtime_validation_status_breakdown: Record<string, number>;
+    lens_breakdown?: Record<string, number> | undefined;
+    grounding_status_breakdown?: Record<string, number> | undefined;
+    stranded_unit_count?: number | undefined;
+}, {
+    finding_count: number;
+    work_block_count: number;
+    severity_breakdown: Record<string, number>;
+    audited_file_count: number;
+    excluded_file_count: number;
+    runtime_validation_status_breakdown: Record<string, number>;
+    lens_breakdown?: Record<string, number> | undefined;
+    grounding_status_breakdown?: Record<string, number> | undefined;
+    stranded_unit_count?: number | undefined;
+}>;
+export type AuditFindingsSummary = z.infer<typeof AuditFindingsSummarySchema>;
+/**
+ * The canonical `audit-findings.json` contract. Deterministic fields are always
+ * present; narrative fields (themes/executive_summary/top_risks) are added by
+ * the optional Phase 6 synthesis-narrative pass and omitted without a provider.
+ */
+export declare const AuditFindingsReportSchema: z.ZodObject<{
+    contract_version: z.ZodString;
+    summary: z.ZodObject<{
+        finding_count: z.ZodNumber;
+        work_block_count: z.ZodNumber;
+        severity_breakdown: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        audited_file_count: z.ZodNumber;
+        excluded_file_count: z.ZodNumber;
+        runtime_validation_status_breakdown: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        lens_breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        /**
+         * Per-status counts of the auditor's grounding pass (S7): `grounded`
+         * (re-verified against disk or anchor-confirmed), `ungrounded`
+         * (surfaced-but-not-confirmed), `refuted` (anchor-DISPROVED →
+         * quarantined-excluded). Counted over ALL findings incl. the
+         * quarantined-refuted ones, so a non-zero `refuted` reflects findings that were
+         * dropped from the admitted set. Absent when no finding carried a verdict.
+         */
+        grounding_status_breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        /**
+         * Units/tasks stranded by a partial-completion terminal (empty-pool or
+         * livelock guard). Distinct from `budget_deferred_task_count` (planned
+         * deferrals) — these units could not be dispatched because the provider pool
+         * was exhausted before dispatch completed. Present only when a
+         * `partial_completion_terminal` was set on the active-dispatch artifact.
+         */
+        stranded_unit_count: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        finding_count: number;
+        work_block_count: number;
+        severity_breakdown: Record<string, number>;
+        audited_file_count: number;
+        excluded_file_count: number;
+        runtime_validation_status_breakdown: Record<string, number>;
+        lens_breakdown?: Record<string, number> | undefined;
+        grounding_status_breakdown?: Record<string, number> | undefined;
+        stranded_unit_count?: number | undefined;
+    }, {
+        finding_count: number;
+        work_block_count: number;
+        severity_breakdown: Record<string, number>;
+        audited_file_count: number;
+        excluded_file_count: number;
+        runtime_validation_status_breakdown: Record<string, number>;
+        lens_breakdown?: Record<string, number> | undefined;
+        grounding_status_breakdown?: Record<string, number> | undefined;
+        stranded_unit_count?: number | undefined;
+    }>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+        /** Audit lens; the auditor narrows this to its `Lens` union. */
+        lens: z.ZodString;
+        summary: z.ZodString;
+        affected_files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            line_start: z.ZodOptional<z.ZodNumber>;
+            line_end: z.ZodOptional<z.ZodNumber>;
+            symbol: z.ZodOptional<z.ZodString>;
+            /**
+             * Verbatim text copied from this span, exactly as it appears in the cited
+             * file. The tool re-reads the file and content-matches this quote
+             * (whitespace/CRLF-normalized, matched on content not line numbers) to ground
+             * the finding; a finding whose quote does not re-verify is marked ungrounded
+             * (S7 anti-hallucination — grounding the claim, not attesting the read).
+             */
+            quoted_text: z.ZodOptional<z.ZodString>;
+            /** Content hash of the file when the finding was planned (remediator). */
+            hash_at_plan_time: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }, {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }>, "many">;
+        impact: z.ZodOptional<z.ZodString>;
+        likelihood: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        reproduction: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        systemic: z.ZodOptional<z.ZodBoolean>;
+        related_findings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Synthesis theme this finding belongs to (Phase 6). */
+        theme_id: z.ZodOptional<z.ZodString>;
+        /**
+         * Whether at least one evidence entry cites a real repo path (and valid line)
+         * that exists on disk. Set by the remediator's deterministic grounding pass on
+         * LLM-extracted findings; absent on auditor-produced findings (already grounded).
+         */
+        evidence_grounded: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Result of the auditor's quote-and-verify grounding pass (S7): whether this
+         * finding's cited verbatim span re-verified against disk. Absent until the
+         * grounding pass runs at ingest.
+         */
+        grounding: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<["grounded", "ungrounded", "refuted"]>;
+            /** When ungrounded/refuted, which cited span(s) failed and why. */
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        }, {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        }>>;
+        /**
+         * Optional executable anchor for a behavior claim (S7 tier-2). The tool runs
+         * the read-only `command` at ingest and folds the verdict into `grounding`: a
+         * refuting run marks the finding ungrounded (quarantined) with the run as the
+         * reason, a confirming run grounds it; an inconclusive/skipped run leaves the
+         * quote-and-verify (tier-1) grounding in place. Absent for findings with no
+         * runnable behavior claim.
+         */
+        executable_anchor: z.ZodOptional<z.ZodObject<{
+            command: z.ZodArray<z.ZodString, "many">;
+            confirm_if: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"exit_zero">;
+            }, "strip", z.ZodTypeAny, {
+                kind: "exit_zero";
+            }, {
+                kind: "exit_zero";
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"exit_nonzero">;
+            }, "strip", z.ZodTypeAny, {
+                kind: "exit_nonzero";
+            }, {
+                kind: "exit_nonzero";
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"output_includes">;
+                text: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                kind: "output_includes";
+                text: string;
+            }, {
+                kind: "output_includes";
+                text: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"output_excludes">;
+                text: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                kind: "output_excludes";
+                text: string;
+            }, {
+                kind: "output_excludes";
+                text: string;
+            }>]>;
+            /** Optional human description of what running the command proves. */
+            claim: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        }, {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        }>>;
+        /** Contract-pipeline goal this generated remediation finding belongs to. */
+        contract_goal_id: z.ZodOptional<z.ZodString>;
+        /** Contract-pipeline obligation IDs this finding/task is intended to satisfy. */
+        contract_obligation_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Contract-pipeline verification obligation IDs this task must prove. */
+        verification_obligation_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Commands recommended by the implementation DAG for focused verification. */
+        targeted_commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        confidence: "high" | "low" | "medium";
+        title: string;
+        category: string;
+        severity: "high" | "low" | "critical" | "medium" | "info";
+        lens: string;
+        summary: string;
+        affected_files: {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }[];
+        impact?: string | undefined;
+        likelihood?: string | undefined;
+        evidence?: string[] | undefined;
+        reproduction?: string[] | undefined;
+        systemic?: boolean | undefined;
+        related_findings?: string[] | undefined;
+        theme_id?: string | undefined;
+        evidence_grounded?: boolean | undefined;
+        grounding?: {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        } | undefined;
+        executable_anchor?: {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        } | undefined;
+        contract_goal_id?: string | undefined;
+        contract_obligation_ids?: string[] | undefined;
+        verification_obligation_ids?: string[] | undefined;
+        targeted_commands?: string[] | undefined;
+    }, {
+        id: string;
+        confidence: "high" | "low" | "medium";
+        title: string;
+        category: string;
+        severity: "high" | "low" | "critical" | "medium" | "info";
+        lens: string;
+        summary: string;
+        affected_files: {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }[];
+        impact?: string | undefined;
+        likelihood?: string | undefined;
+        evidence?: string[] | undefined;
+        reproduction?: string[] | undefined;
+        systemic?: boolean | undefined;
+        related_findings?: string[] | undefined;
+        theme_id?: string | undefined;
+        evidence_grounded?: boolean | undefined;
+        grounding?: {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        } | undefined;
+        executable_anchor?: {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        } | undefined;
+        contract_goal_id?: string | undefined;
+        contract_obligation_ids?: string[] | undefined;
+        verification_obligation_ids?: string[] | undefined;
+        targeted_commands?: string[] | undefined;
+    }>, "many">;
+    work_blocks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        finding_ids: z.ZodArray<z.ZodString, "many">;
+        unit_ids: z.ZodArray<z.ZodString, "many">;
+        owned_files: z.ZodArray<z.ZodString, "many">;
+        max_severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+        rationale: z.ZodString;
+        depends_on: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        finding_ids: string[];
+        unit_ids: string[];
+        owned_files: string[];
+        max_severity: "high" | "low" | "critical" | "medium" | "info";
+        rationale: string;
+        depends_on: string[];
+    }, {
+        id: string;
+        finding_ids: string[];
+        unit_ids: string[];
+        owned_files: string[];
+        max_severity: "high" | "low" | "critical" | "medium" | "info";
+        rationale: string;
+        depends_on: string[];
+    }>, "many">;
+    /**
+     * Findings a tool-executable anchor REFUTED (S7 tier-2 disproof). Recorded here
+     * but kept OUT of `findings`/`work_blocks` so a disproven claim never merges as
+     * actionable fact — quarantine, not delete. Absent when nothing was refuted.
+     */
+    quarantined_findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+        /** Audit lens; the auditor narrows this to its `Lens` union. */
+        lens: z.ZodString;
+        summary: z.ZodString;
+        affected_files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            line_start: z.ZodOptional<z.ZodNumber>;
+            line_end: z.ZodOptional<z.ZodNumber>;
+            symbol: z.ZodOptional<z.ZodString>;
+            /**
+             * Verbatim text copied from this span, exactly as it appears in the cited
+             * file. The tool re-reads the file and content-matches this quote
+             * (whitespace/CRLF-normalized, matched on content not line numbers) to ground
+             * the finding; a finding whose quote does not re-verify is marked ungrounded
+             * (S7 anti-hallucination — grounding the claim, not attesting the read).
+             */
+            quoted_text: z.ZodOptional<z.ZodString>;
+            /** Content hash of the file when the finding was planned (remediator). */
+            hash_at_plan_time: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }, {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }>, "many">;
+        impact: z.ZodOptional<z.ZodString>;
+        likelihood: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        reproduction: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        systemic: z.ZodOptional<z.ZodBoolean>;
+        related_findings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Synthesis theme this finding belongs to (Phase 6). */
+        theme_id: z.ZodOptional<z.ZodString>;
+        /**
+         * Whether at least one evidence entry cites a real repo path (and valid line)
+         * that exists on disk. Set by the remediator's deterministic grounding pass on
+         * LLM-extracted findings; absent on auditor-produced findings (already grounded).
+         */
+        evidence_grounded: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Result of the auditor's quote-and-verify grounding pass (S7): whether this
+         * finding's cited verbatim span re-verified against disk. Absent until the
+         * grounding pass runs at ingest.
+         */
+        grounding: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<["grounded", "ungrounded", "refuted"]>;
+            /** When ungrounded/refuted, which cited span(s) failed and why. */
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        }, {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        }>>;
+        /**
+         * Optional executable anchor for a behavior claim (S7 tier-2). The tool runs
+         * the read-only `command` at ingest and folds the verdict into `grounding`: a
+         * refuting run marks the finding ungrounded (quarantined) with the run as the
+         * reason, a confirming run grounds it; an inconclusive/skipped run leaves the
+         * quote-and-verify (tier-1) grounding in place. Absent for findings with no
+         * runnable behavior claim.
+         */
+        executable_anchor: z.ZodOptional<z.ZodObject<{
+            command: z.ZodArray<z.ZodString, "many">;
+            confirm_if: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"exit_zero">;
+            }, "strip", z.ZodTypeAny, {
+                kind: "exit_zero";
+            }, {
+                kind: "exit_zero";
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"exit_nonzero">;
+            }, "strip", z.ZodTypeAny, {
+                kind: "exit_nonzero";
+            }, {
+                kind: "exit_nonzero";
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"output_includes">;
+                text: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                kind: "output_includes";
+                text: string;
+            }, {
+                kind: "output_includes";
+                text: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"output_excludes">;
+                text: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                kind: "output_excludes";
+                text: string;
+            }, {
+                kind: "output_excludes";
+                text: string;
+            }>]>;
+            /** Optional human description of what running the command proves. */
+            claim: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        }, {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        }>>;
+        /** Contract-pipeline goal this generated remediation finding belongs to. */
+        contract_goal_id: z.ZodOptional<z.ZodString>;
+        /** Contract-pipeline obligation IDs this finding/task is intended to satisfy. */
+        contract_obligation_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Contract-pipeline verification obligation IDs this task must prove. */
+        verification_obligation_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Commands recommended by the implementation DAG for focused verification. */
+        targeted_commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        confidence: "high" | "low" | "medium";
+        title: string;
+        category: string;
+        severity: "high" | "low" | "critical" | "medium" | "info";
+        lens: string;
+        summary: string;
+        affected_files: {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }[];
+        impact?: string | undefined;
+        likelihood?: string | undefined;
+        evidence?: string[] | undefined;
+        reproduction?: string[] | undefined;
+        systemic?: boolean | undefined;
+        related_findings?: string[] | undefined;
+        theme_id?: string | undefined;
+        evidence_grounded?: boolean | undefined;
+        grounding?: {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        } | undefined;
+        executable_anchor?: {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        } | undefined;
+        contract_goal_id?: string | undefined;
+        contract_obligation_ids?: string[] | undefined;
+        verification_obligation_ids?: string[] | undefined;
+        targeted_commands?: string[] | undefined;
+    }, {
+        id: string;
+        confidence: "high" | "low" | "medium";
+        title: string;
+        category: string;
+        severity: "high" | "low" | "critical" | "medium" | "info";
+        lens: string;
+        summary: string;
+        affected_files: {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }[];
+        impact?: string | undefined;
+        likelihood?: string | undefined;
+        evidence?: string[] | undefined;
+        reproduction?: string[] | undefined;
+        systemic?: boolean | undefined;
+        related_findings?: string[] | undefined;
+        theme_id?: string | undefined;
+        evidence_grounded?: boolean | undefined;
+        grounding?: {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        } | undefined;
+        executable_anchor?: {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        } | undefined;
+        contract_goal_id?: string | undefined;
+        contract_obligation_ids?: string[] | undefined;
+        verification_obligation_ids?: string[] | undefined;
+        targeted_commands?: string[] | undefined;
+    }>, "many">>;
+    /** Paths excluded from the audit per the intent checkpoint, with reasons. */
+    excluded_scope: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        reason: string;
+    }, {
+        path: string;
+        reason: string;
+    }>, "many">>;
+    themes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        theme_id: z.ZodString;
+        title: z.ZodString;
+        root_cause: z.ZodString;
+        finding_ids: z.ZodArray<z.ZodString, "many">;
+        suggested_fix_pattern: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        theme_id: string;
+        finding_ids: string[];
+        root_cause: string;
+        suggested_fix_pattern: string;
+    }, {
+        title: string;
+        theme_id: string;
+        finding_ids: string[];
+        root_cause: string;
+        suggested_fix_pattern: string;
+    }>, "many">>;
+    executive_summary: z.ZodOptional<z.ZodString>;
+    top_risks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    summary: {
+        finding_count: number;
+        work_block_count: number;
+        severity_breakdown: Record<string, number>;
+        audited_file_count: number;
+        excluded_file_count: number;
+        runtime_validation_status_breakdown: Record<string, number>;
+        lens_breakdown?: Record<string, number> | undefined;
+        grounding_status_breakdown?: Record<string, number> | undefined;
+        stranded_unit_count?: number | undefined;
+    };
+    contract_version: string;
+    findings: {
+        id: string;
+        confidence: "high" | "low" | "medium";
+        title: string;
+        category: string;
+        severity: "high" | "low" | "critical" | "medium" | "info";
+        lens: string;
+        summary: string;
+        affected_files: {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }[];
+        impact?: string | undefined;
+        likelihood?: string | undefined;
+        evidence?: string[] | undefined;
+        reproduction?: string[] | undefined;
+        systemic?: boolean | undefined;
+        related_findings?: string[] | undefined;
+        theme_id?: string | undefined;
+        evidence_grounded?: boolean | undefined;
+        grounding?: {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        } | undefined;
+        executable_anchor?: {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        } | undefined;
+        contract_goal_id?: string | undefined;
+        contract_obligation_ids?: string[] | undefined;
+        verification_obligation_ids?: string[] | undefined;
+        targeted_commands?: string[] | undefined;
+    }[];
+    work_blocks: {
+        id: string;
+        finding_ids: string[];
+        unit_ids: string[];
+        owned_files: string[];
+        max_severity: "high" | "low" | "critical" | "medium" | "info";
+        rationale: string;
+        depends_on: string[];
+    }[];
+    themes?: {
+        title: string;
+        theme_id: string;
+        finding_ids: string[];
+        root_cause: string;
+        suggested_fix_pattern: string;
+    }[] | undefined;
+    executive_summary?: string | undefined;
+    top_risks?: string[] | undefined;
+    quarantined_findings?: {
+        id: string;
+        confidence: "high" | "low" | "medium";
+        title: string;
+        category: string;
+        severity: "high" | "low" | "critical" | "medium" | "info";
+        lens: string;
+        summary: string;
+        affected_files: {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }[];
+        impact?: string | undefined;
+        likelihood?: string | undefined;
+        evidence?: string[] | undefined;
+        reproduction?: string[] | undefined;
+        systemic?: boolean | undefined;
+        related_findings?: string[] | undefined;
+        theme_id?: string | undefined;
+        evidence_grounded?: boolean | undefined;
+        grounding?: {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        } | undefined;
+        executable_anchor?: {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        } | undefined;
+        contract_goal_id?: string | undefined;
+        contract_obligation_ids?: string[] | undefined;
+        verification_obligation_ids?: string[] | undefined;
+        targeted_commands?: string[] | undefined;
+    }[] | undefined;
+    excluded_scope?: {
+        path: string;
+        reason: string;
+    }[] | undefined;
+}, {
+    summary: {
+        finding_count: number;
+        work_block_count: number;
+        severity_breakdown: Record<string, number>;
+        audited_file_count: number;
+        excluded_file_count: number;
+        runtime_validation_status_breakdown: Record<string, number>;
+        lens_breakdown?: Record<string, number> | undefined;
+        grounding_status_breakdown?: Record<string, number> | undefined;
+        stranded_unit_count?: number | undefined;
+    };
+    contract_version: string;
+    findings: {
+        id: string;
+        confidence: "high" | "low" | "medium";
+        title: string;
+        category: string;
+        severity: "high" | "low" | "critical" | "medium" | "info";
+        lens: string;
+        summary: string;
+        affected_files: {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }[];
+        impact?: string | undefined;
+        likelihood?: string | undefined;
+        evidence?: string[] | undefined;
+        reproduction?: string[] | undefined;
+        systemic?: boolean | undefined;
+        related_findings?: string[] | undefined;
+        theme_id?: string | undefined;
+        evidence_grounded?: boolean | undefined;
+        grounding?: {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        } | undefined;
+        executable_anchor?: {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        } | undefined;
+        contract_goal_id?: string | undefined;
+        contract_obligation_ids?: string[] | undefined;
+        verification_obligation_ids?: string[] | undefined;
+        targeted_commands?: string[] | undefined;
+    }[];
+    work_blocks: {
+        id: string;
+        finding_ids: string[];
+        unit_ids: string[];
+        owned_files: string[];
+        max_severity: "high" | "low" | "critical" | "medium" | "info";
+        rationale: string;
+        depends_on: string[];
+    }[];
+    themes?: {
+        title: string;
+        theme_id: string;
+        finding_ids: string[];
+        root_cause: string;
+        suggested_fix_pattern: string;
+    }[] | undefined;
+    executive_summary?: string | undefined;
+    top_risks?: string[] | undefined;
+    quarantined_findings?: {
+        id: string;
+        confidence: "high" | "low" | "medium";
+        title: string;
+        category: string;
+        severity: "high" | "low" | "critical" | "medium" | "info";
+        lens: string;
+        summary: string;
+        affected_files: {
+            path: string;
+            symbol?: string | undefined;
+            line_start?: number | undefined;
+            line_end?: number | undefined;
+            quoted_text?: string | undefined;
+            hash_at_plan_time?: string | undefined;
+        }[];
+        impact?: string | undefined;
+        likelihood?: string | undefined;
+        evidence?: string[] | undefined;
+        reproduction?: string[] | undefined;
+        systemic?: boolean | undefined;
+        related_findings?: string[] | undefined;
+        theme_id?: string | undefined;
+        evidence_grounded?: boolean | undefined;
+        grounding?: {
+            status: "grounded" | "ungrounded" | "refuted";
+            reason?: string | undefined;
+        } | undefined;
+        executable_anchor?: {
+            command: string[];
+            confirm_if: {
+                kind: "exit_zero";
+            } | {
+                kind: "exit_nonzero";
+            } | {
+                kind: "output_includes";
+                text: string;
+            } | {
+                kind: "output_excludes";
+                text: string;
+            };
+            claim?: string | undefined;
+        } | undefined;
+        contract_goal_id?: string | undefined;
+        contract_obligation_ids?: string[] | undefined;
+        verification_obligation_ids?: string[] | undefined;
+        targeted_commands?: string[] | undefined;
+    }[] | undefined;
+    excluded_scope?: {
+        path: string;
+        reason: string;
+    }[] | undefined;
+}>;
+export type AuditFindingsReport = z.infer<typeof AuditFindingsReportSchema>;
+//# sourceMappingURL=finding.d.ts.map