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 FindingLocationObjectSchema: 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;
}>;
/**
 * THE one statement of each line-span rule (every draw, audit and remediate).
 * Exported so the dispatch prompt's contract block renders the very sentences
 * the schema enforces — {@link findingLocationLineIssues} emits these exact
 * strings, so wording cannot drift between the check and the prompt.
 */
export declare const FINDING_LINE_START_INTEGER_RULE = "affected_files[].line_start must be an integer >= 1.";
export declare const FINDING_LINE_END_INTEGER_RULE = "affected_files[].line_end must be an integer >= 1.";
export declare const FINDING_LINE_ORDER_RULE = "affected_files: when both ends are cited, line_start must be less than or equal to line_end.";
/** One violated line-span rule, naming the field that violates it. */
export interface FindingLocationLineIssue {
    field: "line_start" | "line_end";
    message: string;
}
/**
 * THE one evaluation of the line-span rules: when a location cites lines at
 * all, the span is 1-based integers with `line_start <= line_end`. Returns
 * every violated rule with its statement.
 *
 * Consumed by BOTH ingestion doors so neither can drift from the other: the
 * zod refinement ({@link refineFindingLocationLines}) turns these into schema
 * issues at parse time, and the downstream audit-results validator walks the
 * same function over its raw per-location records — the batch lane reaches
 * that validator WITHOUT a worker-projection parse, so the check has to live
 * there too, not only behind the parse.
 *
 * The fields stay `unknown`: callers hold everything from fully-parsed
 * locations to raw JSON payloads, and the guards below are exactly what makes
 * that honest.
 */
export declare function findingLocationLineIssues(location: {
    line_start?: unknown;
    line_end?: unknown;
}): readonly FindingLocationLineIssue[];
/**
 * Applies {@link findingLocationLineIssues} as a zod refinement. Exported so
 * every projection applies the SAME refinement — `.superRefine` wraps in
 * ZodEffects, which cannot be re-`extend`ed, so each projection composes
 * object + refinement itself rather than this file baking them together and
 * freezing the shape.
 */
export declare const refineFindingLocationLines: (location: z.infer<typeof FindingLocationObjectSchema>, context: z.RefinementCtx) => void;
export declare const FindingLocationSchema: z.ZodEffects<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;
}>, {
    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.ZodEffects<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;
    }>, {
        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>;
    /**
     * How far up the goal graph a fix for this finding ripples (conceptual
     * design-review spine, Phase A). Simultaneously PRIORITY (high blast = high
     * value — re-drawing a charter boundary beats a leaf fix) and a RISK gate (a
     * wrong high-blast finding is catastrophic → it must clear a higher adversarial
     * bar before it is actionable). An integer height over the goal DAG; absent on
     * findings with no goal-graph linkage (treated as 0 when ranking). Populated by
     * the conceptual pass (later phases); deterministic findings omit it.
     */
    blast_radius: z.ZodOptional<z.ZodNumber>;
    /**
     * 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">>;
    /**
     * Content-anchored identity of the analyzer lead this finding was born from
     * (item C). Copied verbatim from the injected lead by the auditing worker;
     * remediation's close-verify draw re-runs the analyzer and checks this exact
     * identity no longer fires. Absent on findings not born from analyzer leads.
     */
    analyzer_provenance: z.ZodOptional<z.ZodObject<{
        analyzer_id: z.ZodString;
        rule: z.ZodOptional<z.ZodString>;
        path: z.ZodString;
        snippet_hash: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        path: string;
        analyzer_id: string;
        snippet_hash: string;
        rule?: string | undefined;
    }, {
        path: string;
        analyzer_id: string;
        snippet_hash: string;
        rule?: string | undefined;
    }>>;
}, "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;
    blast_radius?: number | 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;
    analyzer_provenance?: {
        path: string;
        analyzer_id: string;
        snippet_hash: string;
        rule?: string | undefined;
    } | 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;
    blast_radius?: number | 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;
    analyzer_provenance?: {
        path: string;
        analyzer_id: string;
        snippet_hash: string;
        rule?: string | undefined;
    } | 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">;
    /** Implementation work, or a broad/systemic coordination obligation. */
    role: z.ZodEnum<["implementation", "coordination"]>;
    max_severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
    rationale: z.ZodString;
    depends_on: z.ZodArray<z.ZodString, "many">;
    /** Advisory deterministic content estimate; never a membership or fit claim. */
    token_estimate: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    id: string;
    unit_ids: string[];
    finding_ids: string[];
    owned_files: string[];
    role: "implementation" | "coordination";
    max_severity: "high" | "low" | "critical" | "medium" | "info";
    rationale: string;
    depends_on: string[];
    token_estimate?: number | undefined;
}, {
    id: string;
    unit_ids: string[];
    finding_ids: string[];
    owned_files: string[];
    role: "implementation" | "coordination";
    max_severity: "high" | "low" | "critical" | "medium" | "info";
    rationale: string;
    depends_on: string[];
    token_estimate?: number | undefined;
}>;
export type WorkBlock = z.infer<typeof WorkBlockSchema>;
/**
 * One CONTESTED FILE and every work block that owns it — a predicted write
 * conflict, which always requires a seam-first phase before those blocks may run
 * in parallel.
 *
 * The seam is keyed on the file rather than on a block PAIR: the conflict is a
 * property of the contested path, so N blocks over one file are one seam with N
 * `block_ids`, not N·(N−1)/2 records repeating it. `id` is derived from the file
 * (never positional) because `prepares_seam_ids` in the remediation contract
 * pipeline references it.
 */
