@qmilab/lodestar-core 0.1.5 → 0.2.0

package/dist/schemas/calibration.d.ts

@@ -0,0 +1,977 @@
+import { z } from "zod";
+/**
+ * Calibration wire format.
+ *
+ * These schemas describe what the harness `Calibrator` measures —
+ * per-class ECE / Brier / calibration-gap tables and the flagged classes.
+ * They lived in `@qmilab/lodestar-harness` while the calibrator was a
+ * return-value-only surface; they **graduated to `@qmilab/lodestar-core`**
+ * when the durable `calibration.computed@1` event landed (ADR-0011), so
+ * the event payload can embed the report (core is the dependency root and
+ * cannot import the harness). The harness re-exports them unchanged, so
+ * harness consumers are unaffected.
+ *
+ * The Calibrator stays measure-only: it returns a {@link CalibrationReport}
+ * and never writes. Recording a report as a `calibration.computed@1` event
+ * is a separate publish step (`lodestar harness calibrate` / the harness
+ * `eventLogCalibrationSink`), the same measure/record split the sentinels
+ * follow (a `Sentinel` returns findings; `eventLogAlertSink` writes them).
+ *
+ * Everything here is validated at the calibrator and event-sink boundaries,
+ * the same discipline the probe-run observation and sentinel-alert builders
+ * hold.
+ */
+/**
+ * Which signal in the event log produced a calibration sample.
+ * - `action_outcome`: a belief → decision → action chain where the
+ *   action's realised result (terminal phase or an explicit Outcome) is
+ *   the label.
+ * - `truth_status`: the firewall transitioned the belief's `truth_status`
+ *   to `supported` / `contradicted` — the world adjudicating the belief.
+ */
+export declare const SampleSourceSchema: z.ZodEnum<["action_outcome", "truth_status"]>;
+export type SampleSource = z.infer<typeof SampleSourceSchema>;
+/** The scored metrics for a set of samples (one class, or the pool). */
+export declare const CalibrationMetricsSchema: z.ZodObject<{
+    n: z.ZodNumber;
+    /** mean of stated confidence */
+    mean_confidence: z.ZodNumber;
+    /** realised positive rate, mean(correct) */
+    empirical_accuracy: z.ZodNumber;
+    /** mean((p - y)^2); 0 is perfect, lower is better */
+    brier_score: z.ZodNumber;
+    /** expected calibration error over equal-width confidence bins */
+    ece: z.ZodNumber;
+    /** signed mean_confidence - empirical_accuracy; > 0 is overconfident */
+    calibration_gap: z.ZodNumber;
+    overconfident: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    n: number;
+    mean_confidence: number;
+    empirical_accuracy: number;
+    brier_score: number;
+    ece: number;
+    calibration_gap: number;
+    overconfident: boolean;
+}, {
+    n: number;
+    mean_confidence: number;
+    empirical_accuracy: number;
+    brier_score: number;
+    ece: number;
+    calibration_gap: number;
+    overconfident: boolean;
+}>;
+export type CalibrationMetrics = z.infer<typeof CalibrationMetricsSchema>;
+/** One non-empty bin of a reliability diagram. */
+export declare const ReliabilityBinSchema: z.ZodObject<{
+    lower: z.ZodNumber;
+    upper: z.ZodNumber;
+    n: z.ZodNumber;
+    mean_confidence: z.ZodNumber;
+    empirical_accuracy: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    n: number;
+    mean_confidence: number;
+    empirical_accuracy: number;
+    lower: number;
+    upper: number;
+}, {
+    n: number;
+    mean_confidence: number;
+    empirical_accuracy: number;
+    lower: number;
+    upper: number;
+}>;
+export type ReliabilityBin = z.infer<typeof ReliabilityBinSchema>;
+/** Per-class result: metrics, the reliability bins, and the verdict. */
+export declare const CalibrationClassResultSchema: z.ZodObject<{
+    calibration_class: z.ZodString;
+    metrics: z.ZodObject<{
+        n: z.ZodNumber;
+        /** mean of stated confidence */
+        mean_confidence: z.ZodNumber;
+        /** realised positive rate, mean(correct) */
+        empirical_accuracy: z.ZodNumber;
+        /** mean((p - y)^2); 0 is perfect, lower is better */
+        brier_score: z.ZodNumber;
+        /** expected calibration error over equal-width confidence bins */
+        ece: z.ZodNumber;
+        /** signed mean_confidence - empirical_accuracy; > 0 is overconfident */
+        calibration_gap: z.ZodNumber;
+        overconfident: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        brier_score: number;
+        ece: number;
+        calibration_gap: number;
+        overconfident: boolean;
+    }, {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        brier_score: number;
+        ece: number;
+        calibration_gap: number;
+        overconfident: boolean;
+    }>;
+    /** non-empty bins only, ascending by `lower` */
+    reliability_bins: z.ZodArray<z.ZodObject<{
+        lower: z.ZodNumber;
+        upper: z.ZodNumber;
+        n: z.ZodNumber;
+        mean_confidence: z.ZodNumber;
+        empirical_accuracy: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        lower: number;
+        upper: number;
+    }, {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        lower: number;
+        upper: number;
+    }>, "many">;
+    flagged: z.ZodBoolean;
+    /** human-legible reason when flagged; `null` when not */
+    flag_reason: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    calibration_class: string;
+    metrics: {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        brier_score: number;
+        ece: number;
+        calibration_gap: number;
+        overconfident: boolean;
+    };
+    reliability_bins: {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        lower: number;
+        upper: number;
+    }[];
+    flagged: boolean;
+    flag_reason: string | null;
+}, {
+    calibration_class: string;
+    metrics: {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        brier_score: number;
+        ece: number;
+        calibration_gap: number;
+        overconfident: boolean;
+    };
+    reliability_bins: {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        lower: number;
+        upper: number;
+    }[];
+    flagged: boolean;
+    flag_reason: string | null;
+}>;
+export type CalibrationClassResult = z.infer<typeof CalibrationClassResultSchema>;
+/** The thresholds and toggles actually applied, echoed for reproducibility. */
+export declare const ResolvedCalibratorConfigSchema: z.ZodObject<{
+    bins: z.ZodNumber;
+    min_samples: z.ZodNumber;
+    ece_threshold: z.ZodNumber;
+    gap_threshold: z.ZodNumber;
+    outcome_sources: z.ZodArray<z.ZodEnum<["action_outcome", "truth_status"]>, "many">;
+    include_synthetic_authority: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    bins: number;
+    min_samples: number;
+    ece_threshold: number;
+    gap_threshold: number;
+    outcome_sources: ("truth_status" | "action_outcome")[];
+    include_synthetic_authority: boolean;
+}, {
+    bins: number;
+    min_samples: number;
+    ece_threshold: number;
+    gap_threshold: number;
+    outcome_sources: ("truth_status" | "action_outcome")[];
+    include_synthetic_authority: boolean;
+}>;
+export type ResolvedCalibratorConfig = z.infer<typeof ResolvedCalibratorConfigSchema>;
+/**
+ * The calibrator's output: per-class tables, a pooled `overall` block,
+ * the flagged class names, and the config that produced it. A pure
+ * function of `(events, config)` — no clock, no scope inference — so it
+ * is deterministic and testable, and re-running it over the same event
+ * window reproduces the report (the property the `cursor` on
+ * {@link CalibrationComputedPayloadSchema} makes auditable).
+ */
+export declare const CalibrationReportSchema: z.ZodObject<{
+    /** total samples resolved and included (after exclusions) */
+    sample_count: z.ZodNumber;
+    classes: z.ZodArray<z.ZodObject<{
+        calibration_class: z.ZodString;
+        metrics: z.ZodObject<{
+            n: z.ZodNumber;
+            /** mean of stated confidence */
+            mean_confidence: z.ZodNumber;
+            /** realised positive rate, mean(correct) */
+            empirical_accuracy: z.ZodNumber;
+            /** mean((p - y)^2); 0 is perfect, lower is better */
+            brier_score: z.ZodNumber;
+            /** expected calibration error over equal-width confidence bins */
+            ece: z.ZodNumber;
+            /** signed mean_confidence - empirical_accuracy; > 0 is overconfident */
+            calibration_gap: z.ZodNumber;
+            overconfident: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        }, {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        }>;
+        /** non-empty bins only, ascending by `lower` */
+        reliability_bins: z.ZodArray<z.ZodObject<{
+            lower: z.ZodNumber;
+            upper: z.ZodNumber;
+            n: z.ZodNumber;
+            mean_confidence: z.ZodNumber;
+            empirical_accuracy: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            lower: number;
+            upper: number;
+        }, {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            lower: number;
+            upper: number;
+        }>, "many">;
+        flagged: z.ZodBoolean;
+        /** human-legible reason when flagged; `null` when not */
+        flag_reason: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        calibration_class: string;
+        metrics: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        reliability_bins: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            lower: number;
+            upper: number;
+        }[];
+        flagged: boolean;
+        flag_reason: string | null;
+    }, {
+        calibration_class: string;
+        metrics: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        reliability_bins: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            lower: number;
+            upper: number;
+        }[];
+        flagged: boolean;
+        flag_reason: string | null;
+    }>, "many">;
+    overall: z.ZodObject<{
+        n: z.ZodNumber;
+        /** mean of stated confidence */
+        mean_confidence: z.ZodNumber;
+        /** realised positive rate, mean(correct) */
+        empirical_accuracy: z.ZodNumber;
+        /** mean((p - y)^2); 0 is perfect, lower is better */
+        brier_score: z.ZodNumber;
+        /** expected calibration error over equal-width confidence bins */
+        ece: z.ZodNumber;
+        /** signed mean_confidence - empirical_accuracy; > 0 is overconfident */
+        calibration_gap: z.ZodNumber;
+        overconfident: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        brier_score: number;
+        ece: number;
+        calibration_gap: number;
+        overconfident: boolean;
+    }, {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        brier_score: number;
+        ece: number;
+        calibration_gap: number;
+        overconfident: boolean;
+    }>;
+    flagged_classes: z.ZodArray<z.ZodString, "many">;
+    config: z.ZodObject<{
+        bins: z.ZodNumber;
+        min_samples: z.ZodNumber;
+        ece_threshold: z.ZodNumber;
+        gap_threshold: z.ZodNumber;
+        outcome_sources: z.ZodArray<z.ZodEnum<["action_outcome", "truth_status"]>, "many">;
+        include_synthetic_authority: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        bins: number;
+        min_samples: number;
+        ece_threshold: number;
+        gap_threshold: number;
+        outcome_sources: ("truth_status" | "action_outcome")[];
+        include_synthetic_authority: boolean;
+    }, {
+        bins: number;
+        min_samples: number;
+        ece_threshold: number;
+        gap_threshold: number;
+        outcome_sources: ("truth_status" | "action_outcome")[];
+        include_synthetic_authority: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    sample_count: number;
+    classes: {
+        calibration_class: string;
+        metrics: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        reliability_bins: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            lower: number;
+            upper: number;
+        }[];
+        flagged: boolean;
+        flag_reason: string | null;
+    }[];
+    overall: {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        brier_score: number;
+        ece: number;
+        calibration_gap: number;
+        overconfident: boolean;
+    };
+    flagged_classes: string[];
+    config: {
+        bins: number;
+        min_samples: number;
+        ece_threshold: number;
+        gap_threshold: number;
+        outcome_sources: ("truth_status" | "action_outcome")[];
+        include_synthetic_authority: boolean;
+    };
+}, {
+    sample_count: number;
+    classes: {
+        calibration_class: string;
+        metrics: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        reliability_bins: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            lower: number;
+            upper: number;
+        }[];
+        flagged: boolean;
+        flag_reason: string | null;
+    }[];
+    overall: {
+        n: number;
+        mean_confidence: number;
+        empirical_accuracy: number;
+        brier_score: number;
+        ece: number;
+        calibration_gap: number;
+        overconfident: boolean;
+    };
+    flagged_classes: string[];
+    config: {
+        bins: number;
+        min_samples: number;
+        ece_threshold: number;
+        gap_threshold: number;
+        outcome_sources: ("truth_status" | "action_outcome")[];
+        include_synthetic_authority: boolean;
+    };
+}>;
+export type CalibrationReport = z.infer<typeof CalibrationReportSchema>;
+/**
+ * What invoked a calibration pass.
+ *
+ * `cli` — a human ran `lodestar harness calibrate --session <id>`.
+ * `programmatic` — a host computed and recorded calibration from its own
+ *   code (e.g. a guarded loop at a deliberate checkpoint).
+ */
+export declare const CalibrationTriggerSchema: z.ZodEnum<["cli", "programmatic"]>;
+export type CalibrationTrigger = z.infer<typeof CalibrationTriggerSchema>;
+/**
+ * The seq window a calibration pass measured.
+ *
+ * Replayability is by cursor: re-running `calibrate` over the same events
+ * in this window — those with `seq` strictly greater than `from_seq` and
+ * less than or equal to `to_seq`, within the event's own session slice —
+ * reproduces the embedded `report` (the calibrator is a pure function of
+ * `(events, config)`). This is what makes calibration drift auditable
+ * across time — two `calibration.computed@1` events with overlapping
+ * windows can be diffed, and either can be recomputed from the log to
+ * verify it was not tampered with. (`seq` is per-project, so the session
+ * slice is the natural replay scope; a v0 calibration pass reads one
+ * session.)
+ */
+export declare const CalibrationCursorSchema: z.ZodEffects<z.ZodObject<{
+    from_seq: z.ZodNumber;
+    to_seq: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    from_seq: number;
+    to_seq: number;
+}, {
+    from_seq: number;
+    to_seq: number;
+}>, {
+    from_seq: number;
+    to_seq: number;
+}, {
+    from_seq: number;
+    to_seq: number;
+}>;
+export type CalibrationCursor = z.infer<typeof CalibrationCursorSchema>;
+/**
+ * The payload of a `calibration.computed@1` event.
+ *
+ * The durable record of one calibration pass: the verdict (`report`), the
+ * window it measured (`cursor`, for replay), and provenance (`computed_at`,
+ * `triggered_by`, `computation_id`). It does NOT enforce anything — the
+ * Policy Kernel's arbitrate hook reads an in-process `CalibrationReport`
+ * snapshot, not this event (see `docs/architecture/calibrator.md` and
+ * ADR-0011). This event exists so calibration drift is auditable and
+ * replayable, the way a probe run or a sentinel finding already is.
+ *
+ * Not signed in v0: the event inherits the log's canonical-hash
+ * tamper-evidence, and nothing un-parks a held action on the strength of a
+ * calibration *event* (the gate only ever escalates — the conservative
+ * direction). If a future slice makes the gate consume persisted
+ * calibration events as an authority, signing graduates then, the same
+ * staged path the approval resolution followed (ADR-0010).
+ */
+export declare const CalibrationComputedPayloadSchema: z.ZodEffects<z.ZodObject<{
+    /** Stable id for this pass, so the audit chain can reference it. */
+    computation_id: z.ZodString;
+    triggered_by: z.ZodEnum<["cli", "programmatic"]>;
+    /** The seq window measured — re-running `calibrate` over it reproduces `report`. */
+    cursor: z.ZodEffects<z.ZodObject<{
+        from_seq: z.ZodNumber;
+        to_seq: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        from_seq: number;
+        to_seq: number;
+    }, {
+        from_seq: number;
+        to_seq: number;
+    }>, {
+        from_seq: number;
+        to_seq: number;
+    }, {
+        from_seq: number;
+        to_seq: number;
+    }>;
+    /** The verdict: the full report this pass produced. */
+    report: z.ZodObject<{
+        /** total samples resolved and included (after exclusions) */
+        sample_count: z.ZodNumber;
+        classes: z.ZodArray<z.ZodObject<{
+            calibration_class: z.ZodString;
+            metrics: z.ZodObject<{
+                n: z.ZodNumber;
+                /** mean of stated confidence */
+                mean_confidence: z.ZodNumber;
+                /** realised positive rate, mean(correct) */
+                empirical_accuracy: z.ZodNumber;
+                /** mean((p - y)^2); 0 is perfect, lower is better */
+                brier_score: z.ZodNumber;
+                /** expected calibration error over equal-width confidence bins */
+                ece: z.ZodNumber;
+                /** signed mean_confidence - empirical_accuracy; > 0 is overconfident */
+                calibration_gap: z.ZodNumber;
+                overconfident: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            }, {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            }>;
+            /** non-empty bins only, ascending by `lower` */
+            reliability_bins: z.ZodArray<z.ZodObject<{
+                lower: z.ZodNumber;
+                upper: z.ZodNumber;
+                n: z.ZodNumber;
+                mean_confidence: z.ZodNumber;
+                empirical_accuracy: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }, {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }>, "many">;
+            flagged: z.ZodBoolean;
+            /** human-legible reason when flagged; `null` when not */
+            flag_reason: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            calibration_class: string;
+            metrics: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            };
+            reliability_bins: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }[];
+            flagged: boolean;
+            flag_reason: string | null;
+        }, {
+            calibration_class: string;
+            metrics: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            };
+            reliability_bins: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }[];
+            flagged: boolean;
+            flag_reason: string | null;
+        }>, "many">;
+        overall: z.ZodObject<{
+            n: z.ZodNumber;
+            /** mean of stated confidence */
+            mean_confidence: z.ZodNumber;
+            /** realised positive rate, mean(correct) */
+            empirical_accuracy: z.ZodNumber;
+            /** mean((p - y)^2); 0 is perfect, lower is better */
+            brier_score: z.ZodNumber;
+            /** expected calibration error over equal-width confidence bins */
+            ece: z.ZodNumber;
+            /** signed mean_confidence - empirical_accuracy; > 0 is overconfident */
+            calibration_gap: z.ZodNumber;
+            overconfident: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        }, {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        }>;
+        flagged_classes: z.ZodArray<z.ZodString, "many">;
+        config: z.ZodObject<{
+            bins: z.ZodNumber;
+            min_samples: z.ZodNumber;
+            ece_threshold: z.ZodNumber;
+            gap_threshold: z.ZodNumber;
+            outcome_sources: z.ZodArray<z.ZodEnum<["action_outcome", "truth_status"]>, "many">;
+            include_synthetic_authority: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            bins: number;
+            min_samples: number;
+            ece_threshold: number;
+            gap_threshold: number;
+            outcome_sources: ("truth_status" | "action_outcome")[];
+            include_synthetic_authority: boolean;
+        }, {
+            bins: number;
+            min_samples: number;
+            ece_threshold: number;
+            gap_threshold: number;
+            outcome_sources: ("truth_status" | "action_outcome")[];
+            include_synthetic_authority: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        sample_count: number;
+        classes: {
+            calibration_class: string;
+            metrics: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            };
+            reliability_bins: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }[];
+            flagged: boolean;
+            flag_reason: string | null;
+        }[];
+        overall: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        flagged_classes: string[];
+        config: {
+            bins: number;
+            min_samples: number;
+            ece_threshold: number;
+            gap_threshold: number;
+            outcome_sources: ("truth_status" | "action_outcome")[];
+            include_synthetic_authority: boolean;
+        };
+    }, {
+        sample_count: number;
+        classes: {
+            calibration_class: string;
+            metrics: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            };
+            reliability_bins: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }[];
+            flagged: boolean;
+            flag_reason: string | null;
+        }[];
+        overall: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        flagged_classes: string[];
+        config: {
+            bins: number;
+            min_samples: number;
+            ece_threshold: number;
+            gap_threshold: number;
+            outcome_sources: ("truth_status" | "action_outcome")[];
+            include_synthetic_authority: boolean;
+        };
+    }>;
+    computed_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    triggered_by: "cli" | "programmatic";
+    cursor: {
+        from_seq: number;
+        to_seq: number;
+    };
+    computation_id: string;
+    report: {
+        sample_count: number;
+        classes: {
+            calibration_class: string;
+            metrics: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            };
+            reliability_bins: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }[];
+            flagged: boolean;
+            flag_reason: string | null;
+        }[];
+        overall: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        flagged_classes: string[];
+        config: {
+            bins: number;
+            min_samples: number;
+            ece_threshold: number;
+            gap_threshold: number;
+            outcome_sources: ("truth_status" | "action_outcome")[];
+            include_synthetic_authority: boolean;
+        };
+    };
+    computed_at: string;
+}, {
+    triggered_by: "cli" | "programmatic";
+    cursor: {
+        from_seq: number;
+        to_seq: number;
+    };
+    computation_id: string;
+    report: {
+        sample_count: number;
+        classes: {
+            calibration_class: string;
+            metrics: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            };
+            reliability_bins: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }[];
+            flagged: boolean;
+            flag_reason: string | null;
+        }[];
+        overall: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        flagged_classes: string[];
+        config: {
+            bins: number;
+            min_samples: number;
+            ece_threshold: number;
+            gap_threshold: number;
+            outcome_sources: ("truth_status" | "action_outcome")[];
+            include_synthetic_authority: boolean;
+        };
+    };
+    computed_at: string;
+}>, {
+    triggered_by: "cli" | "programmatic";
+    cursor: {
+        from_seq: number;
+        to_seq: number;
+    };
+    computation_id: string;
+    report: {
+        sample_count: number;
+        classes: {
+            calibration_class: string;
+            metrics: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            };
+            reliability_bins: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }[];
+            flagged: boolean;
+            flag_reason: string | null;
+        }[];
+        overall: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        flagged_classes: string[];
+        config: {
+            bins: number;
+            min_samples: number;
+            ece_threshold: number;
+            gap_threshold: number;
+            outcome_sources: ("truth_status" | "action_outcome")[];
+            include_synthetic_authority: boolean;
+        };
+    };
+    computed_at: string;
+}, {
+    triggered_by: "cli" | "programmatic";
+    cursor: {
+        from_seq: number;
+        to_seq: number;
+    };
+    computation_id: string;
+    report: {
+        sample_count: number;
+        classes: {
+            calibration_class: string;
+            metrics: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                brier_score: number;
+                ece: number;
+                calibration_gap: number;
+                overconfident: boolean;
+            };
+            reliability_bins: {
+                n: number;
+                mean_confidence: number;
+                empirical_accuracy: number;
+                lower: number;
+                upper: number;
+            }[];
+            flagged: boolean;
+            flag_reason: string | null;
+        }[];
+        overall: {
+            n: number;
+            mean_confidence: number;
+            empirical_accuracy: number;
+            brier_score: number;
+            ece: number;
+            calibration_gap: number;
+            overconfident: boolean;
+        };
+        flagged_classes: string[];
+        config: {
+            bins: number;
+            min_samples: number;
+            ece_threshold: number;
+            gap_threshold: number;
+            outcome_sources: ("truth_status" | "action_outcome")[];
+            include_synthetic_authority: boolean;
+        };
+    };
+    computed_at: string;
+}>;
+export type CalibrationComputedPayload = z.infer<typeof CalibrationComputedPayloadSchema>;
+/**
+ * Event-type literal. Use this constant rather than the bare string so a
+ * future rename is grep-safe. Mirrors `reflection.completed@1`.
+ */
+export declare const CALIBRATION_COMPUTED_EVENT_TYPE: "calibration.computed";
+export declare const CALIBRATION_COMPUTED_SCHEMA_VERSION: "1";
+//# sourceMappingURL=calibration.d.ts.map