/**
 * Panel synthesis — independent lanes, deterministic script aggregation
 * (mmnto-ai/totem#2104, strategy#474 slice 5).
 *
 * A "panel" is N independent runs (lanes) of the same task over one immutable
 * grounding bundle, each emitting a #2100 {@link RunArtifact} plus its #2103
 * {@link PostCheckReport}. This module is the ENGINE: a pure, zero-LLM script
 * (Tenet 9) that aggregates the lanes — group findings by `ruleName`, tally
 * lane verdicts, surface divergence, and label vendor diversity HONESTLY — plus
 * content-addressed storage for the resulting {@link PanelArtifact}. It does NOT
 * run backends or dispatch lanes (the CLI runner is a deferred fast-follow), and
 * it emits NO panel-level gate: the panel is a SENSOR (a verdict *distribution*,
 * never a single accept/reject), leaving any gating policy to a later consumer.
 *
 * Diversity-labeling honesty is the load-bearing decision (strategy#474 / Prop
 * 291 / Tenet 19): cross-VENDOR convergence is the strong signal, NOT vote count.
 * The raw `providers[]` is always emitted lossless so a label can never overclaim
 * rigor, and an unrecognized provider string trips a fail-loud `coarse` marker
 * (see {@link classifyDiversity}).
 *
 * Schema-evolution policy mirrors {@link RunArtifactSchema} (F1): the reader is
 * version-tolerant within major 1; a major bump needs a migration entry before
 * the writer ships. Zod is the persisted-JSON boundary (read back from disk).
 */
import { z } from 'zod';
import type { PostCheckReport } from './post-checks.js';
import type { RunArtifact } from './schema.js';
/** The panel schemaVersion WRITTEN by this code. Readers accept any 1.x. */
export declare const PANEL_ARTIFACT_SCHEMA_VERSION = "1.0.0";
/** The major this reader understands; other majors need a migration entry. */
export declare const PANEL_ARTIFACT_KNOWN_MAJOR = 1;
/**
 * The two honest diversity labels.
 *
 * `same-vendor-isolated` means **context-isolation, NOT rater-independence**: the
 * lanes ran in isolated contexts but on one vendor family, so the panel's
 * `verdictDistribution` is **N correlated samples, not N independent votes**
 * (Prop 277 correlated-raters; strategy-claude PP2). A consumer must never read a
 * same-vendor split as independent agreement. `cross-vendor` means ≥2 distinct
 * provider families ran — the Tenet-19 strong-signal case — and is trustworthy
 * only when `diversityConfidence === 'verified'` (see {@link classifyDiversity}).
 */
export declare const PanelDiversityClassSchema: z.ZodEnum<["cross-vendor", "same-vendor-isolated"]>;
export type PanelDiversityClass = z.infer<typeof PanelDiversityClassSchema>;
/**
 * Honest vendor-diversity label for a panel. `providers[]` is ALWAYS present and
 * lossless (per-lane, canonical laneId order) so no derived field can overclaim.
 */
export declare const PanelDiversitySchema: z.ZodObject<{
    /** Per-lane provider strings, lossless, in canonical (laneId-sorted) order. */
    providers: z.ZodArray<z.ZodString, "many">;
    /** `new Set(providers).size` — a true cluster count ONLY while confidence is `verified`. */
    distinctProviders: z.ZodNumber;
    class: z.ZodEnum<["cross-vendor", "same-vendor-isolated"]>;
    /** Sorted unique providers outside {@link KNOWN_PROVIDER_FAMILIES} — the overclaim risk. */
    unrecognizedProviders: z.ZodArray<z.ZodString, "many">;
    /** `verified` when every provider's family is known; `coarse` otherwise (don't trust `cross-vendor`). */
    diversityConfidence: z.ZodEnum<["verified", "coarse"]>;
}, "strip", z.ZodTypeAny, {
    class: "cross-vendor" | "same-vendor-isolated";
    providers: string[];
    distinctProviders: number;
    unrecognizedProviders: string[];
    diversityConfidence: "verified" | "coarse";
}, {
    class: "cross-vendor" | "same-vendor-isolated";
    providers: string[];
    distinctProviders: number;
    unrecognizedProviders: string[];
    diversityConfidence: "verified" | "coarse";
}>;
export type PanelDiversity = z.infer<typeof PanelDiversitySchema>;
/**
 * One rule's outcome aggregated across all lanes. The dedup anchor is `ruleName`
 * (PostCheckFinding has no path:line anchor); `messages` are preserved VERBATIM
 * (Tenet 9 — no LLM rewrite) and sorted for determinism.
 */
export declare const SynthesisFindingSchema: z.ZodObject<{
    ruleName: z.ZodString;
    tier: z.ZodEnum<["decidable", "sensor"]>;
    /** Lane verdict tally; the three keys always sum to `lanes.length` (absent lanes count as `abstain`). */
    verdicts: z.ZodObject<{
        pass: z.ZodNumber;
        fail: z.ZodNumber;
        abstain: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        pass: number;
        fail: number;
        abstain: number;
    }, {
        pass: number;
        fail: number;
        abstain: number;
    }>;
    /** True IFF both `pass` and `fail` appear across lanes (`abstain` is neutral). */
    divergent: z.ZodBoolean;
    /** Verbatim lane messages (present lanes only), sorted. */
    messages: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    tier: "decidable" | "sensor";
    ruleName: string;
    verdicts: {
        pass: number;
        fail: number;
        abstain: number;
    };
    divergent: boolean;
    messages: string[];
}, {
    tier: "decidable" | "sensor";
    ruleName: string;
    verdicts: {
        pass: number;
        fail: number;
        abstain: number;
    };
    divergent: boolean;
    messages: string[];
}>;
export type SynthesisFinding = z.infer<typeof SynthesisFindingSchema>;
/**
 * The deterministic aggregation. SENSOR ONLY: a `verdictDistribution` tally (of
 * each lane's own `PostCheckReport.isRejected`) plus per-rule findings and a
 * divergence count — and deliberately NO panel-level `isRejected`/gate boolean.
 * A bare tally invites the vote-counting Tenet 19 forbids, so consumers must
 * lead with divergence + diversity; the tally is one subordinate raw signal.
 */
