@tangle-network/agent-eval 0.200.1 → 0.202.0

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

@@ -8,17 +8,17 @@ 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 { z } from "zod";
 //#region src/meta-eval/correlation-study.d.ts
-interface EvalMetricSpec {
+export 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 {
+export interface OutcomePair {
   evalMetric: string;
   outcomeMetric: string;
 }
-interface CorrelationResult {
+export interface CorrelationResult {
   evalMetric: string;
   outcomeMetric: string;
   n: number;
@@ -37,7 +37,7 @@ interface CorrelationResult {
   /** Rough verdict: 'strong' ≥ 0.7, 'moderate' ≥ 0.4, else 'weak'. */
   verdict: 'strong' | 'moderate' | 'weak';
 }
-interface CorrelationStudyResult {
+export interface CorrelationStudyResult {
   pairs: CorrelationResult[];
   /** Declared pairs without an estimable correlation, including their usable sample count. */
   excludedPairs: Array<OutcomePair & {
@@ -47,7 +47,7 @@ interface CorrelationStudyResult {
   joinedSamples: number;
   skippedRuns: number;
 }
-interface CorrelationStudyOptions {
+export interface CorrelationStudyOptions {
   /** Only join outcomes captured within this window after run.startedAt. */
   maxCaptureLagMs?: number;
   /** Restrict to a subset of outcomes (cohort, region, source). */
@@ -60,10 +60,10 @@ interface CorrelationStudyOptions {
    *  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>;
+export 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 {
+export interface CalibrationBin {
   lower: number;
   upper: number;
   n: number;
@@ -72,7 +72,7 @@ interface CalibrationBin {
   /** |outcomeMean − evalMean|; contributes to ECE weighted by n/total. */
   gap: number;
 }
-interface CalibrationReport {
+export interface CalibrationReport {
   evalMetric: string;
   outcomeMetric: string;
   n: number;
@@ -82,7 +82,7 @@ interface CalibrationReport {
   /** Largest observed difference between a bin's mean score and mean outcome. */
   maxGap: number;
 }
-interface CalibrationOptions {
+export interface CalibrationOptions {
   /** Positive integer; empty bins are omitted. Default 10. */
   bins?: number;
   /** Equal-width (fixed bin edges) or equal-frequency (quantile bins). */
@@ -93,23 +93,23 @@ interface CalibrationOptions {
     hi: number;
   };
 }
-interface CalibrationPair {
+export interface CalibrationPair {
   evalScore: number;
   outcome: number;
 }
-declare function calibrationCurve(traceStore: TraceStore, outcomeStore: OutcomeStore, evalMetric: EvalMetricSpec, outcomeMetric: string, options?: CalibrationOptions): Promise<CalibrationReport | null>;
+export 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;
+export declare function calibrationFromPairs(inputPairs: readonly CalibrationPair[], evalMetric: string, outcomeMetric: string, options?: CalibrationOptions): CalibrationReport | null;
 //#endregion
 //#region src/meta-eval/evaluator-admission.d.ts
-declare const policySchema: z.ZodObject<{
+export 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 policySchema>;
-declare const observationSchema: z.ZodObject<{
+type EvaluatorAdmissionPolicy = z.infer<typeof evaluatorAdmissionPolicySchema>;
+export declare const evaluatorAuditObservationSchema: z.ZodObject<{
   id: z.ZodString;
   independentUnitId: z.ZodString;
   evidenceRef: z.ZodString;
@@ -128,7 +128,7 @@ declare const observationSchema: z.ZodObject<{
   }>;
 }, z.core.$strict>;
 /** Actual control judgments. Variants from one source retain one independent identity. */
-type EvaluatorAuditObservation = z.infer<typeof observationSchema>;
+type EvaluatorAuditObservation = z.infer<typeof evaluatorAuditObservationSchema>;
 declare const inputSchema: z.ZodObject<{
   evaluatorDigest: z.ZodString;
   population: z.ZodString;
@@ -210,12 +210,55 @@ interface EvaluatorAdmissionReport {
   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.
+ */
+export 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;
+export declare function auditEvaluator(input: EvaluatorAuditInput): EvaluatorAdmissionReport;
 declare const probabilityAuditSchema: z.ZodObject<{
   evaluatorDigest: z.ZodString;
   population: z.ZodString;
@@ -267,7 +310,7 @@ interface ProbabilityPolicyAuditReport extends EvaluatorAdmissionReport {
  * 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;
+export declare function auditProbabilityPolicy(input: ProbabilityPolicyAuditInput): ProbabilityPolicyAuditReport;
 //#endregion
 //#region src/meta-eval/plants.d.ts
 /**
@@ -275,7 +318,7 @@ declare function auditProbabilityPolicy(input: ProbabilityPolicyAuditInput): Pro
  * {@link CatchRateReport.byKind} because a grader is routinely sharp on one
  * and blind to another.
  */
-type PlantKind =
+export 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. */
@@ -285,8 +328,8 @@ type PlantKind =
 /** 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 {
+export type PlantExpectation = 'reject' | 'accept';
+export interface Plant {
   /** Name of the plant record. Reported in `missedIds` and `missingIds`. */
   id: string;
   kind: PlantKind;
@@ -307,7 +350,7 @@ interface Plant {
  * 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: {
+export declare function definePlant(input: {
   id: string;
   kind: PlantKind;
   item: GoldenItem;
@@ -317,17 +360,17 @@ declare function definePlant(input: {
  * A claim's executable evidence: the command a grader runs and the output it
  * must produce.
  */
-interface PlantEvidence {
+export 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';
+export type PerturbedField = 'check' | 'expect';
 /** How {@link perturbEvidence} altered it. */
-type PerturbationKind = 'number-off-by-one' | 'comparison-flipped';
-interface EvidencePerturbation {
+export type PerturbationKind = 'number-off-by-one' | 'comparison-flipped';
+export interface EvidencePerturbation {
   /** The evidence with exactly one value altered. */
   evidence: PlantEvidence;
   /** Which field changed. */
@@ -370,8 +413,8 @@ interface EvidencePerturbation {
  * 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 {
+export declare function perturbEvidence(evidence: PlantEvidence): EvidencePerturbation | null;
+export interface PerturbedPlant {
   plant: Plant;
   /** The perturbed evidence to write into the item the grader is handed. */
   evidence: PlantEvidence;
@@ -400,7 +443,7 @@ interface PerturbedPlant {
  * 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: {
+export declare function plantByPerturbation(input: {
   id: string;
   itemId: string;
   evidence: PlantEvidence;
@@ -408,7 +451,7 @@ declare function plantByPerturbation(input: {
   humanScore?: number;
   group?: string;
 }): PerturbedPlant | null;
-interface PlantManifest {
+export 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
@@ -424,7 +467,7 @@ interface PlantManifest {
   /** The seeded plants. This is the answer key; keep it out of the graded workspace. */
   plants: Plant[];
 }
-interface SeededGradingSet {
+export 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`
@@ -433,7 +476,7 @@ interface SeededGradingSet {
   items: GoldenItem[];
   manifest: PlantManifest;
 }
-interface SeedPlantsOptions {
+export interface SeedPlantsOptions {
   /**
    * Fixes the mix order. The same dataset, plants, threshold, and seed always
    * produce the same seeded order and the same seal.
@@ -455,13 +498,13 @@ interface SeedPlantsOptions {
  * 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;
+export 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 {
+export interface PlantOutcome {
   itemId: string;
   score: number | null;
 }
@@ -469,8 +512,8 @@ interface PlantOutcome {
  * `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 {
+export type CatchRateStatus = 'evaluated' | 'incomplete' | 'not_evaluated';
+export interface PlantKindCounts {
   seeded: number;
   caught: number;
   missed: number;
@@ -484,14 +527,14 @@ interface PlantKindCounts {
  * on reject-plants, and a `rejectionRate` of 1.0 here is what separates that
  * reflex from discrimination.
  */
-interface UnseededRejection {
+export interface UnseededRejection {
   n: number;
   decided: number;
   rejected: number;
   /** rejected / decided, or null when nothing unseeded was decided. */
   rejectionRate: number | null;
 }
-interface CatchRateReport {
+export interface CatchRateReport {
   status: CatchRateStatus;
   /** Why the status is not `evaluated`. Absent when it is. */
   reason?: string;
@@ -521,12 +564,12 @@ interface CatchRateReport {
  * 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;
+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'];
-type SentinelMetricName = (typeof SENTINEL_METRIC_NAMES)[number];
-interface SentinelMetrics {
+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*`). */
@@ -534,7 +577,7 @@ interface SentinelMetrics {
   /** Fraction of a fixed sentinel golden set the judge still scores within tolerance. */
   sentinelPassRate?: number;
 }
-interface SentinelSnapshot {
+export interface SentinelSnapshot {
   /** Caller-supplied ISO-8601 timestamp — the module never reads a clock. */
   at: string;
   judgeId: string;
@@ -549,19 +592,19 @@ interface SentinelSnapshot {
   metrics: SentinelMetrics;
 }
 /** Identity + timestamp the caller supplies alongside an instrument output. */
-interface SnapshotMeta {
+export 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;
+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).
  */
-declare function snapshotFromCalibration(report: CalibrationResult | ContinuousCalibrationResult, meta: SnapshotMeta): SentinelSnapshot;
+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
@@ -569,8 +612,8 @@ declare function snapshotFromCalibration(report: CalibrationResult | ContinuousC
  * `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 {
+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;
 }
@@ -581,21 +624,21 @@ interface SentinelSetOptions {
  * 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 {
+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[]>;
 }
-declare function inMemorySentinelStore(initial?: SentinelSnapshot[]): SentinelStore;
+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.
  */
-declare function fileSentinelStore(path: string): SentinelStore;
-interface SentinelThresholds {
+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. */
@@ -605,14 +648,14 @@ interface SentinelThresholds {
   /** Newest snapshot older than this (days, vs asOf) = the sentinel itself went blind. Default 30. */
   staleAfterDays?: number;
 }
-interface JudgeSentinelOptions {
+export interface JudgeSentinelOptions {
   /** Caller-supplied ISO timestamp staleness is measured against. */
   asOf: string;
   thresholds?: SentinelThresholds;
   /** Forwarded to `analyzeSeries` (window, stableCv, driftRun). */
   convergence?: SeriesConvergenceOptions;
 }
-interface SentinelTrend {
+export interface SentinelTrend {
   judgeId: string;
   metric: SentinelMetricName;
   /** Verbatim `analyzeSeries` state for this judge×metric history. */
@@ -626,7 +669,7 @@ interface SentinelTrend {
   alarmed: boolean;
   reason?: string;
 }
-interface SentinelReport {
+export interface SentinelReport {
   perJudge: SentinelTrend[];
   alarms: string[];
   healthy: boolean;
@@ -638,8 +681,8 @@ interface SentinelReport {
    */
   insufficientHistory: string[];
 }
-declare function judgeSentinelReport(history: SentinelSnapshot[], opts: JudgeSentinelOptions): SentinelReport;
-interface EvalHealthStamp {
+export declare function judgeSentinelReport(history: SentinelSnapshot[], opts: JudgeSentinelOptions): SentinelReport;
+export interface EvalHealthStamp {
   healthy: boolean;
   alarms: string[];
 }
@@ -651,7 +694,7 @@ interface EvalHealthStamp {
  * 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;
+export declare function evalHealthStamp(report: SentinelReport): EvalHealthStamp;
 //#endregion
-export { CalibrationBin, CalibrationOptions, CalibrationPair, CalibrationReport, type CalibrationResult, type CandidateScore, CatchRateReport, CatchRateStatus, type ContinuousAgreement, type ContinuousAgreementOptions, type ContinuousCalibrationResult, type CorrelationInterval, CorrelationResult, CorrelationStudyOptions, CorrelationStudyResult, DeploymentOutcome, EvalHealthStamp, EvalMetricSpec, type EvaluatorAdmissionPolicy, type EvaluatorAdmissionReport, type EvaluatorAuditInput, type EvaluatorAuditObservation, type EvaluatorErrorRate, EvidencePerturbation, FileSystemOutcomeStore, FileSystemOutcomeStoreOptions, type GoldenItem, InMemoryOutcomeStore, JudgeSentinelOptions, OutcomeFilter, OutcomeMetricSpec, OutcomePair, type OutcomeReduction, OutcomeStore, OutcomeStoreError, PerturbationKind, PerturbedField, PerturbedPlant, Plant, PlantEvidence, PlantExpectation, PlantKind, PlantKindCounts, PlantManifest, PlantOutcome, type PositionalBiasResult, type ProbabilityPolicyAuditInput, type ProbabilityPolicyAuditReport, RubricOutcomeExclusion, RubricOutcomePair, RubricPredictiveValidityInput, RubricPredictiveValidityReport, RubricRanking, SeedPlantsOptions, SeededGradingSet, type SelfPreferenceResult, SentinelMetricName, SentinelMetrics, SentinelReport, SentinelSetOptions, SentinelSnapshot, SentinelStore, SentinelThresholds, SentinelTrend, SnapshotMeta, UnseededRejection, type VerbosityBiasResult, auditEvaluator, auditProbabilityPolicy, calibrateJudge, calibrateJudgeContinuous, calibrationCurve, calibrationFromPairs, catchRate, continuousAgreement, correlationStudy, definePlant, evalHealthStamp, fileSentinelStore, inMemorySentinelStore, judgeSentinelReport, perturbEvidence, plantByPerturbation, positionalBias, rubricPredictiveValidity, seedPlants, selfPreference, snapshotFromAgreement, snapshotFromCalibration, snapshotFromSentinelSet, validateSentinelSnapshot, verbosityBias };
+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 };
 //# 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/evaluator-admission.ts","../../src/meta-eval/plants.ts","../../src/meta-eval/sentinel.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/meta-eval/correlation-study.ts","../../src/meta-eval/calibration.ts","../../src/meta-eval/evaluator-admission.ts","../../src/meta-eval/plants.ts","../../src/meta-eval/sentinel.ts"],"mappings":"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"}

package/dist/meta-eval/index.js

@@ -1,12 +1,12 @@
 import { n as CaptureIntegrityError, s as ValidationError } from "../errors-Dngq5h35.js";
 import { a as hashCanonical, i as compareCodeUnits } from "../canonical-BsZVgBhW.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-DYmaBtJr.js";
+import { a as selfPreference, i as positionalBias, n as calibrateJudgeContinuous, o as verbosityBias, r as continuousAgreement, t as calibrateJudge } from "../judge-calibration-C5zgtiJT.js";
 import { u as runMetricExtractor } from "../query-DlV0pdx4.js";
-import { r as computeInterval } from "../ast-CP9ae9B0.js";
+import { r as computeInterval } from "../ast-DJ6Bc7ab.js";
 import { t as analyzeSeries } from "../series-convergence-CjO2QdRW.js";
-import { a as reduceOutcomeMetric, i as hasVariation, n as assertUniqueObservationIds, o as validateObservationOptions, r as correlationSummary, t as rubricPredictiveValidity } from "../rubric-predictive-validity-CCK-1B7w.js";
-import { n as InMemoryOutcomeStore, r as OutcomeStoreError, t as FileSystemOutcomeStore } from "../outcome-store-BXlkwMPR.js";
+import { a as reduceOutcomeMetric, i as hasVariation, n as assertUniqueObservationIds, o as validateObservationOptions, r as correlationSummary, t as rubricPredictiveValidity } from "../rubric-predictive-validity-B0Pg-3I5.js";
+import { n as InMemoryOutcomeStore, r as OutcomeStoreError, t as FileSystemOutcomeStore } from "../outcome-store-DUcMj-3D.js";
 import { z } from "zod";
 //#region src/meta-eval/calibration.ts
 /**
@@ -231,12 +231,12 @@ async function correlationStudy(traceStore, outcomeStore, evalMetrics, outcomeMe
 //#endregion
 //#region src/meta-eval/evaluator-admission.ts
 const identity = z.string().min(1).refine((value) => value.trim() === value);
-const policySchema = z.object({
+const evaluatorAdmissionPolicySchema = z.object({
 	confidence: z.number().finite().gt(0).lt(1),
 	maxFalseAcceptanceRate: z.number().finite().min(0).lt(1),
 	maxFalseRejectionRate: z.number().finite().min(0).lt(1)
 }).strict();
-const observationSchema = z.object({
+const evaluatorAuditObservationSchema = z.object({
 	id: identity,
 	independentUnitId: identity,
 	evidenceRef: identity,
@@ -257,8 +257,8 @@ const inputSchema = z.object({
 		auditorId: identity,
 		independenceEvidenceRef: identity
 	}).strict(),
-	policy: policySchema,
-	observations: z.array(observationSchema)
+	policy: evaluatorAdmissionPolicySchema,
+	observations: z.array(evaluatorAuditObservationSchema)
 }).strict();
 function errorRate(rows, expected, limit, level) {
 	const cases = rows.filter((row) => row.expected === expected);
@@ -308,6 +308,83 @@ function errorRate(rows, expected, limit, level) {
 		verdict
 	};
 }
+function eligibleControls(observations) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const row of observations) {
+		if (ids.has(row.id)) throw new ValidationError(`duplicate evaluator audit observation '${row.id}'`);
+		ids.add(row.id);
+	}
+	observations.sort((a, b) => compareCodeUnits(a.id, b.id));
+	const developmentUnits = new Set(observations.filter((row) => row.exposure === "development").map((row) => row.independentUnitId));
+	return {
+		eligible: observations.filter((row) => !developmentUnits.has(row.independentUnitId)),
+		exclusions: observations.filter((row) => developmentUnits.has(row.independentUnitId)).map((row) => ({
+			id: row.id,
+			independentUnitId: row.independentUnitId,
+			reason: "development-exposure"
+		}))
+	};
+}
+function simultaneousIntervalConfidence(confidence) {
+	const level = 1 - (1 - confidence) / 2;
+	if (level >= 1) throw new ValidationError("evaluator audit confidence is too close to one for simultaneous intervals");
+	return level;
+}
+const capacitySchema = z.object({
+	policy: evaluatorAdmissionPolicySchema,
+	controls: z.array(evaluatorAuditObservationSchema.omit({
+		observed: true,
+		evidenceRef: true
+	})).default([])
+}).strict();
+/** The zero-error eligibility floor, not a statistical power calculation. */
+function zeroErrorUpperBound(trials, level) {
+	return -Math.expm1(Math.log((1 - level) / 2) / trials);
+}
+function minimumAuditUnits(limit, level) {
+	if (limit === 0) return null;
+	const estimate = Math.ceil(Math.log((1 - level) / 2) / Math.log1p(-limit));
+	if (!Number.isFinite(estimate) || estimate > Number.MAX_SAFE_INTEGER) return null;
+	const clears = (trials) => zeroErrorUpperBound(trials, level) <= limit;
+	let minimum = Math.max(1, estimate);
+	while (minimum > 1 && clears(minimum - 1)) minimum -= 1;
+	while (!clears(minimum)) {
+		if (minimum === Number.MAX_SAFE_INTEGER) return null;
+		minimum += 1;
+	}
+	return minimum;
+}
+/**
+* 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.
+*/
+function planEvaluatorAudit(input) {
+	const parsed = capacitySchema.safeParse(input);
+	if (!parsed.success) throw new ValidationError(`invalid evaluator audit plan: ${parsed.error.message}`);
+	const { policy, controls } = parsed.data;
+	const { eligible } = eligibleControls(controls);
+	const level = simultaneousIntervalConfidence(policy.confidence);
+	const capacity = (expected, limit) => {
+		const independentUnits = new Set(eligible.filter((row) => row.expected === expected).map((row) => row.independentUnitId)).size;
+		const bestPossibleUpperBound = independentUnits === 0 ? null : zeroErrorUpperBound(independentUnits, level);
+		const minimumIndependentUnits = minimumAuditUnits(limit, level);
+		return {
+			independentUnits,
+			bestPossibleUpperBound,
+			limit,
+			minimumIndependentUnits,
+			additionalIndependentUnits: minimumIndependentUnits === null ? null : Math.max(0, minimumIndependentUnits - independentUnits)
+		};
+	};
+	const falseAcceptance = capacity("reject", policy.maxFalseAcceptanceRate);
+	const falseRejection = capacity("accept", policy.maxFalseRejectionRate);
+	return {
+		sufficient: [falseAcceptance, falseRejection].every((rate) => rate.bestPossibleUpperBound !== null && rate.bestPossibleUpperBound <= rate.limit),
+		falseAcceptance,
+		falseRejection
+	};
+}
 /**
 * Audit frozen judgments using independent source units and exact binomial bounds.
 * A unit fails a class when any control in that class is misjudged.
@@ -318,21 +395,8 @@ function auditEvaluator(input) {
 	if (!parsed.success) throw new ValidationError(`invalid evaluator audit: ${parsed.error.message}`);
 	const audit = parsed.data;
 	if (audit.authority.evaluatorAuthorId === audit.authority.auditorId) throw new ValidationError("evaluator admission requires a separate declared audit authority");
-	const ids = /* @__PURE__ */ new Set();
-	for (const row of audit.observations) {
-		if (ids.has(row.id)) throw new ValidationError(`duplicate evaluator audit observation '${row.id}'`);
-		ids.add(row.id);
-	}
-	audit.observations.sort((a, b) => compareCodeUnits(a.id, b.id));
-	const developmentUnits = new Set(audit.observations.filter((row) => row.exposure === "development").map((row) => row.independentUnitId));
-	const eligible = audit.observations.filter((row) => !developmentUnits.has(row.independentUnitId));
-	const exclusions = audit.observations.filter((row) => developmentUnits.has(row.independentUnitId)).map((row) => ({
-		id: row.id,
-		independentUnitId: row.independentUnitId,
-		reason: "development-exposure"
-	}));
-	const intervalConfidence = 1 - (1 - audit.policy.confidence) / 2;
-	if (intervalConfidence >= 1) throw new ValidationError("evaluator audit confidence is too close to one for simultaneous intervals");
+	const { eligible, exclusions } = eligibleControls(audit.observations);
+	const intervalConfidence = simultaneousIntervalConfidence(audit.policy.confidence);
 	const falseAcceptance = errorRate(eligible, "reject", audit.policy.maxFalseAcceptanceRate, intervalConfidence);
 	const falseRejection = errorRate(eligible, "accept", audit.policy.maxFalseRejectionRate, intervalConfidence);
 	const rates = [falseAcceptance, falseRejection];
@@ -379,7 +443,7 @@ const probabilityThresholdsSchema = z.object({
 	rejectAtOrBelow: z.number().finite().min(0).max(1),
 	acceptAtOrAbove: z.number().finite().min(0).max(1)
 }).strict().refine((value) => value.rejectAtOrBelow < value.acceptAtOrAbove, { message: "rejection and acceptance thresholds must not overlap" });
-const probabilityObservationSchema = observationSchema.omit({ observed: true }).extend({ acceptProbability: z.number().finite().min(0).max(1).nullable() }).strict();
+const probabilityObservationSchema = evaluatorAuditObservationSchema.omit({ observed: true }).extend({ acceptProbability: z.number().finite().min(0).max(1).nullable() }).strict();
 const probabilityAuditSchema = inputSchema.extend({
 	thresholds: probabilityThresholdsSchema,
 	observations: z.array(probabilityObservationSchema)
@@ -1179,6 +1243,6 @@ function evalHealthStamp(report) {
 	};
 }
 //#endregion
-export { FileSystemOutcomeStore, InMemoryOutcomeStore, OutcomeStoreError, auditEvaluator, auditProbabilityPolicy, calibrateJudge, calibrateJudgeContinuous, calibrationCurve, calibrationFromPairs, catchRate, continuousAgreement, correlationStudy, definePlant, evalHealthStamp, fileSentinelStore, inMemorySentinelStore, judgeSentinelReport, perturbEvidence, plantByPerturbation, positionalBias, rubricPredictiveValidity, seedPlants, selfPreference, snapshotFromAgreement, snapshotFromCalibration, snapshotFromSentinelSet, validateSentinelSnapshot, verbosityBias };
+export { FileSystemOutcomeStore, InMemoryOutcomeStore, OutcomeStoreError, auditEvaluator, auditProbabilityPolicy, calibrateJudge, calibrateJudgeContinuous, calibrationCurve, calibrationFromPairs, catchRate, continuousAgreement, correlationStudy, definePlant, evalHealthStamp, evaluatorAdmissionPolicySchema, evaluatorAuditObservationSchema, fileSentinelStore, inMemorySentinelStore, judgeSentinelReport, perturbEvidence, planEvaluatorAudit, plantByPerturbation, positionalBias, rubricPredictiveValidity, seedPlants, selfPreference, snapshotFromAgreement, snapshotFromCalibration, snapshotFromSentinelSet, validateSentinelSnapshot, verbosityBias };
 
 //# sourceMappingURL=index.js.map