@tangle-network/agent-eval 0.220.2 → 0.221.1

package/dist/index-DWd1gUwR.d.ts

@@ -0,0 +1,1086 @@
+import { a as JudgeError } from "./errors-DEE6u6ot.js";
+import { f as Run } from "./schema-D6EVKzTB.js";
+import { o as DimensionJudgeScore } from "./types-eMhdacVp.js";
+import { a as ContinuousCalibrationResult, i as ContinuousAgreementOptions, n as CandidateScore, o as GoldenItem, r as ContinuousAgreement, t as CalibrationResult } from "./judge-calibration-DFtEMlde.js";
+import { r as LedgerHash } from "./canonical-CFpojCN5.js";
+import { s as TraceStore } from "./store-B3nWRy3B.js";
+import { h as OutcomeStore, m as OutcomeFilter } from "./rubric-predictive-validity-Cd5SCtAf.js";
+import { t as ComputedInterval } from "./interval-ohuOJurX.js";
+import { z } from "zod";
+//#region src/statistics/agreement-irr.d.ts
+/**
+ * Inter-rater reliability — Krippendorff's α under the squared-difference
+ * metric, pooled across dimensions.
+ *
+ * Each inner array is one judge's scores. Items are matched by position
+ * WITHIN a dimension: the k-th score a judge supplies carrying dimension
+ * `d` is item k of `d`, and the ratings compared against each other are
+ * the ones different judges gave to the same item. Every judge that scores
+ * a dimension at all must supply the same number of scores for it —
+ * ragged input cannot be aligned into items and throws rather than
+ * comparing mismatched items.
+ *
+ * α = 1 − D_observed / D_expected: D_observed averages the squared
+ * difference over within-item judge pairs, D_expected over every pair of
+ * ratings irrespective of item. α = 1 is perfect agreement, 0 is chance,
+ * negative is systematic disagreement.
+ */
+declare function interRaterReliability(judgeScores: DimensionJudgeScore[][]): number;
+interface CorpusScoreRecord {
+  /** Stable identifier for the rated item (scenario, span, turn, …). */
+  itemId: string;
+  /** Identifier for the judge that produced this score. */
+  judgeName: string;
+  /** Dimension name (matches `DimensionJudgeScore.dimension`). */
+  dimension: string;
+  /** Numeric score; must be finite. */
+  score: number;
+}
+interface CorpusAgreementPerDimension extends ContinuousAgreement {
+  dimension: string;
+  /** Item IDs that contributed to this dimension's matrix (every judge scored them). */
+  itemIds: string[];
+  /** Judge IDs that contributed to this dimension's matrix. */
+  judgeIds: string[];
+}
+interface CorpusAgreementReport {
+  /** Per-dimension ICC(2,1) + κ_w + Pearson + Spearman + bootstrap CIs. */
+  perDimension: CorpusAgreementPerDimension[];
+  /** Mean ICC across dimensions (NaN if no dimension yielded a finite ICC). */
+  overallIcc: number;
+  /** Mean weighted κ across dimensions (NaN if none finite). */
+  overallWeightedKappa: number;
+  /** Dimensions evaluated (sorted). */
+  dimensions: string[];
+  /** Judges seen across the corpus (sorted). */
+  judgeIds: string[];
+}
+interface CorpusAgreementOptions extends ContinuousAgreementOptions {
+  /**
+   * Restrict the audit to these dimensions. Default = every dimension
+   * that appears in the input. A dimension named here but absent from
+   * the input throws — silent omission would corrupt the overall metric.
+   */
+  dimensions?: string[];
+  /**
+   * Restrict the audit to these judges. Default = every judge that
+   * appears in the input. A judge named here but absent from a
+   * dimension throws (see "fail loud" below).
+   */
+  judges?: string[];
+}
+/**
+ * Corpus-wide inter-rater agreement across N items × M judges × D dimensions.
+ *
+ * For each dimension, builds the [n_items][n_judges] matrix of scores
+ * (keeping only items every judge rated on that dimension), then runs
+ * `continuousAgreement` to get ICC(2,1), κ_w, Pearson, Spearman, and
+ * bootstrap CIs. Reports a pooled mean across dimensions as a single
+ * "is this judge panel reliable on this corpus?" number.
+ *
+ * Fail-loud contract:
+ *   - Empty input throws.
+ *   - Fewer than 2 judges or fewer than 2 items per dimension throws.
+ *   - A judge present in some dimensions but with zero scored items on
+ *     another dimension throws (would silently shrink the matrix).
+ *   - Duplicate (itemId, judgeName, dimension) records throw.
+ */
+declare function corpusInterRaterAgreement(records: CorpusScoreRecord[], opts?: CorpusAgreementOptions): CorpusAgreementReport;
+/**
+ * Convenience adapter for `DimensionJudgeScore[]` data keyed externally by item.
+ *
+ * Use when you have per-item arrays of `DimensionJudgeScore[]` (e.g. one
+ * `ScenarioResult.judgeScores` per scenario) and want corpus-wide
+ * agreement without manually flattening. `itemId` must be unique per
+ * row of `itemsScores`.
+ */
+declare function corpusInterRaterAgreementFromJudgeScores(itemsScores: Array<{
+  itemId: string;
+  scores: DimensionJudgeScore[];
+}>, opts?: CorpusAgreementOptions): CorpusAgreementReport;
+//#endregion
+//#region src/meta-eval/correlation-study.d.ts
+interface EvalMetricSpec {
+  id: string;
+  /** Extract a scalar from a run. Omit it and `id` must name one of
+   *  `RUN_METRICS`; any other `id` is refused. */
+  extract?: (run: Run, store: TraceStore) => Promise<number | null>;
+}
+interface OutcomePair {
+  evalMetric: string;
+  outcomeMetric: string;
+}
+interface CorrelationResult {
+  evalMetric: string;
+  outcomeMetric: string;
+  n: number;
+  pearson: number;
+  spearman: number;
+  /** 95% bootstrap CI for Pearson. */
+  pearsonCi95: {
+    lower: number;
+    upper: number;
+  } | null;
+  /** 95% bootstrap CI for Spearman; null when no resample is estimable. */
+  spearmanCi95: {
+    lower: number;
+    upper: number;
+  } | null;
+  /** Rough verdict: 'strong' ≥ 0.7, 'moderate' ≥ 0.4, else 'weak'. */
+  verdict: 'strong' | 'moderate' | 'weak';
+}
+interface CorrelationStudyResult {
+  pairs: CorrelationResult[];
+  /** Declared pairs without an estimable correlation, including their usable sample count. */
+  excludedPairs: Array<OutcomePair & {
+    n: number;
+    reason: 'insufficient_samples' | 'constant_eval_metric' | 'constant_outcome';
+  }>;
+  joinedSamples: number;
+  skippedRuns: number;
+}
+interface CorrelationStudyOptions {
+  /** Only join outcomes captured within this window after run.startedAt. */
+  maxCaptureLagMs?: number;
+  /** Restrict to a subset of outcomes (cohort, region, source). */
+  outcomeFilter?: OutcomeFilter;
+  /** Which outcome per run to use when multiple exist. Default 'latest'. */
+  reduction?: 'latest' | 'mean' | 'max';
+  /** Bootstrap iterations for the CI. Default 500. */
+  bootstrapIterations?: number;
+  /** Seed for the bootstrap resampler. Absent, the seed is derived from the
+   *  paired observations, so the same study reproduces the same interval. */
+  seed?: number;
+}
+declare function correlationStudy(traceStore: TraceStore, outcomeStore: OutcomeStore, evalMetrics: EvalMetricSpec[], outcomeMetricNames: string[], options?: CorrelationStudyOptions): Promise<CorrelationStudyResult>;
+//#endregion
+//#region src/meta-eval/calibration.d.ts
+interface CalibrationBin {
+  lower: number;
+  upper: number;
+  n: number;
+  evalMean: number;
+  outcomeMean: number;
+  /** |outcomeMean − evalMean|; contributes to ECE weighted by n/total. */
+  gap: number;
+}
+interface CalibrationReport {
+  evalMetric: string;
+  outcomeMetric: string;
+  n: number;
+  bins: CalibrationBin[];
+  /** Expected Calibration Error — Σ (n_i/N) × |outcomeMean_i − evalMean_i|. */
+  ece: number;
+  /** Largest observed difference between a bin's mean score and mean outcome. */
+  maxGap: number;
+}
+interface CalibrationOptions {
+  /** Positive integer; empty bins are omitted. Default 10. */
+  bins?: number;
+  /** Equal-width (fixed bin edges) or equal-frequency (quantile bins). */
+  binning?: 'equal-width' | 'equal-frequency';
+  /** Clip eval values to [lo, hi] before binning. */
+  range?: {
+    lo: number;
+    hi: number;
+  };
+}
+interface CalibrationPair {
+  evalScore: number;
+  outcome: number;
+}
+declare function calibrationCurve(traceStore: TraceStore, outcomeStore: OutcomeStore, evalMetric: EvalMetricSpec, outcomeMetric: string, options?: CalibrationOptions): Promise<CalibrationReport | null>;
+/** Measure already joined observations without constructing trace and outcome stores. */
+declare function calibrationFromPairs(inputPairs: readonly CalibrationPair[], evalMetric: string, outcomeMetric: string, options?: CalibrationOptions): CalibrationReport | null;
+/**
+ * Mean squared error of probability forecasts against binary outcomes, Σ(p − y)²/N; always
+ * forecasting 0.5 scores 0.25. For the reliability table and ECE use `calibrationFromPairs`
+ * with `range: { lo: 0, hi: 1 }` (`binning: 'equal-frequency'` gives equal-mass bins).
+ */
+declare function brierScore(pairs: readonly CalibrationPair[]): number;
+/** One categorical forecast: a distribution over named outcomes and the outcome that occurred. */
+interface CategoricalForecast {
+  /** Probability per outcome name. Must sum to 1 within 1e-6 and include `outcome`. */
+  probabilities: Readonly<Record<string, number>>;
+  outcome: string;
+}
+/**
+ * Multiclass Brier score in its sum form, mean over forecasts of Σₖ(pₖ − yₖ)², range [0, 2].
+ * With two outcomes it is twice the binary `brierScore`. A uniform forecast over K outcomes
+ * scores 1 − 1/K. The distribution is not renormalized here: repair provider rounding before
+ * scoring (`normalizeSystemOneResult` in `/systemone/protocol`), so a defective answer stays
+ * visible instead of being scored as if it were valid.
+ */
+declare function multiclassBrierScore(forecasts: readonly CategoricalForecast[]): number;
+/** One ordinal forecast: probabilities in level order, lowest level first. */
+interface OrdinalForecast {
+  probabilities: readonly number[];
+  /** Index into `probabilities` of the level that occurred. */
+  outcome: number;
+}
+/**
+ * Ranked probability score, mean over forecasts of Σₖ₌₁ᴷ⁻¹(Fₖ − Oₖ)² / (K − 1), where F and O are
+ * the cumulative forecast and observation, range [0, 1]. Unlike multiclass Brier it charges
+ * less for mass on a level next to the outcome than for mass far from it, which is the right
+ * penalty for score questions. With two levels it equals the binary Brier score.
+ */
+declare function rankedProbabilityScore(forecasts: readonly OrdinalForecast[]): number;
+//#endregion
+//#region src/meta-eval/cluster-bootstrap.d.ts
+/** One observation and the source cluster it belongs to. */
+interface ClusteredObservation {
+  cluster: string;
+  value: number;
+}
+interface ClusterBootstrapOptions {
+  /** Confidence level. Default 0.95. */
+  confidence?: number;
+  /** Bootstrap resample count. Default 2000. */
+  resamples?: number;
+  /** Deterministic seed. If omitted, derived from the values so the interval is reproducible. */
+  seed?: number;
+}
+interface ClusterBootstrapResult {
+  n: number;
+  clusters: number;
+  /** Mean over observations, each observation weighted equally. */
+  mean: number;
+  low: number;
+  high: number;
+  confidence: number;
+  resamples: number;
+}
+/**
+ * Percentile cluster bootstrap of an observation mean. Whole clusters are resampled with
+ * replacement and each resample's statistic is Σ values / Σ observations over the drawn
+ * clusters, so observations that share a source move together and a large cluster cannot
+ * pose as many independent results. For a paired comparison pass the per-observation
+ * difference (candidate − baseline) under the observation's cluster.
+ *
+ * With one cluster the interval collapses to the point estimate: there is no between-cluster
+ * spread to measure, which callers must treat as no interval, not as certainty.
+ */
+declare function clusterBootstrapMean(observations: readonly ClusteredObservation[], options?: ClusterBootstrapOptions): ClusterBootstrapResult;
+//#endregion
+//#region src/meta-eval/evaluator-admission.d.ts
+declare const evaluatorAdmissionPolicySchema: z.ZodObject<{
+  confidence: z.ZodNumber;
+  maxFalseAcceptanceRate: z.ZodNumber;
+  maxFalseRejectionRate: z.ZodNumber;
+}, z.core.$strict>;
+/** Register both error limits before inspecting audit judgments. */
+type EvaluatorAdmissionPolicy = z.infer<typeof evaluatorAdmissionPolicySchema>;
+declare const evaluatorAuditObservationSchema: z.ZodObject<{
+  id: z.ZodString;
+  independentUnitId: z.ZodString;
+  evidenceRef: z.ZodString;
+  expected: z.ZodEnum<{
+    accept: "accept";
+    reject: "reject";
+  }>;
+  observed: z.ZodEnum<{
+    accept: "accept";
+    reject: "reject";
+    unknown: "unknown";
+  }>;
+  exposure: z.ZodEnum<{
+    development: "development";
+    fresh: "fresh";
+  }>;
+}, z.core.$strict>;
+/** Actual control judgments. Variants from one source retain one independent identity. */
+type EvaluatorAuditObservation = z.infer<typeof evaluatorAuditObservationSchema>;
+declare const inputSchema: z.ZodObject<{
+  evaluatorDigest: z.ZodString;
+  population: z.ZodString;
+  samplingFrame: z.ZodString;
+  authority: z.ZodObject<{
+    evaluatorAuthorId: z.ZodString;
+    auditorId: z.ZodString;
+    independenceEvidenceRef: z.ZodString;
+  }, z.core.$strict>;
+  policy: z.ZodObject<{
+    confidence: z.ZodNumber;
+    maxFalseAcceptanceRate: z.ZodNumber;
+    maxFalseRejectionRate: z.ZodNumber;
+  }, z.core.$strict>;
+  observations: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    independentUnitId: z.ZodString;
+    evidenceRef: z.ZodString;
+    expected: z.ZodEnum<{
+      accept: "accept";
+      reject: "reject";
+    }>;
+    observed: z.ZodEnum<{
+      accept: "accept";
+      reject: "reject";
+      unknown: "unknown";
+    }>;
+    exposure: z.ZodEnum<{
+      development: "development";
+      fresh: "fresh";
+    }>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type EvaluatorAuditInput = z.infer<typeof inputSchema>;
+interface EvaluatorErrorRate {
+  /** Eligible control judgments in this class, including unknown judgments. */
+  cases: number;
+  independentUnits: number;
+  /** Units with at least one observed mistake. */
+  errorUnits: number;
+  /** Units with unknown judgments and no observed mistake yet. */
+  unresolvedUnits: number;
+  unknownCases: number;
+  /** Missing judgments do not become measured zeros. */
+  errorRate: number | null;
+  /** Exact bounds conservatively include every possible outcome of unknown judgments. */
+  interval: ComputedInterval | null;
+  limit: number;
+  verdict: 'pass' | 'fail' | 'inconclusive';
+}
+interface EvaluatorAdmissionReport {
+  evaluatorDigest: LedgerHash;
+  policyDigest: LedgerHash;
+  inputDigest: LedgerHash;
+  reportDigest: LedgerHash;
+  population: string;
+  samplingFrame: string;
+  authority: EvaluatorAuditInput['authority'];
+  policy: EvaluatorAdmissionPolicy;
+  /** Joint coverage for the two reported error-rate intervals. */
+  confidence: number;
+  intervalConfidence: number;
+  verdict: 'admit' | 'reject' | 'inconclusive';
+  reasons: string[];
+  observations: EvaluatorAuditObservation[];
+  coverage: {
+    cases: number;
+    independentUnits: number;
+    eligibleCases: number;
+    eligibleIndependentUnits: number;
+    excludedCases: number;
+    unknownCases: number;
+  };
+  exclusions: Array<{
+    id: string;
+    independentUnitId: string;
+    reason: 'development-exposure';
+  }>;
+  falseAcceptance: EvaluatorErrorRate;
+  falseRejection: EvaluatorErrorRate;
+}
+declare const capacitySchema: z.ZodObject<{
+  policy: z.ZodObject<{
+    confidence: z.ZodNumber;
+    maxFalseAcceptanceRate: z.ZodNumber;
+    maxFalseRejectionRate: z.ZodNumber;
+  }, z.core.$strict>;
+  controls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    independentUnitId: z.ZodString;
+    expected: z.ZodEnum<{
+      accept: "accept";
+      reject: "reject";
+    }>;
+    exposure: z.ZodEnum<{
+      development: "development";
+      fresh: "fresh";
+    }>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+type EvaluatorAuditPlanInput = z.input<typeof capacitySchema>;
+/**
+ * Can the fixed control roster meet the policy even with zero errors?
+ * Planning uses the admission rule's exact bounds and source-unit exclusions.
+ * It accepts no judgments or authority and returns no admission report.
+ */
+declare function planEvaluatorAudit(input: EvaluatorAuditPlanInput): {
+  sufficient: boolean;
+  falseAcceptance: {
+    independentUnits: number;
+    bestPossibleUpperBound: number | null;
+    limit: number;
+    minimumIndependentUnits: number | null;
+    additionalIndependentUnits: number | null;
+  };
+  falseRejection: {
+    independentUnits: number;
+    bestPossibleUpperBound: number | null;
+    limit: number;
+    minimumIndependentUnits: number | null;
+    additionalIndependentUnits: number | null;
+  };
+};
+type EvaluatorAuditPlan = ReturnType<typeof planEvaluatorAudit>;
+/**
+ * Audit frozen judgments using independent source units and exact binomial bounds.
+ * A unit fails a class when any control in that class is misjudged.
+ * The execution owner enforces auditor separation, fresh sampling, and evidence authenticity.
+ */
+declare function auditEvaluator(input: EvaluatorAuditInput): EvaluatorAdmissionReport;
+declare const probabilityAuditSchema: z.ZodObject<{
+  evaluatorDigest: z.ZodString;
+  population: z.ZodString;
+  samplingFrame: z.ZodString;
+  authority: z.ZodObject<{
+    evaluatorAuthorId: z.ZodString;
+    auditorId: z.ZodString;
+    independenceEvidenceRef: z.ZodString;
+  }, z.core.$strict>;
+  policy: z.ZodObject<{
+    confidence: z.ZodNumber;
+    maxFalseAcceptanceRate: z.ZodNumber;
+    maxFalseRejectionRate: z.ZodNumber;
+  }, z.core.$strict>;
+  thresholds: z.ZodObject<{
+    rejectAtOrBelow: z.ZodNumber;
+    acceptAtOrAbove: z.ZodNumber;
+  }, z.core.$strict>;
+  observations: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    independentUnitId: z.ZodString;
+    evidenceRef: z.ZodString;
+    expected: z.ZodEnum<{
+      accept: "accept";
+      reject: "reject";
+    }>;
+    exposure: z.ZodEnum<{
+      development: "development";
+      fresh: "fresh";
+    }>;
+    acceptProbability: z.ZodNullable<z.ZodNumber>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+/** A frozen caller-owned rule over P(accept), not the provider's entropy/confidence statistic. */
+type ProbabilityPolicyAuditInput = z.infer<typeof probabilityAuditSchema>;
+interface ProbabilityPolicyAuditReport extends EvaluatorAdmissionReport {
+  probabilityPolicy: {
+    sourceEvaluatorDigest: LedgerHash;
+    thresholds: ProbabilityPolicyAuditInput['thresholds'];
+    /** Retain probabilities by observation id so the reported mapping can be reproduced. */
+    observations: Array<{
+      id: string;
+      acceptProbability: number | null;
+    }>;
+  };
+}
+/**
+ * Audit a fixed probability-to-decision rule with the existing independent-unit error bounds.
+ * No threshold search, model calls, promotion, or assumption of calibrated probabilities.
+ * Null scores and the open interval between thresholds remain unknown, never correct by default.
+ */
+declare function auditProbabilityPolicy(input: ProbabilityPolicyAuditInput): ProbabilityPolicyAuditReport;
+//#endregion
+//#region src/series-convergence.d.ts
+/**
+ * Series convergence — detects whether a sequence of scalar measurements
+ * is stabilizing, drifting, or noisy. It reads drift *across* runs, e.g.
+ * "are my nightly eval scores stabilizing?".
+ *
+ * Three signals:
+ *   - stabilized: last K values have low variance (< epsilon) — done
+ *   - drifting:   recent trend is monotonic and beyond noise — regressing or improving
+ *   - noisy:      neither — keep iterating, but flag as untrustworthy for gating
+ */
+interface SeriesConvergenceOptions {
+  /** Window size for "recent" analysis (default 5). */
+  window?: number;
+  /** Coefficient-of-variation threshold below which the window is stabilized (default 0.05 = 5%). */
+  stableCv?: number;
+  /** Minimum monotone run length to call drift (default 3). */
+  driftRun?: number;
+}
+interface SeriesConvergenceResult {
+  state: 'stabilized' | 'drifting-up' | 'drifting-down' | 'noisy' | 'insufficient-data';
+  windowMean: number;
+  windowCv: number;
+  /** Longest monotonic run at the tail of the series (positive for up, negative for down). */
+  tailRun: number;
+  /** True when n ≥ window AND windowCv ≤ stableCv. */
+  stable: boolean;
+}
+declare function analyzeSeries(values: number[], options?: SeriesConvergenceOptions): SeriesConvergenceResult;
+//#endregion
+//#region src/meta-eval/sentinel.d.ts
+declare const SENTINEL_METRIC_NAMES: readonly ['irr', 'calibrationKappa', 'sentinelPassRate'];
+type SentinelMetricName = (typeof SENTINEL_METRIC_NAMES)[number];
+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;
+}
+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. */
+interface SnapshotMeta {
+  at: string;
+  judgeId: string;
+  judgeModel: string;
+}
+/** Shape guard for snapshots crossing a boundary (store append, JSONL load, report input). */
+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).
+ */
+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).
+ */
+declare function snapshotFromAgreement(report: CorpusAgreementReport | ContinuousAgreement, meta: SnapshotMeta): SentinelSnapshot;
+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.
+ */
+declare function snapshotFromSentinelSet(scores: CandidateScore[], golden: GoldenItem[], meta: SnapshotMeta, options?: SentinelSetOptions): SentinelSnapshot;
+interface SentinelStore {
+  append(snapshot: SentinelSnapshot): Promise<void>;
+  /** All snapshots (optionally for one judge), in append order. */
+  history(judgeId?: string): Promise<SentinelSnapshot[]>;
+}
+/**
+ * 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.
+ */
+declare function fileSentinelStore(path: string): SentinelStore;
+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;
+}
+interface JudgeSentinelOptions {
+  /** Caller-supplied ISO timestamp staleness is measured against. */
+  asOf: string;
+  thresholds?: SentinelThresholds;
+  /** Forwarded to `analyzeSeries` (window, stableCv, driftRun). */
+  convergence?: SeriesConvergenceOptions;
+}
+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;
+}
+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[];
+}
+declare function judgeSentinelReport(history: SentinelSnapshot[], opts: JudgeSentinelOptions): SentinelReport;
+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.
+ */
+declare function evalHealthStamp(report: SentinelReport): EvalHealthStamp;
+//#endregion
+//#region src/meta-eval/judge-gate.d.ts
+type OwnerVerdict = 'pass' | 'fail';
+/** One item the owner decided, with where that decision is recorded. */
+interface CalibrationExample {
+  /** Stable id of the decided item; a judge run names it in `exampleId`. */
+  id: string;
+  verdict: OwnerVerdict;
+  /** The person whose verdict this is. Never a model. */
+  labeledBy: string;
+  /** ISO-8601 time the verdict was given. */
+  labeledAt: string;
+  /** Where the verdict is recorded, e.g. `gtm:asset_decision:<id>`. */
+  source: string;
+  /** What the owner judged (an image digest, a run id), so a replay judges the same thing. */
+  evidenceRef?: string;
+  note?: string;
+}
+interface JudgeCalibrationSet {
+  judgeId: string;
+  /** Whose verdicts the judge stands in for. */
+  owner: string;
+  examples: readonly CalibrationExample[];
+}
+/**
+ * Validate a calibration set and return a normalized copy ordered by example
+ * id. Every verdict needs its person, time and source; ids are unique.
+ */
+declare function registerCalibrationSet(set: JudgeCalibrationSet): JudgeCalibrationSet;
+interface CalibrationMerge {
+  set: JudgeCalibrationSet;
+  /** Ids that joined the set. */
+  added: string[];
+  /** Ids whose verdict a later decision replaced. */
+  superseded: string[];
+  /** Ids whose incoming verdict was already recorded, or older than the recorded one. */
+  unchanged: string[];
+}
+/**
+ * Join new owner verdicts to a set. A verdict already recorded from the same
+ * source is unchanged, so ingestion can rerun. A later verdict on an item
+ * replaces an earlier one: the owner changed their mind, and the set keeps
+ * what they decided last.
+ */
+declare function addCalibrationVerdicts(set: JudgeCalibrationSet, verdicts: readonly CalibrationExample[]): CalibrationMerge;
+/** One gate decision the judge made on a calibration example. */
+interface JudgeRun {
+  exampleId: string;
+  /** The judge's decision after its own sample aggregation (median, majority). */
+  verdict: OwnerVerdict;
+  /** The per-sample verdicts behind that decision, when the judge samples. */
+  samples?: readonly OwnerVerdict[];
+}
+interface JudgeRunMeta {
+  judgeId: string;
+  /** Exact model identity, or `deterministic` for a grader without one. */
+  judgeModel: string;
+  rubricVersion: string;
+  measuredAt: string;
+}
+interface JudgeConfusion {
+  /** Judge pass, owner pass. */
+  truePass: number;
+  /** Judge fail, owner fail. */
+  trueFail: number;
+  /** Judge pass, owner fail: the judge let through what the owner rejected. */
+  falsePass: number;
+  /** Judge fail, owner pass: the judge blocked what the owner accepted. */
+  falseFail: number;
+}
+interface JudgeExampleAgreement {
+  id: string;
+  verdict: OwnerVerdict;
+  runs: number;
+  /** Share of runs that passed. */
+  passRate: number;
+  /** Share of runs that reached the owner's verdict. */
+  agreement: number;
+}
+interface JudgeAgreement extends JudgeRunMeta {
+  owner: string;
+  /** Examples in the calibration set. */
+  examples: number;
+  /** Examples the judge ran on at least once. */
+  judged: number;
+  /** Judged examples per owner verdict. */
+  judgedByVerdict: Record<OwnerVerdict, number>;
+  runs: number;
+  /** Runs that reached the owner's verdict, over all runs; null with no runs. */
+  accuracy: number | null;
+  /**
+   * Exact (Clopper-Pearson) 95% interval for the share of judged examples on
+   * which every run reached the owner's verdict. Examples, not runs, are the
+   * independent units.
+   */
+  exampleAccuracy: {
+    agreed: number;
+    judged: number;
+    interval: ComputedInterval;
+  } | null;
+  /**
+   * Cohen's κ between the judge and the owner over runs. Null when undefined:
+   * no runs, or both sides used a single verdict.
+   */
+  kappa: number | null;
+  /** Runs that failed what the owner passed, over runs on owner passes; null with none. A veto judge is held to this. */
+  falseFailRate: number | null;
+  /** Runs that failed what the owner failed, over runs on owner fails; null with none. */
+  catchRate: number | null;
+  confusion: JudgeConfusion;
+  variance: {
+    /** Mean over judged examples of p(1 − p), p the example's run pass rate. 0 = no run changed its mind. */
+    betweenRuns: number | null;
+    /** Mean over runs that reported samples of p(1 − p) across those samples; null when none did. */
+    withinRun: number | null;
+    /** Examples whose runs disagree with each other. */
+    unstable: string[];
+  };
+  /** Examples with at least one run against the owner, least agreement first. */
+  disagreements: JudgeExampleAgreement[];
+  /** Examples without any run. */
+  unjudged: string[];
+}
+/**
+ * Agreement between a judge's runs and the owner's verdicts on one
+ * calibration set. A run that names an example outside the set is an error:
+ * a silently dropped run would overstate agreement.
+ */
+declare function measureJudgeAgreement(set: JudgeCalibrationSet, runs: readonly JudgeRun[], meta: JudgeRunMeta): JudgeAgreement;
+interface JudgeGatePolicy {
+  /**
+   * `verdict`: the judge passes and blocks, so accuracy and κ must hold.
+   * `veto`: it only blocks, so its false-fail rate on owner passes must hold.
+   */
+  decides: 'verdict' | 'veto';
+  /** Judged examples required before the judge may gate; for a veto judge, owner passes. */
+  minExamples: number;
+  /** Judged examples required of each owner verdict, so κ is defined. */
+  minPerVerdict: number;
+  /** Floor on run accuracy. */
+  minAccuracy: number;
+  /** Floor on Cohen's κ. */
+  minKappa: number;
+  /** Ceiling on a veto judge's false-fail rate. */
+  maxFalseFailRate: number;
+  /** A report older than this (days, vs `asOf`) no longer calibrates the judge. */
+  maxAgeDays: number;
+  /** Drift thresholds forwarded to `judgeSentinelReport` over the history. */
+  drift?: SentinelThresholds;
+}
+declare const DEFAULT_JUDGE_GATE_POLICY: Readonly<JudgeGatePolicy>;
+type JudgeGateStatus = 'calibrated' | 'uncalibrated' | 'below-threshold' | 'drifted';
+interface JudgeGateDecision {
+  judgeId: string;
+  judgeModel: string;
+  rubricVersion: string;
+  /** True only for `calibrated`. */
+  mayGate: boolean;
+  status: JudgeGateStatus;
+  /** Why the judge may not gate; empty when it may. */
+  reasons: string[];
+  agreement: JudgeAgreement | null;
+  policy: JudgeGatePolicy;
+}
+interface JudgeGateInput {
+  judgeId: string;
+  /** The model the judge runs now. */
+  judgeModel: string;
+  /** The rubric the judge runs now. */
+  rubricVersion: string;
+  /** The latest calibration report; null when the judge was never measured. */
+  agreement: JudgeAgreement | null;
+  asOf: string;
+  /** Sentinel snapshots for this judge, oldest first or in any order. */
+  history?: readonly SentinelSnapshot[];
+  policy?: Partial<JudgeGatePolicy>;
+}
+/** Whether a judge may gate now, and every reason it may not. */
+declare function judgeGateDecision(input: JudgeGateInput): JudgeGateDecision;
+/** Thrown by `assertJudgeMayGate`; carries the refused decision. */
+declare class JudgeGateRefusedError extends JudgeError {
+  readonly decision: JudgeGateDecision;
+  constructor(decision: JudgeGateDecision);
+}
+/** Throw unless the decision lets the judge gate. */
+declare function assertJudgeMayGate(decision: JudgeGateDecision): void;
+/**
+ * The sentinel snapshot for one calibration run. A deciding judge records
+ * accuracy as `sentinelPassRate` and κ as `calibrationKappa` when it is
+ * defined; a veto judge records the share of owner passes it let through as
+ * `sentinelPassRate`. Append it to the judge's `SentinelStore`; the gate reads
+ * drift from that history.
+ */
+declare function snapshotFromJudgeAgreement(agreement: JudgeAgreement, options?: {
+  decides?: JudgeGatePolicy['decides'];
+}): SentinelSnapshot;
+//#endregion
+//#region src/meta-eval/plants.d.ts
+/**
+ * How a plant item was authored wrong. The class is reported separately in
+ * {@link CatchRateReport.byKind} because a grader is routinely sharp on one
+ * and blind to another.
+ */
+type PlantKind =
+/** A load-bearing value is altered: a number off by one, a comparison flipped. */
+'wrong-value' |
+/** The item carries its own check, and that check passes without testing the claim. */
+'self-certifying' |
+/** The check names an input that does not exist, so it cannot run at all. */
+'unreachable-input' |
+/** A copy of an item already in the set, which is owed a duplicate flag rather than a second grade. */
+'duplicate';
+/** What a working grader owes a seeded item. */
+type PlantExpectation = 'reject' | 'accept';
+interface Plant {
+  /** Name of the plant record. Reported in `missedIds` and `missingIds`. */
+  id: string;
+  kind: PlantKind;
+  /** The seeded item, indistinguishable from a real one once mixed. */
+  item: GoldenItem;
+  /** The verdict a working grader owes this item. */
+  expectedVerdict: PlantExpectation;
+}
+/**
+ * Build one plant record and refuse an incoherent one.
+ *
+ * The refusal that matters is the last: a record whose `expectedVerdict`
+ * disagrees with `item.humanScore` inverts the measurement silently, because
+ * the same item then reads as wrong here and as correct to every calibration
+ * instrument that joins on the id.
+ *
+ * `item` is copied field by field so a later mutation of the caller's object
+ * cannot change what the manifest sealed, and `group` is dropped when it is
+ * absent so the record always has a canonical JSON form.
+ */
+declare function definePlant(input: {
+  id: string;
+  kind: PlantKind;
+  item: GoldenItem;
+  expectedVerdict: PlantExpectation;
+}): Plant;
+/**
+ * A claim's executable evidence: the command a grader runs and the output it
+ * must produce.
+ */
+interface PlantEvidence {
+  /** The command a grader runs to test the claim. */
+  check?: string;
+  /** The output that command must produce for the claim to stand. */
+  expect?: string;
+}
+/** Which evidence field {@link perturbEvidence} altered. */
+type PerturbedField = 'check' | 'expect';
+/** How {@link perturbEvidence} altered it. */
+type PerturbationKind = 'number-off-by-one' | 'comparison-flipped';
+interface EvidencePerturbation {
+  /** The evidence with exactly one value altered. */
+  evidence: PlantEvidence;
+  /** Which field changed. */
+  field: PerturbedField;
+  /** How it changed. */
+  how: PerturbationKind;
+  /**
+   * The exact substring that was replaced. A comparison token carries its
+   * surrounding spaces, because the spaces are what make ` -ge ` a comparison
+   * and not part of a word.
+   */
+  original: string;
+  /** What replaced it. */
+  perturbed: string;
+}
+/**
+ * Derive a known-wrong version of a claim's evidence by altering exactly one
+ * value, or return null when no value can be altered safely.
+ *
+ * Exactly one value changes. A perturbation that moves two does not name the
+ * defect it seeded, so a grader that catches it says nothing about which defect
+ * the grader can see.
+ *
+ * The preference order IS the safety order:
+ *
+ * 1. the last standalone number in `expect` — it falsifies the claim while the
+ *    command still runs exactly as it did;
+ * 2. a flipped comparison in `check` — it inverts a test that was passing;
+ * 3. the last standalone number in `check` — last because a number in a command
+ *    can name an input (a port, a width, a version) rather than a threshold,
+ *    and renaming an input breaks execution, not the claim.
+ *
+ * "Standalone" excludes a digit run glued to a word, a dot, a slash, or a
+ * hyphen: `python3`, `file42.txt`, `1.5`, `utf-8`. That exclusion is why this
+ * helper exists. Hand-rolled perturbation bumps one of those, the check stops
+ * executing, and the plant measures the environment instead of the grader.
+ *
+ * A number is bumped with BigInt, so a value wider than
+ * `Number.MAX_SAFE_INTEGER` moves by exactly one. Bumped as a `number` it
+ * rounds back to itself, and the plant is then a correct claim the grader is
+ * right to verify.
+ */
+declare function perturbEvidence(evidence: PlantEvidence): EvidencePerturbation | null;
+interface PerturbedPlant {
+  plant: Plant;
+  /** The perturbed evidence to write into the item the grader is handed. */
+  evidence: PlantEvidence;
+  field: PerturbedField;
+  how: PerturbationKind;
+  original: string;
+  perturbed: string;
+}
+/**
+ * Derive a reject-direction plant from a claim a grader verified, by perturbing
+ * one value.
+ *
+ * {@link definePlant} takes a {@link GoldenItem} and never authors a wrong item
+ * from a right one, so until now every caller hand-rolled the perturbation.
+ * This is that step, done once and the same way every time: the claim's
+ * evidence is altered by {@link perturbEvidence}, the result is a `wrong-value`
+ * plant the grader owes a `reject`, and the record itself is built by
+ * `definePlant` so every refusal there still applies — in particular the one
+ * that catches an `expectedVerdict` its `humanScore` contradicts.
+ *
+ * Returns null when nothing in the evidence can be perturbed. That is not a
+ * failure: a claim with no executable evidence cannot be made wrong in a way a
+ * grader could execute, and seeding it would measure prose.
+ *
+ * Refuses an empty `id` or `itemId`. Both name the record — one in the manifest
+ * and in `missedIds`, the other in the join with the results — and a miss
+ * nobody can look up is not a measurement.
+ */
+declare function plantByPerturbation(input: {
+  id: string;
+  itemId: string;
+  evidence: PlantEvidence;
+  /** Score for the perturbed item. Must sit below the run's accept threshold. Default 0. */
+  humanScore?: number;
+  group?: string;
+}): PerturbedPlant | null;
+interface PlantManifest {
+  /**
+   * Digest over the seeded order, the plants, and the threshold. Publish it
+   * before the grading run: a manifest edited afterwards to match the results
+   * no longer matches its seal, and {@link catchRate} refuses it.
+   */
+  seal: LedgerHash;
+  /** The seed that fixed the mix order. */
+  seed: number;
+  /** The grade at or above which the graded policy's own gate accepts an item. */
+  acceptThreshold: number;
+  /** Every item id in the seeded set, in the order handed out. */
+  itemIds: string[];
+  /** The seeded plants. This is the answer key; keep it out of the graded workspace. */
+  plants: Plant[];
+}
+interface SeededGradingSet {
+  /**
+   * The mixed set in seeded order. Operator-side: it still carries every
+   * item's `humanScore`, so hand the graded policy the payload each `itemId`
+   * names, never this array.
+   */
+  items: GoldenItem[];
+  manifest: PlantManifest;
+}
+interface SeedPlantsOptions {
+  /**
+   * Fixes the mix order. The same dataset, plants, threshold, and seed always
+   * produce the same seeded order and the same seal.
+   */
+  seed?: number;
+  /**
+   * The grade at or above which the graded policy's own gate accepts an item.
+   * Supply the threshold your gate uses; the default suits a judge scoring in
+   * [0, 1] with a pass at the midpoint.
+   */
+  acceptThreshold?: number;
+}
+/**
+ * Mix plants into a grading set and seal which items they are.
+ *
+ * Refusals: a duplicate id anywhere in the mixed set (the join is by id, so a
+ * repeat makes one of the two unscoreable), a plant whose item id collides
+ * with a dataset item (it would shadow real work and grade it as a plant), a
+ * dataset item with no usable label, and a plant whose expectation the run's
+ * `acceptThreshold` contradicts.
+ */
+declare function seedPlants(dataset: readonly GoldenItem[], plants: readonly Plant[], options?: SeedPlantsOptions): SeededGradingSet;
+/**
+ * One grader outcome for one item. `score: null` says the grader ran and
+ * declined to decide — the check never tested the item's defect. Any
+ * `CandidateScore` from a judge run is already a valid outcome.
+ */
+interface PlantOutcome {
+  itemId: string;
+  score: number | null;
+}
+/**
+ * `evaluated` — a rate stands. `incomplete` — a seeded id had no result.
+ * `not_evaluated` — nothing was seeded, or nothing seeded was decided.
+ */
+type CatchRateStatus = 'evaluated' | 'incomplete' | 'not_evaluated';
+interface PlantKindCounts {
+  seeded: number;
+  caught: number;
+  missed: number;
+  indecisive: number;
+  /** caught / (caught + missed), or null when the report is not `evaluated`. */
+  rate: number | null;
+}
+/**
+ * How the same grader treated the unseeded items of the same set. No labels
+ * are needed to read it: a grader that refuses everything scores `rate` 1.0
+ * on reject-plants, and a `rejectionRate` of 1.0 here is what separates that
+ * reflex from discrimination.
+ */
+interface UnseededRejection {
+  n: number;
+  decided: number;
+  rejected: number;
+  /** rejected / decided, or null when nothing unseeded was decided. */
+  rejectionRate: number | null;
+}
+interface CatchRateReport {
+  status: CatchRateStatus;
+  /** Why the status is not `evaluated`. Absent when it is. */
+  reason?: string;
+  seeded: number;
+  caught: number;
+  missed: number;
+  /**
+   * The grader returned a result and declined to decide. Counted apart: it
+   * enters neither side of `rate`.
+   */
+  indecisive: number;
+  /** caught / (caught + missed), or null unless the status is `evaluated`. */
+  rate: number | null;
+  /** One entry per kind actually seeded. A kind nobody seeded is absent, never zero. */
+  byKind: Partial<Record<PlantKind, PlantKindCounts>>;
+  /** Plant ids the grader graded as the seed says it must not. */
+  missedIds: string[];
+  /** Plant ids with no result at all — the reason a status is `incomplete`. */
+  missingIds: string[];
+  unseeded: UnseededRejection;
+}
+/**
+ * Score a grading run against its sealed manifest.
+ *
+ * Refusals: a manifest whose contents no longer match its seal, a result for
+ * an id the manifest never handed out, and a repeated result id. Each says
+ * the results and the manifest describe different runs, and a rate computed
+ * across two runs is a fabrication.
+ */
+declare function catchRate(results: readonly PlantOutcome[], manifest: PlantManifest): CatchRateReport;
+//#endregion
+export { SnapshotMeta as $, JudgeGateInput as A, CalibrationPair as At, measureJudgeAgreement as B, CorrelationStudyOptions as Bt, CalibrationMerge as C, planEvaluatorAudit as Ct, JudgeConfusion as D, clusterBootstrapMean as Dt, JudgeCalibrationSet as E, ClusteredObservation as Et, JudgeRunMeta as F, calibrationCurve as Ft, SentinelMetricName as G, CorpusAgreementOptions as Gt, snapshotFromJudgeAgreement as H, EvalMetricSpec as Ht, OwnerVerdict as I, calibrationFromPairs as It, SentinelSetOptions as J, CorpusScoreRecord as Jt, SentinelMetrics as K, CorpusAgreementPerDimension as Kt, addCalibrationVerdicts as L, multiclassBrierScore as Lt, JudgeGateRefusedError as M, CategoricalForecast as Mt, JudgeGateStatus as N, OrdinalForecast as Nt, JudgeExampleAgreement as O, CalibrationBin as Ot, JudgeRun as P, brierScore as Pt, SentinelTrend as Q, assertJudgeMayGate as R, rankedProbabilityScore as Rt, CalibrationExample as S, evaluatorAuditObservationSchema as St, JudgeAgreement as T, ClusterBootstrapResult as Tt, EvalHealthStamp as U, OutcomePair as Ut, registerCalibrationSet as V, CorrelationStudyResult as Vt, JudgeSentinelOptions as W, correlationStudy as Wt, SentinelStore as X, corpusInterRaterAgreementFromJudgeScores as Xt, SentinelSnapshot as Y, corpusInterRaterAgreement as Yt, SentinelThresholds as Z, interRaterReliability as Zt, catchRate as _, ProbabilityPolicyAuditInput as _t, PerturbedField as a, snapshotFromSentinelSet as at, plantByPerturbation as b, auditProbabilityPolicy as bt, PlantEvidence as c, SeriesConvergenceResult as ct, PlantKindCounts as d, EvaluatorAdmissionReport as dt, evalHealthStamp as et, PlantManifest as f, EvaluatorAuditInput as ft, UnseededRejection as g, EvaluatorErrorRate as gt, SeededGradingSet as h, EvaluatorAuditPlanInput as ht, PerturbationKind as i, snapshotFromCalibration as it, JudgeGatePolicy as j, CalibrationReport as jt, JudgeGateDecision as k, CalibrationOptions as kt, PlantExpectation as l, analyzeSeries as lt, SeedPlantsOptions as m, EvaluatorAuditPlan as mt, CatchRateStatus as n, judgeSentinelReport as nt, PerturbedPlant as o, validateSentinelSnapshot as ot, PlantOutcome as p, EvaluatorAuditObservation as pt, SentinelReport as q, CorpusAgreementReport as qt, EvidencePerturbation as r, snapshotFromAgreement as rt, Plant as s, SeriesConvergenceOptions as st, CatchRateReport as t, fileSentinelStore as tt, PlantKind as u, EvaluatorAdmissionPolicy as ut, definePlant as v, ProbabilityPolicyAuditReport as vt, DEFAULT_JUDGE_GATE_POLICY as w, ClusterBootstrapOptions as wt, seedPlants as x, evaluatorAdmissionPolicySchema as xt, perturbEvidence as y, auditEvaluator as yt, judgeGateDecision as z, CorrelationResult as zt };
+//# sourceMappingURL=index-DWd1gUwR.d.ts.map