export declare const PanelSynthesisSchema: z.ZodObject<{
    /** Tally of lane outcomes: `isRejected===false ⟹ accepted`, `true ⟹ rejected`. Sums to lane count. */
    verdictDistribution: z.ZodObject<{
        accepted: z.ZodNumber;
        rejected: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        accepted: number;
        rejected: number;
    }, {
        accepted: number;
        rejected: number;
    }>;
    findings: z.ZodArray<z.ZodObject<{
        ruleName: z.ZodString;
        tier: z.ZodEnum<["decidable", "sensor"]>;
        /** Lane verdict tally; the three keys always sum to `lanes.length` (absent lanes count as `abstain`). */
        verdicts: z.ZodObject<{
            pass: z.ZodNumber;
            fail: z.ZodNumber;
            abstain: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            pass: number;
            fail: number;
            abstain: number;
        }, {
            pass: number;
            fail: number;
            abstain: number;
        }>;
        /** True IFF both `pass` and `fail` appear across lanes (`abstain` is neutral). */
        divergent: z.ZodBoolean;
        /** Verbatim lane messages (present lanes only), sorted. */
        messages: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        tier: "decidable" | "sensor";
        ruleName: string;
        verdicts: {
            pass: number;
            fail: number;
            abstain: number;
        };
        divergent: boolean;
        messages: string[];
    }, {
        tier: "decidable" | "sensor";
        ruleName: string;
        verdicts: {
            pass: number;
            fail: number;
            abstain: number;
        };
        divergent: boolean;
        messages: string[];
    }>, "many">;
    /** `=== findings.filter(f => f.divergent).length`. */
    divergences: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    findings: {
        tier: "decidable" | "sensor";
        ruleName: string;
        verdicts: {
            pass: number;
            fail: number;
            abstain: number;
        };
        divergent: boolean;
        messages: string[];
    }[];
    verdictDistribution: {
        accepted: number;
        rejected: number;
    };
    divergences: number;
}, {
    findings: {
        tier: "decidable" | "sensor";
        ruleName: string;
        verdicts: {
            pass: number;
            fail: number;
            abstain: number;
        };
        divergent: boolean;
        messages: string[];
    }[];
    verdictDistribution: {
        accepted: number;
        rejected: number;
    };
    divergences: number;
}>;
export type PanelSynthesis = z.infer<typeof PanelSynthesisSchema>;
/**
 * A persisted copy of a {@link PostCheckFinding}. slice-4's report is plain TS
 * (in-memory only); persisting the panel's audit inputs across the disk boundary
 * needs a Zod boundary (codex #1). `context` is OMITTED from the persisted copy:
 * it is rule-specific, unbounded, not JSON-safe by contract, and never load-bearing
 * for synthesis (which keys on `ruleName`) — "constrain JSON-safe or omit", omitted.
 */
export declare const PersistedPostCheckFindingSchema: z.ZodObject<{
    ruleName: z.ZodString;
    tier: z.ZodEnum<["decidable", "sensor"]>;
    verdict: z.ZodEnum<["pass", "fail", "abstain"]>;
    message: z.ZodString;
}, "strip", z.ZodTypeAny, {
    message: string;
    tier: "decidable" | "sensor";
    ruleName: string;
    verdict: "pass" | "fail" | "abstain";
}, {
    message: string;
    tier: "decidable" | "sensor";
    ruleName: string;
    verdict: "pass" | "fail" | "abstain";
}>;
export type PersistedPostCheckFinding = z.infer<typeof PersistedPostCheckFindingSchema>;
/**
 * A persisted copy of a {@link PostCheckReport}. The `isRejected` ADR-109
 * invariant is re-validated here at BOTH write and read (codex #1): a stored
 * report whose `isRejected` disagrees with its findings is a corrupt audit
 * record and must be rejected loud, never trusted.
 */
export declare const PersistedPostCheckReportSchema: z.ZodEffects<z.ZodObject<{
    findings: z.ZodArray<z.ZodObject<{
        ruleName: z.ZodString;
        tier: z.ZodEnum<["decidable", "sensor"]>;
        verdict: z.ZodEnum<["pass", "fail", "abstain"]>;
        message: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        message: string;
        tier: "decidable" | "sensor";
        ruleName: string;
        verdict: "pass" | "fail" | "abstain";
    }, {
        message: string;
        tier: "decidable" | "sensor";
        ruleName: string;
        verdict: "pass" | "fail" | "abstain";
    }>, "many">;
    isRejected: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    findings: {
        message: string;
        tier: "decidable" | "sensor";
        ruleName: string;
        verdict: "pass" | "fail" | "abstain";
    }[];
    isRejected: boolean;
}, {
    findings: {
        message: string;
        tier: "decidable" | "sensor";
        ruleName: string;
        verdict: "pass" | "fail" | "abstain";
    }[];
    isRejected: boolean;
}>, {
    findings: {
        message: string;
        tier: "decidable" | "sensor";
        ruleName: string;
        verdict: "pass" | "fail" | "abstain";
    }[];
    isRejected: boolean;
}, {
    findings: {
        message: string;
        tier: "decidable" | "sensor";
        ruleName: string;
        verdict: "pass" | "fail" | "abstain";
    }[];
    isRejected: boolean;
}>;
export type PersistedPostCheckReport = z.infer<typeof PersistedPostCheckReportSchema>;
/**
 * One persisted lane: its stable id, the #2100 run artifact, and the persisted
 * #2103 report. The full inputs are stored (not just the aggregate) so a panel
 * is re-auditable offline without re-running rules that may have since changed
 * (codex #1 — the same immutability principle behind RunArtifact).
 */
