@mmnto/totem 1.64.0 → 1.64.2

package/dist/artifacts/panel.d.ts

@@ -0,0 +1,1919 @@
+/**
+ * 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, {
+        rejected: number;
+        accepted: number;
+    }, {
+        rejected: number;
+        accepted: 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: {
+        rejected: number;
+        accepted: number;
+    };
+    divergences: number;
+}, {
+    findings: {
+        tier: "decidable" | "sensor";
+        ruleName: string;
+        verdicts: {
+            pass: number;
+            fail: number;
+            abstain: number;
+        };
+        divergent: boolean;
+        messages: string[];
+    }[];
+    verdictDistribution: {
+        rejected: number;
+        accepted: 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>;
+                }, "strip", z.ZodTypeAny, {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }, {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                items: {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }[];
+            }, {
+                items: {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }[];
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            hash: string;
+            provenanceSummary: string;
+            bundle?: {
+                items: {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }[];
+            } | undefined;
+        }, {
+            hash: string;
+            provenanceSummary: string;
+            bundle?: {
+                items: {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }[];
+            } | 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, {
+            provider: string;
+            model: string;
+            qualifiedModel: string;
+            admissionClass: "completion_only" | "self_grounding_agent";
+            taskProfile: string;
+            temperature?: number | undefined;
+        }, {
+            provider: string;
+            model: 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;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            metrics: {
+                durationMs: number;
+                inputTokens?: number | null | undefined;
+                outputTokens?: number | null | undefined;
+                cacheReadInputTokens?: number | null | undefined;
+                finishReason?: string | undefined;
+            };
+        }, {
+            content: string;
+            metrics: {
+                durationMs: number;
+                inputTokens?: number | null | undefined;
+                outputTokens?: number | null | undefined;
+                cacheReadInputTokens?: number | null | undefined;
+                finishReason?: string | 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>;
+            }, "strip", z.ZodTypeAny, {
+                caller?: string | undefined;
+                command?: string | undefined;
+                codeBlind?: boolean | undefined;
+            }, {
+                caller?: string | undefined;
+                command?: string | undefined;
+                codeBlind?: boolean | 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;
+            } | 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;
+            } | 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;
+            bundle?: {
+                items: {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }[];
+            } | undefined;
+        };
+        backend: {
+            provider: string;
+            model: 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;
+            };
+        };
+        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;
+            } | 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;
+            bundle?: {
+                items: {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }[];
+            } | undefined;
+        };
+        backend: {
+            provider: string;
+            model: 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;
+            };
+        };
+        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;
+            } | 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;
+            bundle?: {
+                items: {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }[];
+            } | undefined;
+        };
+        backend: {
+            provider: string;
+            model: 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;
+            };
+        };
+        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;
+            } | 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;
+            bundle?: {
+                items: {
+                    provenance: string;
+                    contentHash: string;
+                    sourceType: string;
+                    filePath: string;
+                    sourceRepo?: string | undefined;
+                }[];
+            } | undefined;
+        };
+        backend: {
+            provider: string;
+            model: 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;
+            };
+        };
+        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;
+            } | 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>;
+                    }, "strip", z.ZodTypeAny, {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }, {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }>, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                }, {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                hash: string;
+                provenanceSummary: string;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            }, {
+                hash: string;
+                provenanceSummary: string;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | 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, {
+                provider: string;
+                model: string;
+                qualifiedModel: string;
+                admissionClass: "completion_only" | "self_grounding_agent";
+                taskProfile: string;
+                temperature?: number | undefined;
+            }, {
+                provider: string;
+                model: 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;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                content: string;
+                metrics: {
+                    durationMs: number;
+                    inputTokens?: number | null | undefined;
+                    outputTokens?: number | null | undefined;
+                    cacheReadInputTokens?: number | null | undefined;
+                    finishReason?: string | undefined;
+                };
+            }, {
+                content: string;
+                metrics: {
+                    durationMs: number;
+                    inputTokens?: number | null | undefined;
+                    outputTokens?: number | null | undefined;
+                    cacheReadInputTokens?: number | null | undefined;
+                    finishReason?: string | 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>;
+                }, "strip", z.ZodTypeAny, {
+                    caller?: string | undefined;
+                    command?: string | undefined;
+                    codeBlind?: boolean | undefined;
+                }, {
+                    caller?: string | undefined;
+                    command?: string | undefined;
+                    codeBlind?: boolean | 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;
+                } | 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;
+                } | 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;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            };
+            backend: {
+                provider: string;
+                model: 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;
+                };
+            };
+            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;
+                } | 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;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            };
+            backend: {
+                provider: string;
+                model: 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;
+                };
+            };
+            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;
+                } | 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;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            };
+            backend: {
+                provider: string;
+                model: 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;
+                };
+            };
+            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;
+                } | 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;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            };
+            backend: {
+                provider: string;
+                model: 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;
+                };
+            };
+            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;
+                } | 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, {
+            rejected: number;
+            accepted: number;
+        }, {
+            rejected: number;
+            accepted: 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: {
+            rejected: number;
+            accepted: number;
+        };
+        divergences: number;
+    }, {
+        findings: {
+            tier: "decidable" | "sensor";
+            ruleName: string;
+            verdicts: {
+                pass: number;
+                fail: number;
+                abstain: number;
+            };
+            divergent: boolean;
+            messages: string[];
+        }[];
+        verdictDistribution: {
+            rejected: number;
+            accepted: 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;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            };
+            backend: {
+                provider: string;
+                model: 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;
+                };
+            };
+            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;
+                } | 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: {
+            rejected: number;
+            accepted: 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;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            };
+            backend: {
+                provider: string;
+                model: 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;
+                };
+            };
+            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;
+                } | 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: {
+            rejected: number;
+            accepted: 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;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            };
+            backend: {
+                provider: string;
+                model: 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;
+                };
+            };
+            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;
+                } | 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: {
+            rejected: number;
+            accepted: 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;
+                bundle?: {
+                    items: {
+                        provenance: string;
+                        contentHash: string;
+                        sourceType: string;
+                        filePath: string;
+                        sourceRepo?: string | undefined;
+                    }[];
+                } | undefined;
+            };
+            backend: {
+                provider: string;
+                model: 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;
+                };
+            };
+            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;
+                } | 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: {
+            rejected: number;
+            accepted: 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