@tangle-network/agent-eval 0.208.2 → 0.210.0

package/dist/judge-gate-C59znGmR.js

@@ -0,0 +1,638 @@
+import { i as JudgeError, s as ValidationError } from "./errors-Dngq5h35.js";
+import { r as computeInterval } from "./ast-DJ6Bc7ab.js";
+//#region src/series-convergence.ts
+function analyzeSeries(values, options = {}) {
+	const window = options.window ?? 5;
+	const stableCv = options.stableCv ?? .05;
+	const driftRun = options.driftRun ?? 3;
+	if (values.length < Math.max(2, Math.min(window, 3))) return {
+		state: "insufficient-data",
+		windowMean: 0,
+		windowCv: 0,
+		tailRun: 0,
+		stable: false
+	};
+	const tail = values.slice(-window);
+	const mean = tail.reduce((a, b) => a + b, 0) / tail.length;
+	const variance = tail.reduce((acc, v) => acc + (v - mean) ** 2, 0) / tail.length;
+	const cv = Math.sqrt(variance) / (Math.abs(mean) > 1e-9 ? Math.abs(mean) : 1);
+	const stable = tail.length >= window && cv <= stableCv;
+	let tailRun = 0;
+	let direction = 0;
+	for (let i = values.length - 1; i > 0; i--) {
+		const delta = values[i] - values[i - 1];
+		if (delta === 0) break;
+		const dir = delta > 0 ? 1 : -1;
+		if (direction === 0) direction = dir;
+		if (dir !== direction) break;
+		tailRun += dir;
+	}
+	let state;
+	if (stable) state = "stabilized";
+	else if (Math.abs(tailRun) >= driftRun) state = tailRun > 0 ? "drifting-up" : "drifting-down";
+	else state = "noisy";
+	return {
+		state,
+		windowMean: mean,
+		windowCv: cv,
+		tailRun,
+		stable
+	};
+}
+//#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$1(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$1(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$1(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$1(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
+//#region src/meta-eval/judge-gate.ts
+/**
+* Judge calibration gate: a judge may gate only while its measured agreement
+* with its owner's verdicts holds.
+*
+* A judge (a model judge or a deterministic grader) registers a calibration
+* set: items its owner has decided, each verdict with its provenance. A
+* calibration run replays the judge on those items, once or several times, and
+* `measureJudgeAgreement` reports how often it reached the owner's verdict
+* (accuracy, and Cohen's κ for the pass/fail pair), how much its own verdict
+* moves between runs and between samples, and where it disagreed.
+*
+* `judgeGateDecision` turns that report into the one decision a consumer acts
+* on. It refuses when the judge has no measured agreement, too few decided
+* items of either verdict, a report measured on a different model or rubric
+* than the one the judge now runs, a report older than the policy allows,
+* agreement below the policy floors, or an alarmed drift history. A refused
+* judge's verdict is advisory: the consumer reports it but does not let it
+* pass or block anything.
+*
+* Drift is the judge sentinel (`./sentinel`): `snapshotFromJudgeAgreement`
+* records accuracy as `sentinelPassRate` and κ as `calibrationKappa`, so each
+* calibration run appends one snapshot to a `SentinelStore` and the gate reads
+* the alarms `judgeSentinelReport` raises over that history.
+*
+* Every timestamp is caller-supplied ISO-8601, so decisions are reproducible.
+*/
+function parseIso(value, label) {
+	const ms = typeof value === "string" ? Date.parse(value) : NaN;
+	if (!Number.isFinite(ms)) throw new ValidationError(`judge-gate: ${label} is not a parseable ISO timestamp: ${JSON.stringify(value)}`);
+	return ms;
+}
+function requireText(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new ValidationError(`judge-gate: ${label} must be a non-empty string`);
+	return value;
+}
+function requireVerdict(value, label) {
+	if (value !== "pass" && value !== "fail") throw new ValidationError(`judge-gate: ${label} must be 'pass' or 'fail', got ${JSON.stringify(value)}`);
+	return value;
+}
+function checkExample(example, label) {
+	if (example === null || typeof example !== "object") throw new ValidationError(`judge-gate: ${label} must be an object`);
+	requireText(example.id, `${label}.id`);
+	requireVerdict(example.verdict, `${label}.verdict`);
+	requireText(example.labeledBy, `${label}.labeledBy`);
+	parseIso(example.labeledAt, `${label}.labeledAt`);
+	requireText(example.source, `${label}.source`);
+	if (example.evidenceRef !== void 0) requireText(example.evidenceRef, `${label}.evidenceRef`);
+	const copy = {
+		id: example.id,
+		verdict: example.verdict,
+		labeledBy: example.labeledBy,
+		labeledAt: example.labeledAt,
+		source: example.source
+	};
+	if (example.evidenceRef !== void 0) copy.evidenceRef = example.evidenceRef;
+	if (example.note !== void 0) copy.note = example.note;
+	return copy;
+}
+/**
+* Validate a calibration set and return a normalized copy ordered by example
+* id. Every verdict needs its person, time and source; ids are unique.
+*/
+function registerCalibrationSet(set) {
+	if (set === null || typeof set !== "object") throw new ValidationError("judge-gate: calibration set must be an object");
+	const judgeId = requireText(set.judgeId, "calibration set judgeId");
+	const owner = requireText(set.owner, `calibration set "${judgeId}" owner`);
+	if (!Array.isArray(set.examples)) throw new ValidationError(`judge-gate: calibration set "${judgeId}" examples must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	const examples = set.examples.map((example, index) => {
+		const checked = checkExample(example, `calibration set "${judgeId}" example ${index}`);
+		if (seen.has(checked.id)) throw new ValidationError(`judge-gate: calibration set "${judgeId}" has duplicate example id "${checked.id}"`);
+		seen.add(checked.id);
+		return checked;
+	});
+	examples.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+	return {
+		judgeId,
+		owner,
+		examples
+	};
+}
+/**
+* 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.
+*/
+function addCalibrationVerdicts(set, verdicts) {
+	const base = registerCalibrationSet(set);
+	const byId = new Map(base.examples.map((example) => [example.id, example]));
+	const added = [];
+	const superseded = [];
+	const unchanged = [];
+	for (const [index, verdict] of verdicts.entries()) {
+		const incoming = checkExample(verdict, `incoming verdict ${index} for "${base.judgeId}"`);
+		const current = byId.get(incoming.id);
+		if (!current) {
+			byId.set(incoming.id, incoming);
+			added.push(incoming.id);
+			continue;
+		}
+		if (current.source === incoming.source && current.verdict === incoming.verdict || parseIso(incoming.labeledAt, "labeledAt") <= parseIso(current.labeledAt, "labeledAt")) {
+			unchanged.push(incoming.id);
+			continue;
+		}
+		byId.set(incoming.id, incoming);
+		superseded.push(incoming.id);
+	}
+	return {
+		set: registerCalibrationSet({
+			...base,
+			examples: [...byId.values()]
+		}),
+		added,
+		superseded,
+		unchanged
+	};
+}
+function bernoulliVariance(passes, n) {
+	const p = passes / n;
+	return p * (1 - p);
+}
+/** Cohen's κ for two raters over a binary pass/fail table. */
+function binaryKappa(confusion) {
+	const n = confusion.truePass + confusion.trueFail + confusion.falsePass + confusion.falseFail;
+	if (n === 0) return null;
+	const observed = (confusion.truePass + confusion.trueFail) / n;
+	const judgePass = (confusion.truePass + confusion.falsePass) / n;
+	const ownerPass = (confusion.truePass + confusion.falseFail) / n;
+	const expected = judgePass * ownerPass + (1 - judgePass) * (1 - ownerPass);
+	if (expected === 1) return null;
+	return (observed - expected) / (1 - expected);
+}
+/**
+* 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.
+*/
+function measureJudgeAgreement(set, runs, meta) {
+	const registered = registerCalibrationSet(set);
+	if (meta.judgeId !== registered.judgeId) throw new ValidationError(`judge-gate: runs are for judge "${meta.judgeId}" but the set belongs to "${registered.judgeId}"`);
+	requireText(meta.judgeModel, "judgeModel");
+	requireText(meta.rubricVersion, "rubricVersion");
+	parseIso(meta.measuredAt, "measuredAt");
+	const byId = new Map(registered.examples.map((example) => [example.id, example]));
+	const runsById = /* @__PURE__ */ new Map();
+	const confusion = {
+		truePass: 0,
+		trueFail: 0,
+		falsePass: 0,
+		falseFail: 0
+	};
+	const withinRun = [];
+	for (const [index, run] of runs.entries()) {
+		const example = byId.get(run?.exampleId);
+		if (!example) throw new ValidationError(`judge-gate: run ${index} names example ${JSON.stringify(run?.exampleId)}, which is not in "${registered.judgeId}"'s calibration set`);
+		const verdict = requireVerdict(run.verdict, `run ${index} verdict`);
+		if (run.samples !== void 0) {
+			if (!Array.isArray(run.samples) || run.samples.length === 0) throw new ValidationError(`judge-gate: run ${index} samples must be a non-empty array`);
+			const samples = run.samples.map((sample, s) => requireVerdict(sample, `run ${index} sample ${s}`));
+			withinRun.push(bernoulliVariance(samples.filter((sample) => sample === "pass").length, samples.length));
+		}
+		const list = runsById.get(example.id) ?? [];
+		list.push({
+			...run,
+			verdict
+		});
+		runsById.set(example.id, list);
+		if (verdict === "pass") {
+			if (example.verdict === "pass") confusion.truePass++;
+			else confusion.falsePass++;
+		} else if (example.verdict === "fail") confusion.trueFail++;
+		else confusion.falseFail++;
+	}
+	const perExample = [];
+	const unjudged = [];
+	const judgedByVerdict = {
+		pass: 0,
+		fail: 0
+	};
+	for (const example of registered.examples) {
+		const list = runsById.get(example.id);
+		if (!list) {
+			unjudged.push(example.id);
+			continue;
+		}
+		judgedByVerdict[example.verdict]++;
+		const passes = list.filter((run) => run.verdict === "pass").length;
+		perExample.push({
+			id: example.id,
+			verdict: example.verdict,
+			runs: list.length,
+			passRate: passes / list.length,
+			agreement: list.filter((run) => run.verdict === example.verdict).length / list.length
+		});
+	}
+	const total = runs.length;
+	const agreedRuns = confusion.truePass + confusion.trueFail;
+	const agreedExamples = perExample.filter((example) => example.agreement === 1).length;
+	const mean = (values) => values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
+	return {
+		...meta,
+		owner: registered.owner,
+		examples: registered.examples.length,
+		judged: perExample.length,
+		judgedByVerdict,
+		runs: total,
+		accuracy: total === 0 ? null : agreedRuns / total,
+		exampleAccuracy: perExample.length === 0 ? null : {
+			agreed: agreedExamples,
+			judged: perExample.length,
+			interval: computeInterval({
+				kind: "clopper-pearson",
+				level: .95
+			}, {
+				kind: "binomial",
+				successes: agreedExamples,
+				trials: perExample.length
+			})
+		},
+		kappa: binaryKappa(confusion),
+		confusion,
+		variance: {
+			betweenRuns: mean(perExample.map((example) => example.passRate * (1 - example.passRate))),
+			withinRun: mean(withinRun),
+			unstable: perExample.filter((example) => example.passRate > 0 && example.passRate < 1).map((example) => example.id)
+		},
+		disagreements: perExample.filter((example) => example.agreement < 1).sort((a, b) => a.agreement - b.agreement || (a.id < b.id ? -1 : 1)),
+		unjudged
+	};
+}
+const DEFAULT_JUDGE_GATE_POLICY = Object.freeze({
+	minExamples: 10,
+	minPerVerdict: 1,
+	minAccuracy: .9,
+	minKappa: .6,
+	maxAgeDays: 30
+});
+const DAY_MS = 864e5;
+function percent(value) {
+	return `${(value * 100).toFixed(1)}%`;
+}
+/** Whether a judge may gate now, and every reason it may not. */
+function judgeGateDecision(input) {
+	const judgeId = requireText(input.judgeId, "judgeId");
+	const judgeModel = requireText(input.judgeModel, "judgeModel");
+	const rubricVersion = requireText(input.rubricVersion, "rubricVersion");
+	const asOf = parseIso(input.asOf, "asOf");
+	const policy = {
+		...DEFAULT_JUDGE_GATE_POLICY,
+		...input.policy
+	};
+	const agreement = input.agreement;
+	const decide = (status, reasons) => ({
+		judgeId,
+		judgeModel,
+		rubricVersion,
+		mayGate: status === "calibrated",
+		status,
+		reasons,
+		agreement,
+		policy
+	});
+	if (!agreement) return decide("uncalibrated", ["no measured agreement with owner verdicts"]);
+	if (agreement.judgeId !== judgeId) throw new ValidationError(`judge-gate: agreement belongs to "${agreement.judgeId}", not "${judgeId}"`);
+	const uncalibrated = [];
+	if (agreement.judgeModel !== judgeModel) uncalibrated.push(`agreement was measured on model ${agreement.judgeModel}; the judge now runs ${judgeModel}`);
+	if (agreement.rubricVersion !== rubricVersion) uncalibrated.push(`agreement was measured on rubric ${agreement.rubricVersion}; the judge now runs ${rubricVersion}`);
+	const ageDays = (asOf - parseIso(agreement.measuredAt, "agreement.measuredAt")) / DAY_MS;
+	if (ageDays > policy.maxAgeDays) uncalibrated.push(`agreement is ${ageDays.toFixed(1)} days old (limit ${policy.maxAgeDays})`);
+	if (agreement.judged < policy.minExamples) uncalibrated.push(`${agreement.judged} judged ${agreement.judged === 1 ? "example" : "examples"}; at least ${policy.minExamples} required`);
+	for (const verdict of ["pass", "fail"]) if (agreement.judgedByVerdict[verdict] < policy.minPerVerdict) uncalibrated.push(`${agreement.judgedByVerdict[verdict]} judged examples the owner marked ${verdict}; at least ${policy.minPerVerdict} required`);
+	if (uncalibrated.length > 0) return decide("uncalibrated", uncalibrated);
+	const below = [];
+	if (agreement.accuracy === null || agreement.accuracy < policy.minAccuracy) below.push(`accuracy ${agreement.accuracy === null ? "unmeasured" : percent(agreement.accuracy)} is below ${percent(policy.minAccuracy)}`);
+	if (agreement.kappa === null || agreement.kappa < policy.minKappa) below.push(`kappa ${agreement.kappa === null ? "undefined" : agreement.kappa.toFixed(2)} is below ${policy.minKappa}`);
+	if (below.length > 0) return decide("below-threshold", below);
+	const history = (input.history ?? []).filter((snapshot) => snapshot.judgeId === judgeId);
+	if (history.length > 0) {
+		const report = judgeSentinelReport([...history], {
+			asOf: input.asOf,
+			...policy.drift ? { thresholds: policy.drift } : {}
+		});
+		if (!report.healthy) return decide("drifted", report.alarms);
+	}
+	return decide("calibrated", []);
+}
+/** Thrown by `assertJudgeMayGate`; carries the refused decision. */
+var JudgeGateRefusedError = class extends JudgeError {
+	decision;
+	constructor(decision) {
+		super(`judge "${decision.judgeId}" may not gate (${decision.status}): ${decision.reasons.join("; ")}`);
+		this.decision = decision;
+	}
+};
+/** Throw unless the decision lets the judge gate. */
+function assertJudgeMayGate(decision) {
+	if (!decision.mayGate) throw new JudgeGateRefusedError(decision);
+}
+/**
+* The sentinel snapshot for one calibration run: accuracy as
+* `sentinelPassRate`, κ as `calibrationKappa` when it is defined. Append it to
+* the judge's `SentinelStore`; the gate reads drift from that history.
+*/
+function snapshotFromJudgeAgreement(agreement) {
+	if (agreement.accuracy === null) throw new ValidationError(`snapshotFromJudgeAgreement: judge "${agreement.judgeId}" has no runs to snapshot`);
+	const snapshot = {
+		at: agreement.measuredAt,
+		judgeId: agreement.judgeId,
+		judgeModel: agreement.judgeModel,
+		metrics: {
+			sentinelPassRate: agreement.accuracy,
+			...agreement.kappa === null ? {} : { calibrationKappa: agreement.kappa }
+		}
+	};
+	validateSentinelSnapshot(snapshot);
+	return snapshot;
+}
+//#endregion
+export { analyzeSeries as _, judgeGateDecision as a, snapshotFromJudgeAgreement as c, inMemorySentinelStore as d, judgeSentinelReport as f, validateSentinelSnapshot as g, snapshotFromSentinelSet as h, assertJudgeMayGate as i, evalHealthStamp as l, snapshotFromCalibration as m, JudgeGateRefusedError as n, measureJudgeAgreement as o, snapshotFromAgreement as p, addCalibrationVerdicts as r, registerCalibrationSet as s, DEFAULT_JUDGE_GATE_POLICY as t, fileSentinelStore as u };
+
+//# sourceMappingURL=judge-gate-C59znGmR.js.map