export declare const PanelLaneSchema: z.ZodObject<{
    laneId: z.ZodString;
    artifact: z.ZodObject<{
        schemaVersion: z.ZodEffects<z.ZodString, string, string>;
        inputBundle: z.ZodObject<{
            maskedPrompt: z.ZodString;
            maskedSystemPrompt: z.ZodOptional<z.ZodString>;
            diffScope: z.ZodOptional<z.ZodString>;
            specContract: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            maskedPrompt: string;
            maskedSystemPrompt?: string | undefined;
            diffScope?: string | undefined;
            specContract?: string | undefined;
        }, {
            maskedPrompt: string;
            maskedSystemPrompt?: string | undefined;
            diffScope?: string | undefined;
            specContract?: string | undefined;
        }>;
        inputHash: z.ZodString;
        grounding: z.ZodObject<{
            hash: z.ZodString;
            provenanceSummary: z.ZodString;
            bundle: z.ZodOptional<z.ZodObject<{
                items: z.ZodArray<z.ZodObject<{
                    provenance: z.ZodString;
                    contentHash: z.ZodString;
                    sourceType: z.ZodString;
                    filePath: z.ZodString;
                    sourceRepo: z.ZodOptional<z.ZodString>;
                    relevance: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }, {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                items: {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }[];
            }, {
                items: {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }[];
            }>>;
            anchor: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                kind: z.ZodEnum<["issue", "record", "free-text", "mixed"]>;
                ref: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                sha256: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            }, {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            }>, {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            }, {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            }>>;
            floor: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            hash: string;
            provenanceSummary: string;
            anchor?: {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            } | undefined;
            bundle?: {
                items: {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }[];
            } | undefined;
            floor?: number | undefined;
        }, {
            hash: string;
            provenanceSummary: string;
            anchor?: {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            } | undefined;
            bundle?: {
                items: {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }[];
            } | undefined;
            floor?: number | undefined;
        }>;
        backend: z.ZodObject<{
            provider: z.ZodString;
            model: z.ZodString;
            qualifiedModel: z.ZodString;
            admissionClass: z.ZodEnum<["completion_only", "self_grounding_agent"]>;
            taskProfile: z.ZodString;
            temperature: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            model: string;
            provider: string;
            qualifiedModel: string;
            admissionClass: "completion_only" | "self_grounding_agent";
            taskProfile: string;
            temperature?: number | undefined;
        }, {
            model: string;
            provider: string;
            qualifiedModel: string;
            admissionClass: "completion_only" | "self_grounding_agent";
            taskProfile: string;
            temperature?: number | undefined;
        }>;
        output: z.ZodObject<{
            content: z.ZodString;
            metrics: z.ZodObject<{
                inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                durationMs: z.ZodNumber;
                finishReason: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                durationMs: number;
                inputTokens?: number | null | undefined;
                outputTokens?: number | null | undefined;
                cacheReadInputTokens?: number | null | undefined;
                finishReason?: string | undefined;
            }, {
                durationMs: number;
                inputTokens?: number | null | undefined;
                outputTokens?: number | null | undefined;
                cacheReadInputTokens?: number | null | undefined;
                finishReason?: string | undefined;
            }>;
            execution: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                attempts: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodObject<{
                    sequence: z.ZodNumber;
                    route: z.ZodEnum<["sdk", "cli-fallback", "configured-shell", "quota-model-fallback"]>;
                    provider: z.ZodString;
                    model: z.ZodString;
                    status: z.ZodEnum<["succeeded", "failed"]>;
                    durationMs: z.ZodNumber;
                    failureKind: z.ZodOptional<z.ZodEnum<["auth", "quota", "model", "process-spawn", "process-exit", "timeout", "unknown"]>>;
                    providerStatus: z.ZodOptional<z.ZodNumber>;
                    providerCode: z.ZodOptional<z.ZodString>;
                    process: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                        exitCode: z.ZodNullable<z.ZodNumber>;
                        signal: z.ZodNullable<z.ZodString>;
                        timedOut: z.ZodBoolean;
                        timeoutMs: z.ZodOptional<z.ZodNumber>;
                        stdout: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                            encoding: z.ZodLiteral<"utf-8">;
                            head: z.ZodString;
                            tail: z.ZodOptional<z.ZodString>;
                            observedBytes: z.ZodNumber;
                            retainedBytes: z.ZodNumber;
                            limitBytes: z.ZodNumber;
                            truncated: z.ZodBoolean;
                            dlp: z.ZodEnum<["masked", "omitted-on-mask-failure"]>;
                        }, "strip", z.ZodTypeAny, {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        }, {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        }>, {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        }, {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        }>>;
                        stderr: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                            encoding: z.ZodLiteral<"utf-8">;
                            head: z.ZodString;
                            tail: z.ZodOptional<z.ZodString>;
                            observedBytes: z.ZodNumber;
                            retainedBytes: z.ZodNumber;
                            limitBytes: z.ZodNumber;
                            truncated: z.ZodBoolean;
                            dlp: z.ZodEnum<["masked", "omitted-on-mask-failure"]>;
                        }, "strip", z.ZodTypeAny, {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        }, {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        }>, {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        }, {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    }, {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    }>, {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    }, {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }, {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }>, {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }, {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }>, "many">, {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[], {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[]>;
            }, "strip", z.ZodTypeAny, {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            }, {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            }>, {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            }, {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            }>>;
        }, "strip", z.ZodTypeAny, {
            content: string;
            metrics: {
                durationMs: number;
                inputTokens?: number | null | undefined;
                outputTokens?: number | null | undefined;
                cacheReadInputTokens?: number | null | undefined;
                finishReason?: string | undefined;
            };
            execution?: {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            } | undefined;
        }, {
            content: string;
            metrics: {
                durationMs: number;
                inputTokens?: number | null | undefined;
                outputTokens?: number | null | undefined;
                cacheReadInputTokens?: number | null | undefined;
                finishReason?: string | undefined;
            };
            execution?: {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            } | undefined;
        }>;
        admission: z.ZodOptional<z.ZodObject<{
            outputContract: z.ZodOptional<z.ZodObject<{
                citationsRequired: z.ZodOptional<z.ZodBoolean>;
                verifyFallback: z.ZodOptional<z.ZodBoolean>;
                schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                citationsRequired?: boolean | undefined;
                verifyFallback?: boolean | undefined;
                schema?: Record<string, unknown> | undefined;
            }, {
                citationsRequired?: boolean | undefined;
                verifyFallback?: boolean | undefined;
                schema?: Record<string, unknown> | undefined;
            }>>;
            contextPolicy: z.ZodOptional<z.ZodObject<{
                budget: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                budget?: number | undefined;
            }, {
                budget?: number | undefined;
            }>>;
            runMetadata: z.ZodOptional<z.ZodObject<{
                caller: z.ZodOptional<z.ZodString>;
                command: z.ZodOptional<z.ZodString>;
                codeBlind: z.ZodOptional<z.ZodBoolean>;
                promptSource: z.ZodOptional<z.ZodEnum<["builtin", "override"]>>;
            }, "strip", z.ZodTypeAny, {
                caller?: string | undefined;
                command?: string | undefined;
                codeBlind?: boolean | undefined;
                promptSource?: "builtin" | "override" | undefined;
            }, {
                caller?: string | undefined;
                command?: string | undefined;
                codeBlind?: boolean | undefined;
                promptSource?: "builtin" | "override" | undefined;
            }>>;
        }, "strip", z.ZodTypeAny, {
            outputContract?: {
                citationsRequired?: boolean | undefined;
                verifyFallback?: boolean | undefined;
                schema?: Record<string, unknown> | undefined;
            } | undefined;
            contextPolicy?: {
                budget?: number | undefined;
            } | undefined;
            runMetadata?: {
                caller?: string | undefined;
                command?: string | undefined;
                codeBlind?: boolean | undefined;
                promptSource?: "builtin" | "override" | undefined;
            } | undefined;
        }, {
            outputContract?: {
                citationsRequired?: boolean | undefined;
                verifyFallback?: boolean | undefined;
                schema?: Record<string, unknown> | undefined;
            } | undefined;
            contextPolicy?: {
                budget?: number | undefined;
            } | undefined;
            runMetadata?: {
                caller?: string | undefined;
                command?: string | undefined;
                codeBlind?: boolean | undefined;
                promptSource?: "builtin" | "override" | undefined;
            } | undefined;
        }>>;
        createdAt: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        createdAt: string;
        schemaVersion: string;
        inputBundle: {
            maskedPrompt: string;
            maskedSystemPrompt?: string | undefined;
            diffScope?: string | undefined;
            specContract?: string | undefined;
        };
        inputHash: string;
        grounding: {
            hash: string;
            provenanceSummary: string;
            anchor?: {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            } | undefined;
            bundle?: {
                items: {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }[];
            } | undefined;
            floor?: number | undefined;
        };
        backend: {
            model: string;
            provider: string;
            qualifiedModel: string;
            admissionClass: "completion_only" | "self_grounding_agent";
            taskProfile: string;
            temperature?: number | undefined;
        };
        output: {
            content: string;
            metrics: {
                durationMs: number;
                inputTokens?: number | null | undefined;
                outputTokens?: number | null | undefined;
                cacheReadInputTokens?: number | null | undefined;
                finishReason?: string | undefined;
            };
            execution?: {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            } | undefined;
        };
        admission?: {
            outputContract?: {
                citationsRequired?: boolean | undefined;
                verifyFallback?: boolean | undefined;
                schema?: Record<string, unknown> | undefined;
            } | undefined;
            contextPolicy?: {
                budget?: number | undefined;
            } | undefined;
            runMetadata?: {
                caller?: string | undefined;
                command?: string | undefined;
                codeBlind?: boolean | undefined;
                promptSource?: "builtin" | "override" | undefined;
            } | undefined;
        } | undefined;
    }, {
        createdAt: string;
        schemaVersion: string;
        inputBundle: {
            maskedPrompt: string;
            maskedSystemPrompt?: string | undefined;
            diffScope?: string | undefined;
            specContract?: string | undefined;
        };
        inputHash: string;
        grounding: {
            hash: string;
            provenanceSummary: string;
            anchor?: {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            } | undefined;
            bundle?: {
                items: {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }[];
            } | undefined;
            floor?: number | undefined;
        };
        backend: {
            model: string;
            provider: string;
            qualifiedModel: string;
            admissionClass: "completion_only" | "self_grounding_agent";
            taskProfile: string;
            temperature?: number | undefined;
        };
        output: {
            content: string;
            metrics: {
                durationMs: number;
                inputTokens?: number | null | undefined;
                outputTokens?: number | null | undefined;
                cacheReadInputTokens?: number | null | undefined;
                finishReason?: string | undefined;
            };
            execution?: {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            } | undefined;
        };
        admission?: {
            outputContract?: {
                citationsRequired?: boolean | undefined;
                verifyFallback?: boolean | undefined;
                schema?: Record<string, unknown> | undefined;
            } | undefined;
            contextPolicy?: {
                budget?: number | undefined;
            } | undefined;
            runMetadata?: {
                caller?: string | undefined;
                command?: string | undefined;
                codeBlind?: boolean | undefined;
                promptSource?: "builtin" | "override" | undefined;
            } | undefined;
        } | undefined;
    }>;
    report: z.ZodEffects<z.ZodObject<{
        findings: z.ZodArray<z.ZodObject<{
            ruleName: z.ZodString;
            tier: z.ZodEnum<["decidable", "sensor"]>;
            verdict: z.ZodEnum<["pass", "fail", "abstain"]>;
            message: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            message: string;
            tier: "decidable" | "sensor";
            ruleName: string;
            verdict: "pass" | "fail" | "abstain";
        }, {
            message: string;
            tier: "decidable" | "sensor";
            ruleName: string;
            verdict: "pass" | "fail" | "abstain";
        }>, "many">;
        isRejected: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        findings: {
            message: string;
            tier: "decidable" | "sensor";
            ruleName: string;
            verdict: "pass" | "fail" | "abstain";
        }[];
        isRejected: boolean;
    }, {
        findings: {
            message: string;
            tier: "decidable" | "sensor";
            ruleName: string;
            verdict: "pass" | "fail" | "abstain";
        }[];
        isRejected: boolean;
    }>, {
        findings: {
            message: string;
            tier: "decidable" | "sensor";
            ruleName: string;
            verdict: "pass" | "fail" | "abstain";
        }[];
        isRejected: boolean;
    }, {
        findings: {
            message: string;
            tier: "decidable" | "sensor";
            ruleName: string;
            verdict: "pass" | "fail" | "abstain";
        }[];
        isRejected: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    laneId: string;
    artifact: {
        createdAt: string;
        schemaVersion: string;
        inputBundle: {
            maskedPrompt: string;
            maskedSystemPrompt?: string | undefined;
            diffScope?: string | undefined;
            specContract?: string | undefined;
        };
        inputHash: string;
        grounding: {
            hash: string;
            provenanceSummary: string;
            anchor?: {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            } | undefined;
            bundle?: {
                items: {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }[];
            } | undefined;
            floor?: number | undefined;
        };
        backend: {
            model: string;
            provider: string;
            qualifiedModel: string;
            admissionClass: "completion_only" | "self_grounding_agent";
            taskProfile: string;
            temperature?: number | undefined;
        };
        output: {
            content: string;
            metrics: {
                durationMs: number;
                inputTokens?: number | null | undefined;
                outputTokens?: number | null | undefined;
                cacheReadInputTokens?: number | null | undefined;
                finishReason?: string | undefined;
            };
            execution?: {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            } | undefined;
        };
        admission?: {
            outputContract?: {
                citationsRequired?: boolean | undefined;
                verifyFallback?: boolean | undefined;
                schema?: Record<string, unknown> | undefined;
            } | undefined;
            contextPolicy?: {
                budget?: number | undefined;
            } | undefined;
            runMetadata?: {
                caller?: string | undefined;
                command?: string | undefined;
                codeBlind?: boolean | undefined;
                promptSource?: "builtin" | "override" | undefined;
            } | undefined;
        } | undefined;
    };
    report: {
        findings: {
            message: string;
            tier: "decidable" | "sensor";
            ruleName: string;
            verdict: "pass" | "fail" | "abstain";
        }[];
        isRejected: boolean;
    };
}, {
    laneId: string;
    artifact: {
        createdAt: string;
        schemaVersion: string;
        inputBundle: {
            maskedPrompt: string;
            maskedSystemPrompt?: string | undefined;
            diffScope?: string | undefined;
            specContract?: string | undefined;
        };
        inputHash: string;
        grounding: {
            hash: string;
            provenanceSummary: string;
            anchor?: {
                kind: "record" | "issue" | "free-text" | "mixed";
                ref: string;
                sha256?: string | undefined;
            } | undefined;
            bundle?: {
                items: {
                    filePath: string;
                    contentHash: string;
                    provenance: string;
                    sourceType: string;
                    sourceRepo?: string | undefined;
                    relevance?: number | undefined;
                }[];
            } | undefined;
            floor?: number | undefined;
        };
        backend: {
            model: string;
            provider: string;
            qualifiedModel: string;
            admissionClass: "completion_only" | "self_grounding_agent";
            taskProfile: string;
            temperature?: number | undefined;
        };
        output: {
            content: string;
            metrics: {
                durationMs: number;
                inputTokens?: number | null | undefined;
                outputTokens?: number | null | undefined;
                cacheReadInputTokens?: number | null | undefined;
                finishReason?: string | undefined;
            };
            execution?: {
                attempts: {
                    status: "succeeded" | "failed";
                    model: string;
                    provider: string;
                    sequence: number;
                    route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                    durationMs: number;
                    failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                    providerStatus?: number | undefined;
                    providerCode?: string | undefined;
                    process?: {
                        exitCode: number | null;
                        signal: string | null;
                        timedOut: boolean;
                        stdout?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                        timeoutMs?: number | undefined;
                        stderr?: {
                            encoding: "utf-8";
                            head: string;
                            observedBytes: number;
                            retainedBytes: number;
                            limitBytes: number;
                            truncated: boolean;
                            dlp: "masked" | "omitted-on-mask-failure";
                            tail?: string | undefined;
                        } | undefined;
                    } | undefined;
                }[];
            } | undefined;
        };
        admission?: {
            outputContract?: {
                citationsRequired?: boolean | undefined;
                verifyFallback?: boolean | undefined;
                schema?: Record<string, unknown> | undefined;
            } | undefined;
            contextPolicy?: {
                budget?: number | undefined;
            } | undefined;
            runMetadata?: {
                caller?: string | undefined;
                command?: string | undefined;
                codeBlind?: boolean | undefined;
                promptSource?: "builtin" | "override" | undefined;
            } | undefined;
        } | undefined;
    };
    report: {
        findings: {
            message: string;
            tier: "decidable" | "sensor";
            ruleName: string;
            verdict: "pass" | "fail" | "abstain";
        }[];
        isRejected: boolean;
    };
}>;
export type PanelLane = z.infer<typeof PanelLaneSchema>;
export declare const PanelArtifactSchema: z.ZodEffects<z.ZodObject<{
    schemaVersion: z.ZodString;
    /** Persisted lanes, canonical laneId order. At least one — a zero-lane panel is structurally meaningless. */
    lanes: z.ZodArray<z.ZodObject<{
        laneId: z.ZodString;
        artifact: z.ZodObject<{
            schemaVersion: z.ZodEffects<z.ZodString, string, string>;
            inputBundle: z.ZodObject<{
                maskedPrompt: z.ZodString;
                maskedSystemPrompt: z.ZodOptional<z.ZodString>;
                diffScope: z.ZodOptional<z.ZodString>;
                specContract: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            }, {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            }>;
            inputHash: z.ZodString;
            grounding: z.ZodObject<{
                hash: z.ZodString;
                provenanceSummary: z.ZodString;
                bundle: z.ZodOptional<z.ZodObject<{
                    items: z.ZodArray<z.ZodObject<{
                        provenance: z.ZodString;
                        contentHash: z.ZodString;
                        sourceType: z.ZodString;
                        filePath: z.ZodString;
                        sourceRepo: z.ZodOptional<z.ZodString>;
                        relevance: z.ZodOptional<z.ZodNumber>;
                    }, "strip", z.ZodTypeAny, {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }, {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                }, {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                }>>;
                anchor: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                    kind: z.ZodEnum<["issue", "record", "free-text", "mixed"]>;
                    ref: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                    sha256: z.ZodOptional<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                }, {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                }>, {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                }, {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                }>>;
                floor: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            }, {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            }>;
            backend: z.ZodObject<{
                provider: z.ZodString;
                model: z.ZodString;
                qualifiedModel: z.ZodString;
                admissionClass: z.ZodEnum<["completion_only", "self_grounding_agent"]>;
                taskProfile: z.ZodString;
                temperature: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            }, {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            }>;
            output: z.ZodObject<{
                content: z.ZodString;
                metrics: z.ZodObject<{
                    inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                    outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                    cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                    durationMs: z.ZodNumber;
                    finishReason: z.ZodOptional<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                }, {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                }>;
                execution: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                    attempts: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodObject<{
                        sequence: z.ZodNumber;
                        route: z.ZodEnum<["sdk", "cli-fallback", "configured-shell", "quota-model-fallback"]>;
                        provider: z.ZodString;
                        model: z.ZodString;
                        status: z.ZodEnum<["succeeded", "failed"]>;
                        durationMs: z.ZodNumber;
                        failureKind: z.ZodOptional<z.ZodEnum<["auth", "quota", "model", "process-spawn", "process-exit", "timeout", "unknown"]>>;
                        providerStatus: z.ZodOptional<z.ZodNumber>;
                        providerCode: z.ZodOptional<z.ZodString>;
                        process: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                            exitCode: z.ZodNullable<z.ZodNumber>;
                            signal: z.ZodNullable<z.ZodString>;
                            timedOut: z.ZodBoolean;
                            timeoutMs: z.ZodOptional<z.ZodNumber>;
                            stdout: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                                encoding: z.ZodLiteral<"utf-8">;
                                head: z.ZodString;
                                tail: z.ZodOptional<z.ZodString>;
                                observedBytes: z.ZodNumber;
                                retainedBytes: z.ZodNumber;
                                limitBytes: z.ZodNumber;
                                truncated: z.ZodBoolean;
                                dlp: z.ZodEnum<["masked", "omitted-on-mask-failure"]>;
                            }, "strip", z.ZodTypeAny, {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            }, {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            }>, {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            }, {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            }>>;
                            stderr: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                                encoding: z.ZodLiteral<"utf-8">;
                                head: z.ZodString;
                                tail: z.ZodOptional<z.ZodString>;
                                observedBytes: z.ZodNumber;
                                retainedBytes: z.ZodNumber;
                                limitBytes: z.ZodNumber;
                                truncated: z.ZodBoolean;
                                dlp: z.ZodEnum<["masked", "omitted-on-mask-failure"]>;
                            }, "strip", z.ZodTypeAny, {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            }, {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            }>, {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            }, {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            }>>;
                        }, "strip", z.ZodTypeAny, {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        }, {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        }>, {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        }, {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }, {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }>, {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }, {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }>, "many">, {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[], {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[]>;
                }, "strip", z.ZodTypeAny, {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                }, {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                }>, {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                }, {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                }>>;
            }, "strip", z.ZodTypeAny, {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            }, {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            }>;
            admission: z.ZodOptional<z.ZodObject<{
                outputContract: z.ZodOptional<z.ZodObject<{
                    citationsRequired: z.ZodOptional<z.ZodBoolean>;
                    verifyFallback: z.ZodOptional<z.ZodBoolean>;
                    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                }, "strip", z.ZodTypeAny, {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                }, {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                }>>;
                contextPolicy: z.ZodOptional<z.ZodObject<{
                    budget: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    budget?: number | undefined;
                }, {
                    budget?: number | undefined;
                }>>;
                runMetadata: z.ZodOptional<z.ZodObject<{
                    caller: z.ZodOptional<z.ZodString>;
                    command: z.ZodOptional<z.ZodString>;
                    codeBlind: z.ZodOptional<z.ZodBoolean>;
                    promptSource: z.ZodOptional<z.ZodEnum<["builtin", "override"]>>;
                }, "strip", z.ZodTypeAny, {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                }, {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                }>>;
            }, "strip", z.ZodTypeAny, {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            }, {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            }>>;
            createdAt: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            createdAt: string;
            schemaVersion: string;
            inputBundle: {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            };
            inputHash: string;
            grounding: {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            };
            backend: {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            };
            output: {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            };
            admission?: {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            } | undefined;
        }, {
            createdAt: string;
            schemaVersion: string;
            inputBundle: {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            };
            inputHash: string;
            grounding: {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            };
            backend: {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            };
            output: {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            };
            admission?: {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            } | undefined;
        }>;
        report: z.ZodEffects<z.ZodObject<{
            findings: z.ZodArray<z.ZodObject<{
                ruleName: z.ZodString;
                tier: z.ZodEnum<["decidable", "sensor"]>;
                verdict: z.ZodEnum<["pass", "fail", "abstain"]>;
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }, {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }>, "many">;
            isRejected: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        }, {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        }>, {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        }, {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        }>;
    }, "strip", z.ZodTypeAny, {
        laneId: string;
        artifact: {
            createdAt: string;
            schemaVersion: string;
            inputBundle: {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            };
            inputHash: string;
            grounding: {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            };
            backend: {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            };
            output: {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            };
            admission?: {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            } | undefined;
        };
        report: {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        };
    }, {
        laneId: string;
        artifact: {
            createdAt: string;
            schemaVersion: string;
            inputBundle: {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            };
            inputHash: string;
            grounding: {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            };
            backend: {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            };
            output: {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            };
            admission?: {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            } | undefined;
        };
        report: {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        };
    }>, "many">;
    diversity: z.ZodObject<{
        /** Per-lane provider strings, lossless, in canonical (laneId-sorted) order. */
        providers: z.ZodArray<z.ZodString, "many">;
        /** `new Set(providers).size` — a true cluster count ONLY while confidence is `verified`. */
        distinctProviders: z.ZodNumber;
        class: z.ZodEnum<["cross-vendor", "same-vendor-isolated"]>;
        /** Sorted unique providers outside {@link KNOWN_PROVIDER_FAMILIES} — the overclaim risk. */
        unrecognizedProviders: z.ZodArray<z.ZodString, "many">;
        /** `verified` when every provider's family is known; `coarse` otherwise (don't trust `cross-vendor`). */
        diversityConfidence: z.ZodEnum<["verified", "coarse"]>;
    }, "strip", z.ZodTypeAny, {
        class: "cross-vendor" | "same-vendor-isolated";
        providers: string[];
        distinctProviders: number;
        unrecognizedProviders: string[];
        diversityConfidence: "verified" | "coarse";
    }, {
        class: "cross-vendor" | "same-vendor-isolated";
        providers: string[];
        distinctProviders: number;
        unrecognizedProviders: string[];
        diversityConfidence: "verified" | "coarse";
    }>;
    synthesis: z.ZodObject<{
        /** Tally of lane outcomes: `isRejected===false ⟹ accepted`, `true ⟹ rejected`. Sums to lane count. */
        verdictDistribution: z.ZodObject<{
            accepted: z.ZodNumber;
            rejected: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            accepted: number;
            rejected: number;
        }, {
            accepted: number;
            rejected: number;
        }>;
        findings: z.ZodArray<z.ZodObject<{
            ruleName: z.ZodString;
            tier: z.ZodEnum<["decidable", "sensor"]>;
            /** Lane verdict tally; the three keys always sum to `lanes.length` (absent lanes count as `abstain`). */
            verdicts: z.ZodObject<{
                pass: z.ZodNumber;
                fail: z.ZodNumber;
                abstain: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                pass: number;
                fail: number;
                abstain: number;
            }, {
                pass: number;
                fail: number;
                abstain: number;
            }>;
            /** True IFF both `pass` and `fail` appear across lanes (`abstain` is neutral). */
            divergent: z.ZodBoolean;
            /** Verbatim lane messages (present lanes only), sorted. */
            messages: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            tier: "decidable" | "sensor";
            ruleName: string;
            verdicts: {
                pass: number;
                fail: number;
                abstain: number;
            };
            divergent: boolean;
            messages: string[];
        }, {
            tier: "decidable" | "sensor";
            ruleName: string;
            verdicts: {
                pass: number;
                fail: number;
                abstain: number;
            };
            divergent: boolean;
            messages: string[];
        }>, "many">;
        /** `=== findings.filter(f => f.divergent).length`. */
        divergences: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        findings: {
            tier: "decidable" | "sensor";
            ruleName: string;
            verdicts: {
                pass: number;
                fail: number;
                abstain: number;
            };
            divergent: boolean;
            messages: string[];
        }[];
        verdictDistribution: {
            accepted: number;
            rejected: number;
        };
        divergences: number;
    }, {
        findings: {
            tier: "decidable" | "sensor";
            ruleName: string;
            verdicts: {
                pass: number;
                fail: number;
                abstain: number;
            };
            divergent: boolean;
            messages: string[];
        }[];
        verdictDistribution: {
            accepted: number;
            rejected: number;
        };
        divergences: number;
    }>;
    /**
     * ISO-8601 emission time. EXCLUDED from the content address (identical panels
     * dedup regardless of when they ran) — observability only.
     */
    createdAt: z.ZodString;
}, "strip", z.ZodTypeAny, {
    createdAt: string;
    schemaVersion: string;
    lanes: {
        laneId: string;
        artifact: {
            createdAt: string;
            schemaVersion: string;
            inputBundle: {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            };
            inputHash: string;
            grounding: {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            };
            backend: {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            };
            output: {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            };
            admission?: {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            } | undefined;
        };
        report: {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        };
    }[];
    diversity: {
        class: "cross-vendor" | "same-vendor-isolated";
        providers: string[];
        distinctProviders: number;
        unrecognizedProviders: string[];
        diversityConfidence: "verified" | "coarse";
    };
    synthesis: {
        findings: {
            tier: "decidable" | "sensor";
            ruleName: string;
            verdicts: {
                pass: number;
                fail: number;
                abstain: number;
            };
            divergent: boolean;
            messages: string[];
        }[];
        verdictDistribution: {
            accepted: number;
            rejected: number;
        };
        divergences: number;
    };
}, {
    createdAt: string;
    schemaVersion: string;
    lanes: {
        laneId: string;
        artifact: {
            createdAt: string;
            schemaVersion: string;
            inputBundle: {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            };
            inputHash: string;
            grounding: {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            };
            backend: {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            };
            output: {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            };
            admission?: {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            } | undefined;
        };
        report: {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        };
    }[];
    diversity: {
        class: "cross-vendor" | "same-vendor-isolated";
        providers: string[];
        distinctProviders: number;
        unrecognizedProviders: string[];
        diversityConfidence: "verified" | "coarse";
    };
    synthesis: {
        findings: {
            tier: "decidable" | "sensor";
            ruleName: string;
            verdicts: {
                pass: number;
                fail: number;
                abstain: number;
            };
            divergent: boolean;
            messages: string[];
        }[];
        verdictDistribution: {
            accepted: number;
            rejected: number;
        };
        divergences: number;
    };
}>, {
    createdAt: string;
    schemaVersion: string;
    lanes: {
        laneId: string;
        artifact: {
            createdAt: string;
            schemaVersion: string;
            inputBundle: {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            };
            inputHash: string;
            grounding: {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            };
            backend: {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            };
            output: {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            };
            admission?: {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            } | undefined;
        };
        report: {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        };
    }[];
    diversity: {
        class: "cross-vendor" | "same-vendor-isolated";
        providers: string[];
        distinctProviders: number;
        unrecognizedProviders: string[];
        diversityConfidence: "verified" | "coarse";
    };
    synthesis: {
        findings: {
            tier: "decidable" | "sensor";
            ruleName: string;
            verdicts: {
                pass: number;
                fail: number;
                abstain: number;
            };
            divergent: boolean;
            messages: string[];
        }[];
        verdictDistribution: {
            accepted: number;
            rejected: number;
        };
        divergences: number;
    };
}, {
    createdAt: string;
    schemaVersion: string;
    lanes: {
        laneId: string;
        artifact: {
            createdAt: string;
            schemaVersion: string;
            inputBundle: {
                maskedPrompt: string;
                maskedSystemPrompt?: string | undefined;
                diffScope?: string | undefined;
                specContract?: string | undefined;
            };
            inputHash: string;
            grounding: {
                hash: string;
                provenanceSummary: string;
                anchor?: {
                    kind: "record" | "issue" | "free-text" | "mixed";
                    ref: string;
                    sha256?: string | undefined;
                } | undefined;
                bundle?: {
                    items: {
                        filePath: string;
                        contentHash: string;
                        provenance: string;
                        sourceType: string;
                        sourceRepo?: string | undefined;
                        relevance?: number | undefined;
                    }[];
                } | undefined;
                floor?: number | undefined;
            };
            backend: {
                model: string;
                provider: string;
                qualifiedModel: string;
                admissionClass: "completion_only" | "self_grounding_agent";
                taskProfile: string;
                temperature?: number | undefined;
            };
            output: {
                content: string;
                metrics: {
                    durationMs: number;
                    inputTokens?: number | null | undefined;
                    outputTokens?: number | null | undefined;
                    cacheReadInputTokens?: number | null | undefined;
                    finishReason?: string | undefined;
                };
                execution?: {
                    attempts: {
                        status: "succeeded" | "failed";
                        model: string;
                        provider: string;
                        sequence: number;
                        route: "sdk" | "cli-fallback" | "configured-shell" | "quota-model-fallback";
                        durationMs: number;
                        failureKind?: "unknown" | "auth" | "quota" | "model" | "process-spawn" | "process-exit" | "timeout" | undefined;
                        providerStatus?: number | undefined;
                        providerCode?: string | undefined;
                        process?: {
                            exitCode: number | null;
                            signal: string | null;
                            timedOut: boolean;
                            stdout?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                            timeoutMs?: number | undefined;
                            stderr?: {
                                encoding: "utf-8";
                                head: string;
                                observedBytes: number;
                                retainedBytes: number;
                                limitBytes: number;
                                truncated: boolean;
                                dlp: "masked" | "omitted-on-mask-failure";
                                tail?: string | undefined;
                            } | undefined;
                        } | undefined;
                    }[];
                } | undefined;
            };
            admission?: {
                outputContract?: {
                    citationsRequired?: boolean | undefined;
                    verifyFallback?: boolean | undefined;
                    schema?: Record<string, unknown> | undefined;
                } | undefined;
                contextPolicy?: {
                    budget?: number | undefined;
                } | undefined;
                runMetadata?: {
                    caller?: string | undefined;
                    command?: string | undefined;
                    codeBlind?: boolean | undefined;
                    promptSource?: "builtin" | "override" | undefined;
                } | undefined;
            } | undefined;
        };
        report: {
            findings: {
                message: string;
                tier: "decidable" | "sensor";
                ruleName: string;
                verdict: "pass" | "fail" | "abstain";
            }[];
            isRejected: boolean;
        };
    }[];
    diversity: {
        class: "cross-vendor" | "same-vendor-isolated";
        providers: string[];
        distinctProviders: number;
        unrecognizedProviders: string[];
        diversityConfidence: "verified" | "coarse";
    };
    synthesis: {
        findings: {
            tier: "decidable" | "sensor";
            ruleName: string;
            verdicts: {
                pass: number;
                fail: number;
                abstain: number;
            };
            divergent: boolean;
            messages: string[];
        }[];
        verdictDistribution: {
            accepted: number;
            rejected: number;
        };
        divergences: number;
    };
}>;
export type PanelArtifact = z.infer<typeof PanelArtifactSchema>;
/**
 * In-memory lane input to the pure aggregators: a stable `laneId`, the run
 * artifact, and slice-4's live {@link PostCheckReport}. The caller (a future CLI
 * runner) computes the report via `evaluatePostChecks`; this engine stays pure
 * over the precomputed pairs.
 */
