@tangle-network/agent-eval 0.208.2 → 0.210.0

package/dist/{matrix-Cqkk7eYI.d.ts → matrix-jHTsHEkR.d.ts}

@@ -1,5 +1,5 @@
 import { p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { w as JudgeScore } from "./types-CFCUZk0B.js";
+import { w as JudgeScore } from "./types-Dv9sYwBB.js";
 import { o as MatrixResult } from "./index-DNgf5gyG.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/multishot/types.d.ts
@@ -398,4 +398,4 @@ interface RunMultishotMatrixResult {
 declare function runMultishotMatrix<TPersona extends MultishotPersona>(opts: RunMultishotMatrixOptions<TPersona>): Promise<RunMultishotMatrixResult>;
 //#endregion
 export { MultishotToolExecutor as A, MultishotFatalToolError as C, MultishotShape as D, MultishotResult as E, assertMultishotShotResult as F, MultishotTransportRequest as M, MultishotTransportResponse as N, MultishotShotResultError as O, MultishotTransportToolCall as P, MultishotDriverEmptyError as S, MultishotPersona as T, JudgeRunResult as _, MultishotCellOutput as a, runJudge as b, RunMultishotMatrixResult as c, MultishotShot as d, RunMultishotOptions as f, JudgeDimension as g, JudgeConfig as h, ConversationJudgeInput as i, MultishotTransport as j, MultishotToolDefinition as k, computeCellComposite as l, DEFAULT_JUDGE_MODEL as m, CellCompositeInput as n, MultishotJudges as o, runMultishot as p, CellCompositeScore as r, RunMultishotMatrixOptions as s, ArtifactJudgeInput as t, runMultishotMatrix as u, renderDimensions as v, MultishotMessage as w, MultishotArtifact as x, renderJsonFooter as y };
-//# sourceMappingURL=matrix-Cqkk7eYI.d.ts.map
+//# sourceMappingURL=matrix-jHTsHEkR.d.ts.map

package/dist/{matrix-Cqkk7eYI.d.ts.map → matrix-jHTsHEkR.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"matrix-Cqkk7eYI.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}
+{"version":3,"file":"matrix-jHTsHEkR.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}

package/dist/meta-eval/index.d.ts

@@ -1,11 +1,11 @@
 import { f as Run } from "../schema-2g7trUwH.js";
 import { a as ContinuousCalibrationResult, c as SelfPreferenceResult, d as calibrateJudgeContinuous, f as continuousAgreement, h as verbosityBias, i as ContinuousAgreementOptions, l as VerbosityBiasResult, m as selfPreference, n as CandidateScore, o as GoldenItem, p as positionalBias, r as ContinuousAgreement, s as PositionalBiasResult, t as CalibrationResult, u as calibrateJudge } from "../judge-calibration-DFtEMlde.js";
-import { n as SeriesConvergenceResult, o as CorpusAgreementReport, t as SeriesConvergenceOptions } from "../series-convergence-hEfKdoi-.js";
+import { A as SentinelThresholds, B as validateSentinelSnapshot, C as JudgeSentinelOptions, D as SentinelSetOptions, E as SentinelReport, F as inMemorySentinelStore, I as judgeSentinelReport, L as snapshotFromAgreement, M as SnapshotMeta, N as evalHealthStamp, O as SentinelSnapshot, P as fileSentinelStore, R as snapshotFromCalibration, S as EvalHealthStamp, T as SentinelMetrics, _ as assertJudgeMayGate, a as JudgeCalibrationSet, b as registerCalibrationSet, c as JudgeGateDecision, d as JudgeGateRefusedError, f as JudgeGateStatus, g as addCalibrationVerdicts, h as OwnerVerdict, i as JudgeAgreement, j as SentinelTrend, k as SentinelStore, l as JudgeGateInput, m as JudgeRunMeta, n as CalibrationMerge, o as JudgeConfusion, p as JudgeRun, r as DEFAULT_JUDGE_GATE_POLICY, s as JudgeExampleAgreement, t as CalibrationExample, u as JudgeGatePolicy, v as judgeGateDecision, w as SentinelMetricName, x as snapshotFromJudgeAgreement, y as measureJudgeAgreement, z as snapshotFromSentinelSet } from "../judge-gate-D2hCppem.js";
 import { r as LedgerHash } from "../canonical-CFpojCN5.js";
 import { s as TraceStore } from "../store-C4avFjIi.js";
 import { a as OutcomeFilter, i as InMemoryOutcomeStore, n as FileSystemOutcomeStore, o as OutcomeStore, r as FileSystemOutcomeStoreOptions, s as OutcomeStoreError, t as DeploymentOutcome } from "../outcome-store-CNt4iZ67.js";
 import { a as ComputedInterval } from "../ast-hI-vjW6J.js";
-import { a as RubricPredictiveValidityReport, c as CorrelationInterval, i as RubricPredictiveValidityInput, l as OutcomeReduction, n as RubricOutcomeExclusion, o as RubricRanking, r as RubricOutcomePair, s as rubricPredictiveValidity, t as OutcomeMetricSpec } from "../rubric-predictive-validity-DIUwJJ9Y.js";
+import { a as RubricPredictiveValidityReport, c as CorrelationInterval, i as RubricPredictiveValidityInput, l as OutcomeReduction, n as RubricOutcomeExclusion, o as RubricRanking, r as RubricOutcomePair, s as rubricPredictiveValidity, t as OutcomeMetricSpec } from "../rubric-predictive-validity-BiNNEjpG.js";
 import { z } from "zod";
 //#region src/meta-eval/correlation-study.d.ts
 export interface EvalMetricSpec {
@@ -635,135 +635,5 @@ export interface CatchRateReport {
  */
 export declare function catchRate(results: readonly PlantOutcome[], manifest: PlantManifest): CatchRateReport;
 //#endregion
-//#region src/meta-eval/sentinel.d.ts
-declare const SENTINEL_METRIC_NAMES: readonly ['irr', 'calibrationKappa', 'sentinelPassRate'];
-export type SentinelMetricName = (typeof SENTINEL_METRIC_NAMES)[number];
-export interface SentinelMetrics {
-  /** Inter-rater reliability — ICC(2,1) from agreement instruments. */
-  irr?: number;
-  /** Weighted κ vs the human golden set (`calibrateJudge*`). */
-  calibrationKappa?: number;
-  /** Fraction of a fixed sentinel golden set the judge still scores within tolerance. */
-  sentinelPassRate?: number;
-}
-export interface SentinelSnapshot {
-  /** Caller-supplied ISO-8601 timestamp — the module never reads a clock. */
-  at: string;
-  judgeId: string;
-  /** Exact model identity behind the judge (pin the full version string). */
-  judgeModel: string;
-  /**
-   * Metrics measured at `at`. May be empty: an empty-metrics snapshot is a
-   * model-change marker — it records the new `judgeModel` immediately and
-   * the silent-upgrade alarm stays raised until a golden-grounded snapshot
-   * (calibrationKappa or sentinelPassRate) follows.
-   */
-  metrics: SentinelMetrics;
-}
-/** Identity + timestamp the caller supplies alongside an instrument output. */
-export interface SnapshotMeta {
-  at: string;
-  judgeId: string;
-  judgeModel: string;
-}
-/** Shape guard for snapshots crossing a boundary (store append, JSONL load, report input). */
-export declare function validateSentinelSnapshot(snapshot: SentinelSnapshot, source?: string): void;
-/**
- * From `calibrateJudge` / `calibrateJudgeContinuous` output. Prefers the
- * un-rounded continuous κ_w when the report carries one (integer κ
- * discards information for [0,1] judges).
- */
-export declare function snapshotFromCalibration(report: CalibrationResult | ContinuousCalibrationResult, meta: SnapshotMeta): SentinelSnapshot;
-/**
- * From `corpusInterRaterAgreement` (statistics.ts) or `continuousAgreement`
- * (judge-calibration.ts) output. IRR = ICC(2,1) — the reliability
- * coefficient both instruments compute. For ensemble-level agreement,
- * `meta.judgeId` names the ensemble and `meta.judgeModel` pins its
- * composition (e.g. a joined list of member model strings).
- */
-export declare function snapshotFromAgreement(report: CorpusAgreementReport | ContinuousAgreement, meta: SnapshotMeta): SentinelSnapshot;
-export interface SentinelSetOptions {
-  /** Max |judge − human| for an item to count as passed. Default 0.1 (tuned for [0,1] scores). */
-  tolerance?: number;
-}
-/**
- * From a rerun of a fixed sentinel golden set: the same `GoldenItem`s the
- * judge was originally calibrated on, re-scored periodically. Pass rate =
- * fraction of joined items where the judge stays within `tolerance` of the
- * human score. Items the judge didn't score are excluded from the
- * denominator; zero joined items is an error, not a 0% pass rate.
- */
-export declare function snapshotFromSentinelSet(scores: CandidateScore[], golden: GoldenItem[], meta: SnapshotMeta, options?: SentinelSetOptions): SentinelSnapshot;
-export interface SentinelStore {
-  append(snapshot: SentinelSnapshot): Promise<void>;
-  /** All snapshots (optionally for one judge), in append order. */
-  history(judgeId?: string): Promise<SentinelSnapshot[]>;
-}
-export declare function inMemorySentinelStore(initial?: SentinelSnapshot[]): SentinelStore;
-/**
- * JSONL store — one snapshot per line, appended atomically per call.
- * A corrupt or shape-invalid line is a loud error naming the file and
- * line number: a sentinel history that silently drops records would
- * defeat the drift detection it exists to provide.
- */
-export declare function fileSentinelStore(path: string): SentinelStore;
-export interface SentinelThresholds {
-  /** Floor for irr — below it the judge ensemble is unreliable regardless of trend. Default 0.6. */
-  minIrr?: number;
-  /** Max tolerated calibrationKappa drop vs the series baseline. Default 0.15. */
-  maxKappaDrop?: number;
-  /** Max tolerated sentinelPassRate drop vs the series baseline. Default 0.1. */
-  maxSentinelDrop?: number;
-  /** Newest snapshot older than this (days, vs asOf) = the sentinel itself went blind. Default 30. */
-  staleAfterDays?: number;
-}
-export interface JudgeSentinelOptions {
-  /** Caller-supplied ISO timestamp staleness is measured against. */
-  asOf: string;
-  thresholds?: SentinelThresholds;
-  /** Forwarded to `analyzeSeries` (window, stableCv, driftRun). */
-  convergence?: SeriesConvergenceOptions;
-}
-export interface SentinelTrend {
-  judgeId: string;
-  metric: SentinelMetricName;
-  /** Verbatim `analyzeSeries` state for this judge×metric history. */
-  state: SeriesConvergenceResult['state'];
-  /** Newest value in the series. */
-  current: number;
-  /** Oldest value in the series — the reference the drop thresholds compare against. */
-  baseline: number;
-  /** current − baseline (signed; negative = decayed). */
-  drift: number;
-  alarmed: boolean;
-  reason?: string;
-}
-export interface SentinelReport {
-  perJudge: SentinelTrend[];
-  alarms: string[];
-  healthy: boolean;
-  /**
-   * `judgeId:metric` pairs with too few snapshots for the convergence
-   * machine. Named, not counted — a blind spot you can't see is a blind
-   * spot you won't fix. Floor/drop checks still apply to thin series, so
-   * insufficient history alone never masks an alarm.
-   */
-  insufficientHistory: string[];
-}
-export declare function judgeSentinelReport(history: SentinelSnapshot[], opts: JudgeSentinelOptions): SentinelReport;
-export interface EvalHealthStamp {
-  healthy: boolean;
-  alarms: string[];
-}
-/**
- * The object a campaign attaches to its verdicts. Compute it from the
- * sentinel report in a post-campaign hook (or a nightly job feeding the
- * next day's campaigns) and store it alongside the verdict payload.
- * `healthy: false` means the judges that produced those verdicts have an
- * unresolved drift / decay / silent-upgrade / staleness alarm — treat the
- * verdicts as carrying an integrity warning until recalibration clears it.
- */
-export declare function evalHealthStamp(report: SentinelReport): EvalHealthStamp;
-//#endregion
-export { type CalibrationResult, type CandidateScore, type ContinuousAgreement, type ContinuousAgreementOptions, type ContinuousCalibrationResult, type CorrelationInterval, DeploymentOutcome, type EvaluatorAdmissionPolicy, type EvaluatorAdmissionReport, type EvaluatorAuditInput, type EvaluatorAuditObservation, type EvaluatorAuditPlan, type EvaluatorAuditPlanInput, type EvaluatorErrorRate, FileSystemOutcomeStore, FileSystemOutcomeStoreOptions, type GoldenItem, InMemoryOutcomeStore, OutcomeFilter, OutcomeMetricSpec, type OutcomeReduction, OutcomeStore, OutcomeStoreError, type PositionalBiasResult, type ProbabilityPolicyAuditInput, type ProbabilityPolicyAuditReport, RubricOutcomeExclusion, RubricOutcomePair, RubricPredictiveValidityInput, RubricPredictiveValidityReport, RubricRanking, type SelfPreferenceResult, type VerbosityBiasResult, calibrateJudge, calibrateJudgeContinuous, continuousAgreement, positionalBias, rubricPredictiveValidity, selfPreference, verbosityBias };
+export { CalibrationExample, CalibrationMerge, type CalibrationResult, type CandidateScore, type ContinuousAgreement, type ContinuousAgreementOptions, type ContinuousCalibrationResult, type CorrelationInterval, DEFAULT_JUDGE_GATE_POLICY, DeploymentOutcome, EvalHealthStamp, type EvaluatorAdmissionPolicy, type EvaluatorAdmissionReport, type EvaluatorAuditInput, type EvaluatorAuditObservation, type EvaluatorAuditPlan, type EvaluatorAuditPlanInput, type EvaluatorErrorRate, FileSystemOutcomeStore, FileSystemOutcomeStoreOptions, type GoldenItem, InMemoryOutcomeStore, JudgeAgreement, JudgeCalibrationSet, JudgeConfusion, JudgeExampleAgreement, JudgeGateDecision, JudgeGateInput, JudgeGatePolicy, JudgeGateRefusedError, JudgeGateStatus, JudgeRun, JudgeRunMeta, JudgeSentinelOptions, OutcomeFilter, OutcomeMetricSpec, type OutcomeReduction, OutcomeStore, OutcomeStoreError, OwnerVerdict, type PositionalBiasResult, type ProbabilityPolicyAuditInput, type ProbabilityPolicyAuditReport, RubricOutcomeExclusion, RubricOutcomePair, RubricPredictiveValidityInput, RubricPredictiveValidityReport, RubricRanking, type SelfPreferenceResult, SentinelMetricName, SentinelMetrics, SentinelReport, SentinelSetOptions, SentinelSnapshot, SentinelStore, SentinelThresholds, SentinelTrend, SnapshotMeta, type VerbosityBiasResult, addCalibrationVerdicts, assertJudgeMayGate, calibrateJudge, calibrateJudgeContinuous, continuousAgreement, evalHealthStamp, fileSentinelStore, inMemorySentinelStore, judgeGateDecision, judgeSentinelReport, measureJudgeAgreement, positionalBias, registerCalibrationSet, rubricPredictiveValidity, selfPreference, snapshotFromAgreement, snapshotFromCalibration, snapshotFromJudgeAgreement, snapshotFromSentinelSet, validateSentinelSnapshot, verbosityBias };
 //# sourceMappingURL=index.d.ts.map

package/dist/meta-eval/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/meta-eval/correlation-study.ts","../../src/meta-eval/calibration.ts","../../src/meta-eval/cluster-bootstrap.ts","../../src/meta-eval/evaluator-admission.ts","../../src/meta-eval/plants.ts","../../src/meta-eval/sentinel.ts"],"mappings":";;;;;;;;;;iBAoBiB;EACf;;;EAGA,WAAW,KAAK,KAAK,OAAO,eAAe;;iBAG5B;EACf;EACA;;iBAGe;EACf;EACA;EACA;EACA;EACA;;EAEA;IAAe;IAAe;;;EAE9B;IAAgB;IAAe;;;EAE/B;;iBAGe;EACf,OAAO;;EAEP,eAAe,MACb;IACE;IACA;;EAGJ;EACA;;iBAGe;;EAEf;;EAEA,gBAAgB;;EAEhB;;EAEA;;;EAGA;;wBAGoB,iBACpB,YAAY,YACZ,cAAc,cACd,aAAa,kBACb,8BACA,UAAS,0BACR,QAAQ;;;iBChEM;EACf;EACA;EACA;EACA;EACA;;EAEA;;iBAGe;EACf;EACA;EACA;EACA,MAAM;;EAEN;;EAEA;;iBAGe;;EAEf;;EAEA;;EAEA;IAAU;IAAY;;;iBAGP;EACf;EACA;;wBAGoB,iBACpB,YAAY,YACZ,cAAc,cACd,YAAY,gBACZ,uBACA,UAAS,qBACR,QAAQ;;wBA0CK,qBACd,qBAAqB,mBACrB,oBACA,uBACA,UAAS,qBACR;;;;;;wBA+Da,WAAW,gBAAgB;;iBAkB1B;;EAEf,eAAe,SAAS;EACxB;;;;;;;;;wBAUc,qBAAqB,oBAAoB;;iBAaxC;EACf;;EAEA;;;;;;;;wBASc,uBAAuB,oBAAoB;;;;iBC1N1C;EACf;EACA;;iBAGe;;EAEf;;EAEA;;EAEA;;iBAGe;EACf;EACA;;EAEA;EACA;EACA;EACA;EACA;;;;;;;;;;;;wBAac,qBACd,uBAAuB,wBACvB,UAAS,0BACR;;;qBCjCU,gCAA8B,EAAA;;;;GAMhC,EAAA,KAAA;;KAGC,2BAA2B,EAAE,aAAa;qBAEzC,iCAA+B,EAAA;;;;;;;;;;;;;;;;;GASjC,EAAA,KAAA;;KAGC,4BAA4B,EAAE,aAAa;cAEjD,aAAW,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAeN,EAAA,KAAA;KAEC,sBAAsB,EAAE,aAAa;UAEhC;;EAEf;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA,UAAU;EACV;EACA;;UAGe;EACf,iBAAiB;EACjB,cAAc;EACd,aAAa;EACb,cAAc;EACd;EACA;EACA,WAAW;EACX,QAAQ;;EAER;EACA;EACA;EACA;EACA,cAAc;EACd;IACE;IACA;IACA;IACA;IACA;IACA;;EAEF,YAAY;IAAQ;IAAY;IAA2B;;EAC3D,iBAAiB;EACjB,gBAAgB;;cAkGZ,gBAAc,EAAA;;;;;;;;;;;;;;;;;;GAOT,EAAA,KAAA;KAEC,0BAA0B,EAAE,aAAa;;;;;;wBA0BrC,mBAAmB,OAAO;;;;;;;;;;;;;;;;;KAiC9B,qBAAqB,kBAAkB;;;;;;wBAOnC,eAAe,OAAO,sBAAsB;cAoFtD,wBAAsB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAG1B,EAAA,KAAA;;KAGU,8BAA8B,EAAE,aAAa;UAExC,qCAAqC;EACpD;IACE,uBAAuB;IACvB,YAAY;;IAEZ,cAAc;MAAQ;MAAY;;;;;;;;;wBAStB,uBACd,OAAO,8BACN;;;;;;;;YC1TS;;;;;;;;;;YAkBA;iBAOK;;EAEf;EACA,MAAM;;EAEN,MAAM;;EAEN,iBAAiB;;;;;;;;;;;;;;wBAeH,YAAY;EAC1B;EACA,MAAM;EACN,MAAM;EACN,iBAAiB;IACf;;;;;iBAqDa;;EAEf;;EAEA;;;YAIU;;YAGA;iBAEK;;EAEf,UAAU;;EAEV,OAAO;;EAEP,KAAK;;;;;;EAML;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsJc,gBAAgB,UAAU,gBAAgB;iBA8BzC;EACf,OAAO;;EAEP,UAAU;EACV,OAAO;EACP,KAAK;EACL;EACA;;;;;;;;;;;;;;;;;;;;;;wBAuBc,oBAAoB;EAClC;EACA;EACA,UAAU;;EAEV;EACA;IACE;iBA0Ba;;;;;;EAMf,MAAM;;EAEN;;EAEA;;EAEA;;EAEA,QAAQ;;iBAGO;;;;;;EAMf,OAAO;EACP,UAAU;;iBAGK;;;;;EAKf;;;;;;EAMA;;;;;;;;;;;wBAYc,WACd,kBAAkB,cAClB,iBAAiB,SACjB,UAAS,oBACR;;;;;;iBAqGc;EACf;EACA;;;;;;YAOU;iBAEK;EACf;EACA;EACA;EACA;;EAEA;;;;;;;;iBASe;EACf;EACA;EACA;;EAEA;;iBAGe;EACf,QAAQ;;EAER;EACA;EACA;EACA;;;;;EAKA;;EAEA;;EAEA,QAAQ,QAAQ,OAAO,WAAW;;EAElC;;EAEA;EACA,UAAU;;;;;;;;;;wBAWI,UACd,kBAAkB,gBAClB,UAAU,gBACT;;;cC/lBG;YAEM,6BAA6B;iBAExB;;EAEf;;EAEA;;EAEA;;iBAGe;;EAEf;EACA;;EAEA;;;;;;;EAOA,SAAS;;;iBAIM;EACf;EACA;EACA;;;wBAcc,yBAAyB,UAAU,kBAAkB;;;;;;wBAiCrD,wBACd,QAAQ,oBAAoB,6BAC5B,MAAM,eACL;;;;;;;;wBAmBa,sBACd,QAAQ,wBAAwB,qBAChC,MAAM,eACL;iBAYc;;EAEf;;;;;;;;;wBAUc,wBACd,QAAQ,kBACR,QAAQ,cACR,MAAM,cACN,UAAS,qBACR;iBA4Cc;EACf,OAAO,UAAU,mBAAmB;;EAEpC,QAAQ,mBAAmB,QAAQ;;wBAGrB,sBAAsB,UAAS,qBAA0B;;;;;;;wBAqBzD,kBAAkB,eAAe;iBA0ChC;;EAEf;;EAEA;;EAEA;;EAEA;;iBAGe;;EAEf;EACA,aAAa;;EAEb,cAAc;;iBAGC;EACf;EACA,QAAQ;;EAER,OAAO;;EAEP;;EAEA;;EAEA;EACA;EACA;;iBAGe;EACf,UAAU;EACV;EACA;;;;;;;EAOA;;wBAKc,oBACd,SAAS,oBACT,MAAM,uBACL;iBA6Gc;EACf;EACA;;;;;;;;;;wBAWc,gBAAgB,QAAQ,iBAAiB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/meta-eval/correlation-study.ts","../../src/meta-eval/calibration.ts","../../src/meta-eval/cluster-bootstrap.ts","../../src/meta-eval/evaluator-admission.ts","../../src/meta-eval/plants.ts"],"mappings":"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"}

package/dist/meta-eval/index.js

@@ -3,9 +3,9 @@ import { a as hashCanonical, i as compareCodeUnits } from "../canonical-BsZVgBhW
 import { i as makeRng } from "../internal-CRHwS9iz.js";
 import { t as mulberry32 } from "../random-Dn5fPWkt.js";
 import { a as selfPreference, i as positionalBias, n as calibrateJudgeContinuous, o as verbosityBias, r as continuousAgreement, t as calibrateJudge } from "../judge-calibration-N44V04Se.js";
-import { u as runMetricExtractor } from "../query-DlV0pdx4.js";
+import { l as runMetricExtractor } from "../query-B1D1qp2Z.js";
 import { r as computeInterval } from "../ast-DJ6Bc7ab.js";
-import { t as analyzeSeries } from "../series-convergence-CjO2QdRW.js";
+import { a as judgeGateDecision, c as snapshotFromJudgeAgreement, d as inMemorySentinelStore, f as judgeSentinelReport, g as validateSentinelSnapshot, h as snapshotFromSentinelSet, i as assertJudgeMayGate, l as evalHealthStamp, m as snapshotFromCalibration, n as JudgeGateRefusedError, o as measureJudgeAgreement, p as snapshotFromAgreement, r as addCalibrationVerdicts, s as registerCalibrationSet, t as DEFAULT_JUDGE_GATE_POLICY, u as fileSentinelStore } from "../judge-gate-C59znGmR.js";
 import { a as reduceOutcomeMetric, i as hasVariation, n as assertUniqueObservationIds, o as validateObservationOptions, r as correlationSummary, t as rubricPredictiveValidity } from "../rubric-predictive-validity-BsgkBfT0.js";
 import { n as InMemoryOutcomeStore, r as OutcomeStoreError, t as FileSystemOutcomeStore } from "../outcome-store-DUcMj-3D.js";
 import { z } from "zod";
@@ -1104,279 +1104,6 @@ function unseededRejection(manifest, scoreByItemId) {
 	};
 }
 //#endregion
-//#region src/meta-eval/sentinel.ts
-/**
-* Judge sentinel — eval trustworthiness as a continuously measured,
-* alarmed trend.
-*
-* Judges are models; models change underneath us; calibration decays.
-* This module composes three existing instruments into one loop:
-*
-*   snapshot — adapters turn real instrument outputs (`calibrateJudge` /
-*              `calibrateJudgeContinuous`, `corpusInterRaterAgreement` /
-*              `continuousAgreement`, a rerun sentinel golden set) into
-*              `SentinelSnapshot`s
-*   series   — `analyzeSeries` (src/series-convergence) classifies each
-*              judge×metric history as stabilized / drifting / noisy
-*   alarm    — `judgeSentinelReport` turns trends + thresholds into named
-*              alarms; `evalHealthStamp` is the tiny object a campaign
-*              attaches to its verdicts
-*
-* Alarm conditions:
-*   - convergence state `drifting-down` on any tracked metric
-*   - irr below `minIrr`
-*   - calibrationKappa / sentinelPassRate dropped vs the series baseline
-*     beyond `maxKappaDrop` / `maxSentinelDrop`
-*   - judge model changed with no post-change golden-grounded snapshot
-*     (the silent-upgrade trap: judges agreeing with each other after a
-*     model swap proves nothing — only re-measuring against gold does)
-*   - newest snapshot older than `staleAfterDays` relative to `asOf`
-*
-* Wire-in: run the snapshot adapters from a post-campaign hook or a
-* nightly job, append to a `SentinelStore`, then compute
-* `judgeSentinelReport(await store.history(), { asOf })` with `asOf` =
-* the campaign timestamp. Attach `evalHealthStamp(report)` to campaign
-* verdicts: an alarmed sentinel means every downstream verdict carries
-* an integrity warning until the judge is recalibrated.
-*
-* The module is clock-free — every timestamp (`at`, `asOf`) is
-* caller-supplied ISO-8601, so reports are reproducible.
-*/
-const SENTINEL_METRIC_NAMES = [
-	"irr",
-	"calibrationKappa",
-	"sentinelPassRate"
-];
-function parseIso(value, label) {
-	const ms = typeof value === "string" ? Date.parse(value) : NaN;
-	if (!Number.isFinite(ms)) throw new ValidationError(`judge-sentinel: ${label} is not a parseable ISO timestamp: ${JSON.stringify(value)}`);
-	return ms;
-}
-/** Shape guard for snapshots crossing a boundary (store append, JSONL load, report input). */
-function validateSentinelSnapshot(snapshot, source = "snapshot") {
-	parseIso(snapshot.at, `${source}.at`);
-	if (typeof snapshot.judgeId !== "string" || snapshot.judgeId.length === 0) throw new ValidationError(`judge-sentinel: ${source}.judgeId must be a non-empty string`);
-	if (typeof snapshot.judgeModel !== "string" || snapshot.judgeModel.length === 0) throw new ValidationError(`judge-sentinel: ${source}.judgeModel must be a non-empty string`);
-	if (snapshot.metrics === null || typeof snapshot.metrics !== "object") throw new ValidationError(`judge-sentinel: ${source}.metrics must be an object (may be empty)`);
-	for (const [key, value] of Object.entries(snapshot.metrics)) {
-		if (!SENTINEL_METRIC_NAMES.includes(key)) throw new ValidationError(`judge-sentinel: ${source}.metrics carries unknown key "${key}" — known: ${SENTINEL_METRIC_NAMES.join(", ")}`);
-		if (value !== void 0 && !Number.isFinite(value)) throw new ValidationError(`judge-sentinel: ${source}.metrics.${key} is not a finite number: ${String(value)}`);
-	}
-}
-/**
-* From `calibrateJudge` / `calibrateJudgeContinuous` output. Prefers the
-* un-rounded continuous κ_w when the report carries one (integer κ
-* discards information for [0,1] judges).
-*/
-function snapshotFromCalibration(report, meta) {
-	const kappa = "weightedKappaContinuous" in report ? report.weightedKappaContinuous : report.kappa;
-	if (!Number.isFinite(kappa)) throw new ValidationError(`snapshotFromCalibration: κ is not finite (n=${report.n}) — calibrate against ≥2 joined golden items before snapshotting`);
-	const snapshot = {
-		...meta,
-		metrics: { calibrationKappa: kappa }
-	};
-	validateSentinelSnapshot(snapshot);
-	return snapshot;
-}
-/**
-* From `corpusInterRaterAgreement` (statistics.ts) or `continuousAgreement`
-* (judge-calibration.ts) output. IRR = ICC(2,1) — the reliability
-* coefficient both instruments compute. For ensemble-level agreement,
-* `meta.judgeId` names the ensemble and `meta.judgeModel` pins its
-* composition (e.g. a joined list of member model strings).
-*/
-function snapshotFromAgreement(report, meta) {
-	const irr = "overallIcc" in report ? report.overallIcc : report.icc;
-	if (!Number.isFinite(irr)) throw new ValidationError("snapshotFromAgreement: ICC is not finite — agreement needs ≥2 raters and ≥2 complete items");
-	const snapshot = {
-		...meta,
-		metrics: { irr }
-	};
-	validateSentinelSnapshot(snapshot);
-	return snapshot;
-}
-/**
-* From a rerun of a fixed sentinel golden set: the same `GoldenItem`s the
-* judge was originally calibrated on, re-scored periodically. Pass rate =
-* fraction of joined items where the judge stays within `tolerance` of the
-* human score. Items the judge didn't score are excluded from the
-* denominator; zero joined items is an error, not a 0% pass rate.
-*/
-function snapshotFromSentinelSet(scores, golden, meta, options = {}) {
-	const tolerance = options.tolerance ?? .1;
-	if (!Number.isFinite(tolerance) || tolerance < 0) throw new ValidationError(`snapshotFromSentinelSet: tolerance must be a finite number ≥ 0, got ${tolerance}`);
-	const goldenById = /* @__PURE__ */ new Map();
-	for (const item of golden) {
-		if (!Number.isFinite(item.humanScore)) throw new ValidationError(`snapshotFromSentinelSet: golden item "${item.itemId}" has a non-finite humanScore`);
-		if (goldenById.has(item.itemId)) throw new ValidationError(`snapshotFromSentinelSet: duplicate golden itemId "${item.itemId}"`);
-		goldenById.set(item.itemId, item.humanScore);
-	}
-	let joined = 0;
-	let passed = 0;
-	for (const s of scores) {
-		const human = goldenById.get(s.itemId);
-		if (human === void 0) continue;
-		if (!Number.isFinite(s.score)) throw new ValidationError(`snapshotFromSentinelSet: judge score for item "${s.itemId}" is not finite`);
-		joined++;
-		if (Math.abs(s.score - human) <= tolerance) passed++;
-	}
-	if (joined === 0) throw new ValidationError("snapshotFromSentinelSet: no judge scores joined the golden set — itemIds mismatch or empty sentinel run");
-	const snapshot = {
-		...meta,
-		metrics: { sentinelPassRate: passed / joined }
-	};
-	validateSentinelSnapshot(snapshot);
-	return snapshot;
-}
-function inMemorySentinelStore(initial = []) {
-	for (const s of initial) validateSentinelSnapshot(s);
-	const items = initial.map((s) => ({
-		...s,
-		metrics: { ...s.metrics }
-	}));
-	return {
-		async append(snapshot) {
-			validateSentinelSnapshot(snapshot);
-			items.push({
-				...snapshot,
-				metrics: { ...snapshot.metrics }
-			});
-		},
-		async history(judgeId) {
-			const all = items.map((s) => ({
-				...s,
-				metrics: { ...s.metrics }
-			}));
-			return judgeId === void 0 ? all : all.filter((s) => s.judgeId === judgeId);
-		}
-	};
-}
-/**
-* JSONL store — one snapshot per line, appended atomically per call.
-* A corrupt or shape-invalid line is a loud error naming the file and
-* line number: a sentinel history that silently drops records would
-* defeat the drift detection it exists to provide.
-*/
-function fileSentinelStore(path) {
-	return {
-		async append(snapshot) {
-			validateSentinelSnapshot(snapshot);
-			const fs = await import("node:fs/promises");
-			const pathMod = await import("node:path");
-			await fs.mkdir(pathMod.dirname(path), { recursive: true });
-			await fs.appendFile(path, `${JSON.stringify(snapshot)}\n`, "utf8");
-		},
-		async history(judgeId) {
-			const fs = await import("node:fs/promises");
-			let raw;
-			try {
-				raw = await fs.readFile(path, "utf8");
-			} catch (err) {
-				if (err.code === "ENOENT") return [];
-				throw err;
-			}
-			const lines = raw.split("\n");
-			const snapshots = [];
-			for (let i = 0; i < lines.length; i++) {
-				const line = lines[i];
-				if (line.trim().length === 0) continue;
-				let parsed;
-				try {
-					parsed = JSON.parse(line);
-				} catch (err) {
-					throw new ValidationError(`judge-sentinel: store at ${path} has a corrupt JSONL line ${i + 1}: ${err.message}`);
-				}
-				const snapshot = parsed;
-				validateSentinelSnapshot(snapshot, `${path}:${i + 1}`);
-				snapshots.push(snapshot);
-			}
-			return judgeId === void 0 ? snapshots : snapshots.filter((s) => s.judgeId === judgeId);
-		}
-	};
-}
-const MS_PER_DAY = 864e5;
-function judgeSentinelReport(history, opts) {
-	const asOfMs = parseIso(opts.asOf, "asOf");
-	const minIrr = opts.thresholds?.minIrr ?? .6;
-	const maxKappaDrop = opts.thresholds?.maxKappaDrop ?? .15;
-	const maxSentinelDrop = opts.thresholds?.maxSentinelDrop ?? .1;
-	const staleAfterDays = opts.thresholds?.staleAfterDays ?? 30;
-	const byJudge = /* @__PURE__ */ new Map();
-	for (const snapshot of history) {
-		validateSentinelSnapshot(snapshot);
-		const atMs = parseIso(snapshot.at, `snapshot.at (judge "${snapshot.judgeId}")`);
-		const arr = byJudge.get(snapshot.judgeId) ?? [];
-		arr.push({
-			...snapshot,
-			atMs
-		});
-		byJudge.set(snapshot.judgeId, arr);
-	}
-	const perJudge = [];
-	const alarms = [];
-	const insufficientHistory = [];
-	for (const judgeId of [...byJudge.keys()].sort()) {
-		const snaps = byJudge.get(judgeId).sort((a, b) => a.atMs - b.atMs);
-		const newest = snaps[snaps.length - 1];
-		const ageDays = (asOfMs - newest.atMs) / MS_PER_DAY;
-		if (ageDays > staleAfterDays) alarms.push(`judge "${judgeId}": stale — newest snapshot ${newest.at} is ${ageDays.toFixed(1)}d old vs asOf (limit ${staleAfterDays}d)`);
-		let changeIdx = -1;
-		for (let i = 1; i < snaps.length; i++) if (snaps[i].judgeModel !== snaps[i - 1].judgeModel) changeIdx = i;
-		if (changeIdx >= 0) {
-			if (!snaps.slice(changeIdx).some((s) => Number.isFinite(s.metrics.calibrationKappa) || Number.isFinite(s.metrics.sentinelPassRate))) alarms.push(`judge "${judgeId}": model changed "${snaps[changeIdx - 1].judgeModel}" → "${snaps[changeIdx].judgeModel}" at ${snaps[changeIdx].at} with no post-change calibration snapshot — silent-upgrade trap; rerun calibrateJudge or the sentinel set against the new model`);
-		}
-		for (const metric of SENTINEL_METRIC_NAMES) {
-			const values = snaps.filter((s) => typeof s.metrics[metric] === "number").map((s) => s.metrics[metric]);
-			if (values.length === 0) continue;
-			const convergence = analyzeSeries(values, opts.convergence);
-			if (convergence.state === "insufficient-data") insufficientHistory.push(`${judgeId}:${metric}`);
-			const current = values[values.length - 1];
-			const baseline = values[0];
-			const drift = current - baseline;
-			const reasons = [];
-			if (convergence.state === "drifting-down") reasons.push(`convergence state drifting-down (tail run ${convergence.tailRun}, window mean ${convergence.windowMean.toFixed(3)})`);
-			if (metric === "irr" && current < minIrr) reasons.push(`irr ${current.toFixed(3)} below floor ${minIrr}`);
-			if (metric === "calibrationKappa" && baseline - current > maxKappaDrop) reasons.push(`calibrationKappa dropped ${(baseline - current).toFixed(3)} from baseline ${baseline.toFixed(3)} (limit ${maxKappaDrop})`);
-			if (metric === "sentinelPassRate" && baseline - current > maxSentinelDrop) reasons.push(`sentinelPassRate dropped ${(baseline - current).toFixed(3)} from baseline ${baseline.toFixed(3)} (limit ${maxSentinelDrop})`);
-			const alarmed = reasons.length > 0;
-			const trend = {
-				judgeId,
-				metric,
-				state: convergence.state,
-				current,
-				baseline,
-				drift,
-				alarmed
-			};
-			if (alarmed) {
-				trend.reason = reasons.join("; ");
-				alarms.push(`judge "${judgeId}" ${metric}: ${trend.reason}`);
-			}
-			perJudge.push(trend);
-		}
-	}
-	return {
-		perJudge,
-		alarms,
-		healthy: alarms.length === 0,
-		insufficientHistory
-	};
-}
-/**
-* The object a campaign attaches to its verdicts. Compute it from the
-* sentinel report in a post-campaign hook (or a nightly job feeding the
-* next day's campaigns) and store it alongside the verdict payload.
-* `healthy: false` means the judges that produced those verdicts have an
-* unresolved drift / decay / silent-upgrade / staleness alarm — treat the
-* verdicts as carrying an integrity warning until recalibration clears it.
-*/
-function evalHealthStamp(report) {
-	return {
-		healthy: report.healthy,
-		alarms: [...report.alarms]
-	};
-}
-//#endregion
-export { FileSystemOutcomeStore, InMemoryOutcomeStore, OutcomeStoreError, auditEvaluator, auditProbabilityPolicy, brierScore, calibrateJudge, calibrateJudgeContinuous, calibrationCurve, calibrationFromPairs, catchRate, clusterBootstrapMean, continuousAgreement, correlationStudy, definePlant, evalHealthStamp, evaluatorAdmissionPolicySchema, evaluatorAuditObservationSchema, fileSentinelStore, inMemorySentinelStore, judgeSentinelReport, multiclassBrierScore, perturbEvidence, planEvaluatorAudit, plantByPerturbation, positionalBias, rankedProbabilityScore, rubricPredictiveValidity, seedPlants, selfPreference, snapshotFromAgreement, snapshotFromCalibration, snapshotFromSentinelSet, validateSentinelSnapshot, verbosityBias };
+export { DEFAULT_JUDGE_GATE_POLICY, FileSystemOutcomeStore, InMemoryOutcomeStore, JudgeGateRefusedError, OutcomeStoreError, addCalibrationVerdicts, assertJudgeMayGate, auditEvaluator, auditProbabilityPolicy, brierScore, calibrateJudge, calibrateJudgeContinuous, calibrationCurve, calibrationFromPairs, catchRate, clusterBootstrapMean, continuousAgreement, correlationStudy, definePlant, evalHealthStamp, evaluatorAdmissionPolicySchema, evaluatorAuditObservationSchema, fileSentinelStore, inMemorySentinelStore, judgeGateDecision, judgeSentinelReport, measureJudgeAgreement, multiclassBrierScore, perturbEvidence, planEvaluatorAudit, plantByPerturbation, positionalBias, rankedProbabilityScore, registerCalibrationSet, rubricPredictiveValidity, seedPlants, selfPreference, snapshotFromAgreement, snapshotFromCalibration, snapshotFromJudgeAgreement, snapshotFromSentinelSet, validateSentinelSnapshot, verbosityBias };
 
 //# sourceMappingURL=index.js.map