export declare const WorkBlockSeamSchema: z.ZodEffects<z.ZodObject<{
    id: z.ZodString;
    /** The contested repo-relative path, forward-slashed. */
    file: z.ZodString;
    /**
     * Every block owning `file`: at least two DISTINCT ids, sorted. `.min(2)` is
     * load-bearing (it is what makes the record a conflict), so a repeated id
     * must not satisfy it.
     */
    block_ids: z.ZodArray<z.ZodString, "many">;
    kind: z.ZodEnum<["predicted_write_conflict", "systemic_coordination"]>;
    /**
     * A contested file IS a write conflict, so this is `true` by construction.
     * Stated as a literal rather than left to the producer: the remediation gate
     * and the phase cut both filter on `requires_preparation === true`, so a
     * seam that arrived `false` would be silently dropped rather than refused.
     */
    requires_preparation: z.ZodLiteral<true>;
    rationale: z.ZodString;
}, "strip", z.ZodTypeAny, {
    id: string;
    kind: "predicted_write_conflict" | "systemic_coordination";
    rationale: string;
    file: string;
    block_ids: string[];
    requires_preparation: true;
}, {
    id: string;
    kind: "predicted_write_conflict" | "systemic_coordination";
    rationale: string;
    file: string;
    block_ids: string[];
    requires_preparation: true;
}>, {
    id: string;
    kind: "predicted_write_conflict" | "systemic_coordination";
    rationale: string;
    file: string;
    block_ids: string[];
    requires_preparation: true;
}, {
    id: string;
    kind: "predicted_write_conflict" | "systemic_coordination";
    rationale: string;
    file: string;
    block_ids: string[];
    requires_preparation: true;
}>;
export type WorkBlockSeam = z.infer<typeof WorkBlockSeamSchema>;
/** 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 synthesis-narrative payload (Phase 6). Produced from one host
 * review of the deterministic findings and merged into `audit-findings.json`.
 * Omitted when no validated narrative result was supplied.
 */
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>>;
}, "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;
}, {
    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;
}>;
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 validated result.
 */