export interface PanelLaneInput {
    laneId: string;
    artifact: RunArtifact;
    report: PostCheckReport;
}
/**
 * Label the vendor diversity of a panel from its per-lane provider strings.
 * Pure. The `class` is the mechanical reading of `distinctProviders`; the
 * `diversityConfidence` marker is whether that reading is trustworthy — `coarse`
 * means an unrecognized provider string is present, so a `cross-vendor` class
 * MUST NOT be taken as a confident independent-cluster claim (strategy-claude
 * PP1/OQ2 tripwire). See {@link KNOWN_PROVIDER_FAMILIES} for the invariant.
 */
export declare function classifyDiversity(providers: readonly string[]): PanelDiversity;
/**
 * Aggregate N lanes into a {@link PanelSynthesis}. Pure, deterministic, zero-LLM.
 * Output is identical under any permutation of `lanes` (findings sorted by
 * `ruleName`; per-rule lanes walked in laneId order; messages sorted).
 *
 * Throws (fail-loud, never silently degrade — Tenet 4) on a corrupt input
 * contract: a lane with two findings sharing one `ruleName` (would masquerade as
 * cross-lane agreement — codex #2), or one `ruleName` carrying conflicting
 * `tier`s across lanes (a rule's tier is static — codex #9). A `ruleName` simply
 * ABSENT from some lanes is NOT an error: those lanes count as implicit
 * `abstain` (agy #4), so each finding's verdicts sum to `lanes.length`.
 */
export declare function synthesizePanel(lanes: readonly PanelLaneInput[]): PanelSynthesis;
/**
 * Assemble a full {@link PanelArtifact} from lane inputs. Pure. Canonicalizes
 * lane order by `laneId` so the content address is stable regardless of caller /
 * completion order, derives diversity from the per-lane providers (same canonical
 * order), synthesizes, and validates the whole shape (which re-checks each
 * persisted report's ADR-109 invariant). `createdAt` is supplied by the caller
 * (this module reads no clock — determinism).
 */
export declare function assemblePanelArtifact(lanes: readonly PanelLaneInput[], createdAt: string): PanelArtifact;
/** Absolute panels directory for a given absolute totem dir. */
export declare function panelsDir(totemDirAbs: string): string;
/**
 * Content address of a panel: deterministic hash over everything EXCEPT
 * `createdAt` (observability, not identity). The artifact is already canonical
 * (assemblePanelArtifact sorts lanes/findings/messages), so the address is a
 * pure function of the logical panel.
 */
export declare function computePanelArtifactContentHash(artifact: PanelArtifact): string;
export interface SavePanelArtifactResult {
    /** The content address (= filename stem). */
    hash: string;
    /** Absolute path of the stored artifact. */
    path: string;
    /** True when an identical logical panel was already recorded (no write happened). */
    existed: boolean;
}
/**
 * Persist a panel at its content address, write-if-absent. An existing file is
 * NEVER rewritten (append-only: first write wins). Validates on the way out so a
 * writer bug cannot poison the ledger with a record the reader would reject.
 */
export declare function writePanelArtifact(totemDirAbs: string, artifact: PanelArtifact): SavePanelArtifactResult;
/**
 * Load + validate a panel by content address. Throws {@link TotemParseError} on
 * a missing file, corrupt JSON, schema violation, an unknown major with no
 * migration entry, or a persisted report whose `isRejected` invariant is broken
 * — loud, never a silent partial (Tenet 4).
 */
export declare function readPanelArtifact(totemDirAbs: string, hash: string): PanelArtifact;
//# sourceMappingURL=panel.d.ts.map