export declare const AuditFindingsReportSchema: z.ZodEffects<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>>;
    }, "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;
    }, {
        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;
    }>;
    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.ZodEffects<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;
        }>, {
            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>;
        /**
         * How far up the goal graph a fix for this finding ripples (conceptual
         * design-review spine, Phase A). Simultaneously PRIORITY (high blast = high
         * value — re-drawing a charter boundary beats a leaf fix) and a RISK gate (a
         * wrong high-blast finding is catastrophic → it must clear a higher adversarial
         * bar before it is actionable). An integer height over the goal DAG; absent on
         * findings with no goal-graph linkage (treated as 0 when ranking). Populated by
         * the conceptual pass (later phases); deterministic findings omit it.
         */
        blast_radius: z.ZodOptional<z.ZodNumber>;
        /**
         * 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">>;
        /**
         * Content-anchored identity of the analyzer lead this finding was born from
         * (item C). Copied verbatim from the injected lead by the auditing worker;
         * remediation's close-verify draw re-runs the analyzer and checks this exact
         * identity no longer fires. Absent on findings not born from analyzer leads.
         */
        analyzer_provenance: z.ZodOptional<z.ZodObject<{
            analyzer_id: z.ZodString;
            rule: z.ZodOptional<z.ZodString>;
            path: z.ZodString;
            snippet_hash: z.ZodString;
        }, "strict", z.ZodTypeAny, {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        }, {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        }>>;
    }, "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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | 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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }>, "many">;
    coherence_trace: z.ZodObject<{
        normalized_items: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            file_paths: z.ZodArray<z.ZodString, "many">;
            unit_ids: z.ZodArray<z.ZodString, "many">;
            tags: z.ZodArray<z.ZodString, "many">;
            critical_flow_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        }, "strict", z.ZodTypeAny, {
            id: string;
            file_paths: string[];
            unit_ids: string[];
            tags: string[];
            critical_flow_ids?: string[] | undefined;
        }, {
            id: string;
            file_paths: string[];
            unit_ids: string[];
            tags: string[];
            critical_flow_ids?: string[] | undefined;
        }>, "many">;
        components: z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">;
    }, "strict", z.ZodTypeAny, {
        normalized_items: {
            id: string;
            file_paths: string[];
            unit_ids: string[];
            tags: string[];
            critical_flow_ids?: string[] | undefined;
        }[];
        components: string[][];
    }, {
        normalized_items: {
            id: string;
            file_paths: string[];
            unit_ids: string[];
            tags: string[];
            critical_flow_ids?: string[] | undefined;
        }[];
        components: string[][];
    }>;
    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">;
        /** Implementation work, or a broad/systemic coordination obligation. */
        role: z.ZodEnum<["implementation", "coordination"]>;
        max_severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
        rationale: z.ZodString;
        depends_on: z.ZodArray<z.ZodString, "many">;
        /** Advisory deterministic content estimate; never a membership or fit claim. */
        token_estimate: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        unit_ids: string[];
        finding_ids: string[];
        owned_files: string[];
        role: "implementation" | "coordination";
        max_severity: "high" | "low" | "critical" | "medium" | "info";
        rationale: string;
        depends_on: string[];
        token_estimate?: number | undefined;
    }, {
        id: string;
        unit_ids: string[];
        finding_ids: string[];
        owned_files: string[];
        role: "implementation" | "coordination";
        max_severity: "high" | "low" | "critical" | "medium" | "info";
        rationale: string;
        depends_on: string[];
        token_estimate?: number | undefined;
    }>, "many">;
    work_block_seams: z.ZodArray<z.ZodEffects<z.ZodObject<{
        id: z.ZodString;
        /** The contested repo-relative path, forward-slashed. */
        file: z.ZodString;
        /**
         * Every block owning `file`: at least two DISTINCT ids, sorted. `.min(2)` is
         * load-bearing (it is what makes the record a conflict), so a repeated id
         * must not satisfy it.
         */
        block_ids: z.ZodArray<z.ZodString, "many">;
        kind: z.ZodEnum<["predicted_write_conflict", "systemic_coordination"]>;
        /**
         * A contested file IS a write conflict, so this is `true` by construction.
         * Stated as a literal rather than left to the producer: the remediation gate
         * and the phase cut both filter on `requires_preparation === true`, so a
         * seam that arrived `false` would be silently dropped rather than refused.
         */
        requires_preparation: z.ZodLiteral<true>;
        rationale: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        id: string;
        kind: "predicted_write_conflict" | "systemic_coordination";
        rationale: string;
        file: string;
        block_ids: string[];
        requires_preparation: true;
    }, {
        id: string;
        kind: "predicted_write_conflict" | "systemic_coordination";
        rationale: string;
        file: string;
        block_ids: string[];
        requires_preparation: true;
    }>, {
        id: string;
        kind: "predicted_write_conflict" | "systemic_coordination";
        rationale: string;
        file: string;
        block_ids: string[];
        requires_preparation: true;
    }, {
        id: string;
        kind: "predicted_write_conflict" | "systemic_coordination";
        rationale: string;
        file: string;
        block_ids: string[];
        requires_preparation: true;
    }>, "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.ZodEffects<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;
        }>, {
            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>;
        /**
         * How far up the goal graph a fix for this finding ripples (conceptual
         * design-review spine, Phase A). Simultaneously PRIORITY (high blast = high
         * value — re-drawing a charter boundary beats a leaf fix) and a RISK gate (a
         * wrong high-blast finding is catastrophic → it must clear a higher adversarial
         * bar before it is actionable). An integer height over the goal DAG; absent on
         * findings with no goal-graph linkage (treated as 0 when ranking). Populated by
         * the conceptual pass (later phases); deterministic findings omit it.
         */
        blast_radius: z.ZodOptional<z.ZodNumber>;
        /**
         * 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">>;
        /**
         * Content-anchored identity of the analyzer lead this finding was born from
         * (item C). Copied verbatim from the injected lead by the auditing worker;
         * remediation's close-verify draw re-runs the analyzer and checks this exact
         * identity no longer fires. Absent on findings not born from analyzer leads.
         */
        analyzer_provenance: z.ZodOptional<z.ZodObject<{
            analyzer_id: z.ZodString;
            rule: z.ZodOptional<z.ZodString>;
            path: z.ZodString;
            snippet_hash: z.ZodString;
        }, "strict", z.ZodTypeAny, {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        }, {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        }>>;
    }, "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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | 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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | 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, {
    contract_version: string;
    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;
    };
    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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }[];
    coherence_trace: {
        normalized_items: {
            id: string;
            file_paths: string[];
            unit_ids: string[];
            tags: string[];
            critical_flow_ids?: string[] | undefined;
        }[];
        components: string[][];
    };
    work_blocks: {
        id: string;
        unit_ids: string[];
        finding_ids: string[];
        owned_files: string[];
        role: "implementation" | "coordination";
        max_severity: "high" | "low" | "critical" | "medium" | "info";
        rationale: string;
        depends_on: string[];
        token_estimate?: number | undefined;
    }[];
    work_block_seams: {
        id: string;
        kind: "predicted_write_conflict" | "systemic_coordination";
        rationale: string;
        file: string;
        block_ids: string[];
        requires_preparation: true;
    }[];
    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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }[] | undefined;
    excluded_scope?: {
        path: string;
        reason: string;
    }[] | undefined;
}, {
    contract_version: string;
    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;
    };
    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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }[];
    coherence_trace: {
        normalized_items: {
            id: string;
            file_paths: string[];
            unit_ids: string[];
            tags: string[];
            critical_flow_ids?: string[] | undefined;
        }[];
        components: string[][];
    };
    work_blocks: {
        id: string;
        unit_ids: string[];
        finding_ids: string[];
        owned_files: string[];
        role: "implementation" | "coordination";
        max_severity: "high" | "low" | "critical" | "medium" | "info";
        rationale: string;
        depends_on: string[];
        token_estimate?: number | undefined;
    }[];
    work_block_seams: {
        id: string;
        kind: "predicted_write_conflict" | "systemic_coordination";
        rationale: string;
        file: string;
        block_ids: string[];
        requires_preparation: true;
    }[];
    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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }[] | undefined;
    excluded_scope?: {
        path: string;
        reason: string;
    }[] | undefined;
}>, {
    contract_version: string;
    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;
    };
    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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }[];
    coherence_trace: {
        normalized_items: {
            id: string;
            file_paths: string[];
            unit_ids: string[];
            tags: string[];
            critical_flow_ids?: string[] | undefined;
        }[];
        components: string[][];
    };
    work_blocks: {
        id: string;
        unit_ids: string[];
        finding_ids: string[];
        owned_files: string[];
        role: "implementation" | "coordination";
        max_severity: "high" | "low" | "critical" | "medium" | "info";
        rationale: string;
        depends_on: string[];
        token_estimate?: number | undefined;
    }[];
    work_block_seams: {
        id: string;
        kind: "predicted_write_conflict" | "systemic_coordination";
        rationale: string;
        file: string;
        block_ids: string[];
        requires_preparation: true;
    }[];
    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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }[] | undefined;
    excluded_scope?: {
        path: string;
        reason: string;
    }[] | undefined;
}, {
    contract_version: string;
    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;
    };
    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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }[];
    coherence_trace: {
        normalized_items: {
            id: string;
            file_paths: string[];
            unit_ids: string[];
            tags: string[];
            critical_flow_ids?: string[] | undefined;
        }[];
        components: string[][];
    };
    work_blocks: {
        id: string;
        unit_ids: string[];
        finding_ids: string[];
        owned_files: string[];
        role: "implementation" | "coordination";
        max_severity: "high" | "low" | "critical" | "medium" | "info";
        rationale: string;
        depends_on: string[];
        token_estimate?: number | undefined;
    }[];
    work_block_seams: {
        id: string;
        kind: "predicted_write_conflict" | "systemic_coordination";
        rationale: string;
        file: string;
        block_ids: string[];
        requires_preparation: true;
    }[];
    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;
        blast_radius?: number | 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;
        analyzer_provenance?: {
            path: string;
            analyzer_id: string;
            snippet_hash: string;
            rule?: string | undefined;
        } | undefined;
    }[] | undefined;
    excluded_scope?: {
        path: string;
        reason: string;
    }[] | undefined;
}>;
export type AuditFindingsReport = z.infer<typeof AuditFindingsReportSchema>;
//# sourceMappingURL=finding.d.ts.map