@rulvar/cli 1.16.1 → 1.17.0

package/dist/dist-CdhvWszV.js

@@ -1,626 +0,0 @@
-import { KnowledgeCasError, claimExpiry, compileVerifiedLayer, defineWorkflow } from "@rulvar/core";
-import { createHash } from "node:crypto";
-//#region ../evals/dist/index.js
-/**
-* @rulvar/evals (M9-T02): EvalCase, the grader contract, and the case and
-* suite runners. A separate quality-measurement package built strictly on
-* the public APIs (L6).
-*
-* Determinism rules (https://docs.rulvar.com/guide/evals and
-* https://docs.rulvar.com/guide/testing): judge graders run THROUGH the
-* engine, so judge calls
-* are journaled, budgeted, and VCR-recordable, and an eval suite replays
-* deterministically from cassettes with zero live calls.
-*/
-/** Thrown when a judge run does not settle ok. */
-var EvalJudgeError = class extends Error {
-	judgeRun;
-	status;
-	constructor(judgeRun, status, detail) {
-		super(`eval judge run '${judgeRun}' settled '${status}'${detail === void 0 ? "" : `: ${detail}`}`);
-		this.name = "EvalJudgeError";
-		this.judgeRun = judgeRun;
-		this.status = status;
-	}
-};
-/**
-* Runs one EvalCase on the given engine: the target workflow as its own
-* run, pure graders host-side over the outcome, judge graders through the
-* engine via GraderContext.judge. Grader thrown errors are not absorbed:
-* a grader that cannot grade is a defect of the suite, not a failed case.
-*/
-async function runEvalCase(engine, evalCase, options = {}) {
-	const name = options.name ?? evalCase.workflow.name;
-	const timing = {};
-	const handle = engine.run(evalCase.workflow, evalCase.args, {
-		name: `eval:${name}`,
-		...options.budgetUsd === void 0 ? {} : { budgetUsd: options.budgetUsd }
-	});
-	const offStart = handle.on("run:start", (event) => {
-		timing.start ??= event.ts;
-	});
-	const offEnd = handle.on("run:end", (event) => {
-		timing.end ??= event.ts;
-	});
-	const outcome = await handle.result;
-	offStart();
-	offEnd();
-	let judgeCostUsd = 0;
-	let judgeOrdinal = 0;
-	const context = {
-		value: outcome.value,
-		outcome,
-		async judge(spec) {
-			const ordinal = judgeOrdinal;
-			judgeOrdinal += 1;
-			const judged = await runJudge(engine, `${name}:${ordinal}`, spec, options.judgeBudgetUsd);
-			judgeCostUsd += judged.costUsd;
-			return judged.output;
-		}
-	};
-	const verdicts = [];
-	for (const grader of evalCase.graders) verdicts.push(await grader.grade(context));
-	const latencyMs = timing.start !== void 0 && timing.end !== void 0 ? Math.max(0, Date.parse(timing.end) - Date.parse(timing.start)) : 0;
-	return {
-		name,
-		status: outcome.status,
-		passed: outcome.status === "ok" && verdicts.every((verdict) => verdict.passed),
-		verdicts,
-		costUsd: outcome.cost.totalUsd + judgeCostUsd,
-		judgeCostUsd,
-		latencyMs,
-		usage: outcome.usage,
-		...outcome.error === void 0 ? {} : { error: outcome.error }
-	};
-}
-async function runJudge(engine, judgeName, spec, budgetUsd) {
-	const workflowName = `eval-judge:${judgeName}`;
-	const judgeWorkflow = defineWorkflow({ name: workflowName }, async (ctx) => {
-		return await ctx.agent(spec.prompt, {
-			model: spec.model,
-			schema: spec.schema,
-			label: "eval-judge",
-			onError: "throw"
-		});
-	});
-	const outcome = await engine.run(judgeWorkflow, null, {
-		name: workflowName,
-		...budgetUsd === void 0 ? {} : { budgetUsd }
-	}).result;
-	if (outcome.status !== "ok") throw new EvalJudgeError(workflowName, outcome.status, outcome.error?.message);
-	return {
-		output: outcome.value ?? null,
-		costUsd: outcome.cost.totalUsd
-	};
-}
-/**
-* Runs cases sequentially (deterministic journal and cassette order) and
-* aggregates. Duplicate workflow names get '#<ordinal>' suffixes so every
-* result row and judge journal is unambiguous.
-*/
-async function runEvalSuite(engine, cases, options = {}) {
-	const seen = /* @__PURE__ */ new Map();
-	const results = [];
-	for (const evalCase of cases) {
-		const base = evalCase.workflow.name;
-		const ordinal = seen.get(base) ?? 0;
-		seen.set(base, ordinal + 1);
-		const name = ordinal === 0 ? base : `${base}#${ordinal}`;
-		results.push(await runEvalCase(engine, evalCase, {
-			name,
-			...options.budgetUsd === void 0 ? {} : { budgetUsd: options.budgetUsd },
-			...options.judgeBudgetUsd === void 0 ? {} : { judgeBudgetUsd: options.judgeBudgetUsd }
-		}));
-	}
-	return {
-		results,
-		passRate: results.length === 0 ? 0 : results.filter((r) => r.passed).length / results.length,
-		totalCostUsd: results.reduce((sum, r) => sum + r.costUsd, 0),
-		meanLatencyMs: results.length === 0 ? 0 : results.reduce((sum, r) => sum + r.latencyMs, 0) / results.length
-	};
-}
-/**
-* Runs the same case list against every cell's engine, sequentially and
-* in declaration order (deterministic cassette consumption), and reports
-* per-cell aggregates for side-by-side comparison.
-*/
-async function runEvalMatrix(cells, cases, options = {}) {
-	const reports = [];
-	for (const cell of cells) {
-		const suite = await runEvalSuite(await cell.engine(), cases, options);
-		reports.push({
-			cell: cell.name,
-			passRate: suite.passRate,
-			totalCostUsd: suite.totalCostUsd,
-			meanLatencyMs: suite.meanLatencyMs,
-			results: suite.results
-		});
-	}
-	return { cells: reports };
-}
-function deepEqual(a, b) {
-	if (a === b) return true;
-	if (a === null || b === null || a === void 0 || b === void 0) return false;
-	if (Array.isArray(a) || Array.isArray(b)) {
-		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
-		return a.every((item, index) => deepEqual(item, b[index]));
-	}
-	if (typeof a === "object" && typeof b === "object") {
-		const aKeys = Object.keys(a).sort();
-		const bKeys = Object.keys(b).sort();
-		if (aKeys.length !== bKeys.length || aKeys.some((key, index) => key !== bKeys[index])) return false;
-		return aKeys.every((key) => deepEqual(a[key], b[key]));
-	}
-	return false;
-}
-function goldenGrader(expected, options = {}) {
-	const name = options.name ?? "golden";
-	return {
-		name,
-		grade(context) {
-			const passed = deepEqual(context.value, expected);
-			return {
-				grader: name,
-				passed,
-				...passed ? {} : { details: {
-					expected,
-					actual: context.value ?? null
-				} }
-			};
-		}
-	};
-}
-function rubricGrader(criteria, options = {}) {
-	const name = options.name ?? "rubric";
-	const threshold = options.passThreshold ?? 1;
-	return {
-		name,
-		grade(context) {
-			const rows = criteria.map((criterion) => ({
-				name: criterion.name,
-				passed: criterion.check(context.value)
-			}));
-			const score = criteria.length === 0 ? 1 : rows.filter((row) => row.passed).length / rows.length;
-			return {
-				grader: name,
-				passed: score >= threshold,
-				score,
-				details: { criteria: rows }
-			};
-		}
-	};
-}
-/** The default judge verdict shape. */
-const JUDGE_VERDICT_SCHEMA = {
-	type: "object",
-	properties: {
-		passed: { type: "boolean" },
-		reasoning: { type: "string" }
-	},
-	required: ["passed"],
-	additionalProperties: false
-};
-function defaultToVerdict(output) {
-	return { passed: typeof output === "object" && output !== null && !Array.isArray(output) && output.passed === true };
-}
-function judgePrompt(instruction, value) {
-	return [
-		"You are an evaluation judge. Judge the candidate output below against the instruction.",
-		"",
-		`Instruction: ${instruction}`,
-		"",
-		"Candidate output (JSON):",
-		JSON.stringify(value ?? null),
-		"",
-		"Return a verdict object matching the response schema."
-	].join("\n");
-}
-function judgeGrader(options) {
-	const name = options.name ?? "judge";
-	if (options.schema !== void 0 && options.toVerdict === void 0) throw new Error(`judgeGrader '${name}': a custom schema requires toVerdict`);
-	const toVerdict = options.toVerdict ?? defaultToVerdict;
-	const schema = options.schema ?? JUDGE_VERDICT_SCHEMA;
-	return {
-		name,
-		async grade(context) {
-			if (context.outcome.status !== "ok") return {
-				grader: name,
-				passed: false,
-				details: { skipped: `target run settled '${context.outcome.status}'` }
-			};
-			const output = await context.judge({
-				model: options.model,
-				prompt: judgePrompt(options.instruction, context.value),
-				schema
-			});
-			const verdict = toVerdict(output);
-			return {
-				grader: name,
-				passed: verdict.passed,
-				...verdict.score === void 0 ? {} : { score: verdict.score },
-				details: { output }
-			};
-		}
-	};
-}
-/**
-* The eval-committer identity (M11-T01; https://docs.rulvar.com/guide/model-knowledge).
-* The pipeline-side commit path: builds
-* eval-committer-gated ops (the coherence square: class eval-measured,
-* author eval-pipeline, metrics present) and commits them with the
-* documented CAS-rebase recipe. Humans never call this; their path is
-* the human gate and it structurally cannot carry metrics.
-*/
-/** One measured claim; claimExpiry applies the TTL from the decay table. */
-function evalMeasuredClaim(input, committerId) {
-	return {
-		id: input.id,
-		subject: input.subject,
-		taskClass: input.taskClass,
-		polarity: input.polarity,
-		statement: input.statement,
-		class: "eval-measured",
-		status: "active",
-		evidence: input.evidence,
-		metrics: input.metrics,
-		confidence: input.confidence,
-		observedAt: input.observedAt,
-		expiresAt: claimExpiry("eval-measured", input.polarity, input.observedAt),
-		...input.modelEpoch === void 0 ? {} : { modelEpoch: input.modelEpoch },
-		author: {
-			kind: "eval-pipeline",
-			id: committerId
-		}
-	};
-}
-/**
-* Commits measured claims through the eval-committer gate with the
-* documented rebase recipe: on a CAS rejection, re-read current() and
-* retry against the fresh version. Returns the committed version.
-*/
-async function commitEvalMeasured(store, claims, options) {
-	const gate = {
-		kind: "eval-committer",
-		committerId: options.committerId,
-		reportId: options.reportId
-	};
-	const ops = claims.map((input) => ({
-		op: "add",
-		claim: evalMeasuredClaim(input, options.committerId),
-		gate
-	}));
-	const attempts = options.attempts ?? 3;
-	let lastCas;
-	for (let attempt = 0; attempt < attempts; attempt += 1) {
-		const snapshot = await store.current();
-		try {
-			return await store.commit(ops, snapshot.version);
-		} catch (thrown) {
-			if (thrown instanceof KnowledgeCasError) {
-				lastCas = thrown;
-				continue;
-			}
-			throw thrown;
-		}
-	}
-	throw lastCas ?? /* @__PURE__ */ new Error("commitEvalMeasured: unreachable");
-}
-/**
-* The canary fingerprint (M11-T04; OQ-06). The optional compensation for silent alias
-* re-pointing that modelEpoch honestly cannot catch: a FIXED probe set,
-* run through the ordinary engine (journaled, budgeted,
-* VCR-recordable), hashed over normalized outputs. Sampling parameters
-* are not pinned; drift detection rests on the fixed prompts, the
-* normalization, and exact fingerprint comparison. A fingerprint change
-* flips the model's eval claims to stale in one command.
-*
-* The committed v1 design (closing OQ-06): the probe set is CALLER
-* data (fixed, versioned alongside the store); normalization is NFC,
-* trim, and whitespace collapse per output; the fingerprint is the
-* sha256 of the JCS-serialized normalized output array, prefixed with
-* the probe count so a probe-set edit never collides with drift.
-*/
-/** The committed v1 normalization (OQ-06): NFC, trim, collapse whitespace. */
-function normalizeCanaryOutput(output) {
-	return (typeof output === "string" ? output : JSON.stringify(output ?? null)).normalize("NFC").trim().replace(/\s+/gu, " ");
-}
-/**
-* Runs the fixed probe set through the ordinary engine and returns the
-* fingerprint. Probes run sequentially in declaration order, one run
-* per probe, so recordings replay deterministically.
-*/
-async function canaryFingerprint(engine, probes) {
-	const outputs = [];
-	for (const [index, prompt] of probes.prompts.entries()) {
-		const workflow = defineWorkflow({ name: `kb-canary:${String(index)}` }, async (ctx) => await ctx.agent(prompt, { agentType: probes.agentType }));
-		const outcome = await engine.run(workflow, null).result;
-		outputs.push(outcome.status === "ok" ? normalizeCanaryOutput(outcome.value) : `!${outcome.status}`);
-	}
-	const body = JSON.stringify([probes.prompts.length, outputs]);
-	return createHash("sha256").update(body, "utf8").digest("hex");
-}
-/**
-* Flips the model's ACTIVE eval-measured claims to stale when their
-* recorded canary fingerprint differs from the fresh one. Claims
-* without a recorded fingerprint have no baseline and
-* stay untouched (the documented no-probe posture); a second run is
-* an idempotent noop. CAS-rebased like every maintenance commit.
-*/
-async function flipStaleOnCanaryDrift(store, model, freshFingerprint, options) {
-	const attempts = options?.attempts ?? 3;
-	let lastCas;
-	for (let attempt = 0; attempt < attempts; attempt += 1) {
-		const snapshot = await store.current();
-		const drifted = snapshot.claims.filter((claim) => claim.status === "active" && claim.class === "eval-measured" && claim.subject.model === model && claim.modelEpoch?.canaryFingerprint !== void 0 && claim.modelEpoch.canaryFingerprint !== freshFingerprint);
-		if (drifted.length === 0) return {
-			model,
-			freshFingerprint,
-			flipped: []
-		};
-		const ops = drifted.map((claim) => ({
-			op: "mark_stale",
-			claimId: claim.id,
-			reason: "canary-drift"
-		}));
-		try {
-			const version = await store.commit(ops, snapshot.version);
-			return {
-				model,
-				freshFingerprint,
-				flipped: drifted.map((claim) => claim.id),
-				version
-			};
-		} catch (thrown) {
-			if (thrown instanceof KnowledgeCasError) {
-				lastCas = thrown;
-				continue;
-			}
-			throw thrown;
-		}
-	}
-	throw lastCas ?? /* @__PURE__ */ new Error("flipStaleOnCanaryDrift: unreachable");
-}
-/**
-* The phases 1-2 measured-value checkpoint (M12-T01; the quantitative
-* criteria of OQ-09, closed at M11-T06). The M12 gate: kb_propose
-* and the proposal loop ship ONLY if the knowledge card demonstrably
-* improves tier and agentType selection on eval cases.
-*
-* Two experiments, both A/B under identical fixed pools:
-*
-* 1. RUNG SELECTION, per (ladder, taskClass) cell: the baseline arm
-*    runs every eval case at the ladder's DEFAULT start tier; the
-*    treatment arm runs at the tier recommended by
-*    compileVerifiedLayer over the store's claims (default when no
-*    recommendation). A cell passes when the treatment reaches a pass
-*    rate at least equal to the baseline at no more than 90 percent
-*    of its cost, OR at least 5 points above it at no more than its
-*    cost. Criterion 1 holds when a MAJORITY of cells pass AND the
-*    pooled aggregate passes the same rule.
-*
-* 2. AGENTTYPE SELECTION, pooled: the same orchestrate-role cases run
-*    with and without the knowledge store configured (the card docks
-*    into the spawn tool description when configured). Criterion 2
-*    holds when the card-informed arm matches or beats the baseline
-*    pass rate at no more than 105 percent of its cost, OR beats it
-*    by at least 15 points at no more than 115 percent of its cost
-*    (the quality branch; OQ-09 as amended 2026-07-12: the baseline
-*    fails CHEAPLY, so the flat cost bar tightened exactly when the
-*    card was winning on quality).
-*
-* The checkpoint PASSES only when both criteria hold. Methodology
-* guard: the claims the treatment consumes MUST come from a seeding
-* sweep over a DISJOINT case set (the seed/eval split is the caller's
-* pool contract), or the measurement is leakage.
-*/
-/** IEEE754 guard for the rule boundaries (0.8 + 0.05 exceeds 0.85). */
-const EPSILON = 1e-9;
-/**
-* The OQ-09 criterion 2 rule (as amended 2026-07-12): match-or-beat at
-* 105 percent of baseline cost, OR at least 15 points better at 115
-* percent (the quality branch: the baseline fails cheaply, so the flat
-* bar tightened exactly when the card won on quality). The vacuous-pass
-* guard stays with the caller.
-*/
-function agentTypeRuleHolds(baseline, informed) {
-	const matchesCheaply = informed.passRate >= baseline.passRate - EPSILON && informed.totalCostUsd <= 1.05 * baseline.totalCostUsd + EPSILON;
-	const clearlyBetterNearCost = informed.passRate >= baseline.passRate + .15 - EPSILON && informed.totalCostUsd <= 1.15 * baseline.totalCostUsd + EPSILON;
-	return matchesCheaply || clearlyBetterNearCost;
-}
-/** The OQ-09 cell rule (shared by the per-cell and pooled verdicts). */
-function rungRuleHolds(baseline, treatment) {
-	const equalOrBetterCheaper = treatment.passRate >= baseline.passRate - EPSILON && treatment.totalCostUsd <= .9 * baseline.totalCostUsd + EPSILON;
-	const clearlyBetterAtCost = treatment.passRate >= baseline.passRate + .05 - EPSILON && treatment.totalCostUsd <= baseline.totalCostUsd + EPSILON;
-	return equalOrBetterCheaper || clearlyBetterAtCost;
-}
-function armOf(suite) {
-	return {
-		passRate: suite.passRate,
-		totalCostUsd: suite.totalCostUsd,
-		n: suite.results.length
-	};
-}
-function pool(arms) {
-	const n = arms.reduce((sum, arm) => sum + arm.n, 0);
-	const passed = arms.reduce((sum, arm) => sum + arm.passRate * arm.n, 0);
-	const cost = arms.reduce((sum, arm) => sum + arm.totalCostUsd, 0);
-	return {
-		passRate: n === 0 ? 0 : passed / n,
-		totalCostUsd: cost,
-		n
-	};
-}
-/**
-* Runs the checkpoint over the fixed pool. Sequential in declaration
-* order (deterministic cassette consumption when recorded); every cell
-* runs baseline then treatment.
-*/
-async function runValueCheckpoint(checkpointPool, options) {
-	const recommendations = compileVerifiedLayer(options.snapshot.claims.filter((claim) => claim.status === "active"), checkpointPool.ladders);
-	const byTaskClass = /* @__PURE__ */ new Map();
-	for (const entry of checkpointPool.evalCases) {
-		const bucket = byTaskClass.get(entry.taskClass) ?? [];
-		bucket.push(entry.case);
-		byTaskClass.set(entry.taskClass, bucket);
-	}
-	const cells = [];
-	for (const ladder of checkpointPool.ladders) for (const [taskClass, cases] of byTaskClass) {
-		const recommendation = recommendations.find((row) => row.ladder === ladder.name && row.taskClass === taskClass);
-		const treatmentTier = recommendation?.recommendedTier ?? ladder.startTier;
-		const baseMember = ladder.rungs[ladder.startTier];
-		const treatMember = ladder.rungs[treatmentTier];
-		if (baseMember === void 0 || treatMember === void 0) throw new Error(`checkpoint: ladder '${ladder.name}' lacks rung ${String(treatmentTier)}`);
-		const baseline = armOf(await runEvalSuite(await options.engineFor(baseMember), cases, options.suite ?? {}));
-		const treatment = treatmentTier === ladder.startTier ? baseline : armOf(await runEvalSuite(await options.engineFor(treatMember), cases, options.suite ?? {}));
-		cells.push({
-			ladder: ladder.name,
-			taskClass,
-			defaultTier: ladder.startTier,
-			treatmentTier,
-			recommended: recommendation !== void 0,
-			baseline,
-			treatment,
-			passed: rungRuleHolds(baseline, treatment)
-		});
-	}
-	const recommendedCells = cells.filter((cell) => cell.recommended);
-	const cellsPassed = recommendedCells.filter((cell) => cell.passed).length;
-	const majorityHolds = recommendedCells.length > 0 && cellsPassed * 2 > recommendedCells.length;
-	const pooledBaseline = pool(cells.map((cell) => cell.baseline));
-	const pooledTreatment = pool(cells.map((cell) => cell.treatment));
-	const pooledHolds = rungRuleHolds(pooledBaseline, pooledTreatment);
-	const criterion1 = {
-		cells,
-		cellsPassed,
-		majorityHolds,
-		pooledBaseline,
-		pooledTreatment,
-		pooledHolds,
-		passed: majorityHolds && pooledHolds
-	};
-	let criterion2;
-	if (options.orchestrateEngineFor !== void 0 && options.orchestratedCases !== void 0) {
-		const cases = options.orchestratedCases.map((entry) => entry.case);
-		const orchestratedSuite = options.orchestratedSuite ?? options.suite ?? {};
-		const baseline = armOf(await runEvalSuite(await options.orchestrateEngineFor(false), cases, orchestratedSuite));
-		const informed = armOf(await runEvalSuite(await options.orchestrateEngineFor(true), cases, orchestratedSuite));
-		criterion2 = {
-			baseline,
-			informed,
-			passed: informed.n > 0 && informed.passRate > 0 && agentTypeRuleHolds(baseline, informed)
-		};
-	}
-	return {
-		observedAt: options.observedAt,
-		criterion1,
-		...criterion2 === void 0 ? {} : { criterion2 },
-		passed: criterion1.passed && criterion2 !== void 0 && criterion2.passed
-	};
-}
-const percent = (rate) => `${(rate * 100).toFixed(1)}%`;
-const usd = (value) => `$${value.toFixed(4)}`;
-/** The deterministic render for the M12 gate docs amendment. */
-function renderCheckpointReport(report) {
-	const lines = [
-		`Measured-value checkpoint (OQ-09) at ${report.observedAt}: ` + (report.passed ? "PASSED" : "FAILED"),
-		"",
-		`Criterion 1 (rung selection): ${report.criterion1.passed ? "holds" : "fails"} (${String(report.criterion1.cellsPassed)}/${String(report.criterion1.cells.length)} cells, pooled ${report.criterion1.pooledHolds ? "holds" : "fails"})`
-	];
-	for (const cell of report.criterion1.cells) lines.push(`* ${cell.ladder} :: ${cell.taskClass}: baseline tier ${String(cell.defaultTier)} ${percent(cell.baseline.passRate)} at ${usd(cell.baseline.totalCostUsd)}; treatment tier ${String(cell.treatmentTier)}${cell.recommended ? "" : " (no recommendation)"} ${percent(cell.treatment.passRate)} at ${usd(cell.treatment.totalCostUsd)}; ${cell.passed ? "pass" : "fail"} (n=${String(cell.baseline.n)})`);
-	if (report.criterion2 !== void 0) {
-		const c2 = report.criterion2;
-		lines.push("", `Criterion 2 (agentType selection): ${c2.passed ? "holds" : "fails"} (baseline ${percent(c2.baseline.passRate)} at ${usd(c2.baseline.totalCostUsd)}; card-informed ${percent(c2.informed.passRate)} at ${usd(c2.informed.totalCostUsd)}; n=${String(c2.baseline.n)})`);
-	} else lines.push("", "Criterion 2 (agentType selection): NOT MEASURED (counts as failed)");
-	return lines.join("\n");
-}
-const SWEEP_THRESHOLD_DEFAULTS = {
-	strength: .9,
-	weakness: .5
-};
-/** Deterministic claim id: report-scoped, readable, collision-free. */
-function claimIdOf(reportId, member, taskClass) {
-	const effort = member.effort === void 0 ? "" : `@${member.effort}`;
-	return `${reportId}/${member.model}${effort}/${taskClass}`;
-}
-/** The typed statement template: never a quote from tool output. */
-function statementOf(cell, polarity) {
-	const rate = cell.passRate.toFixed(2);
-	const band = polarity === "strength" ? "at or above the strength band" : "in the weakness band";
-	return `sweep passRate ${rate} over ${String(cell.n)} ${cell.taskClass} case${cell.n === 1 ? "" : "s"}: ${band}`;
-}
-/**
-* Runs the fixed matrix sequentially in declaration order
-* (deterministic cassette consumption), aggregates per (model,
-* taskClass) cell, emits threshold-crossing claims, and commits them
-* through the eval-committer identity when a store is given.
-*/
-async function runSweepMatrix(pool, options) {
-	const thresholds = {
-		...SWEEP_THRESHOLD_DEFAULTS,
-		...options.thresholds
-	};
-	const byTaskClass = /* @__PURE__ */ new Map();
-	for (const entry of pool.cases) {
-		const bucket = byTaskClass.get(entry.taskClass) ?? [];
-		bucket.push(entry);
-		byTaskClass.set(entry.taskClass, bucket);
-	}
-	const cells = [];
-	const claims = [];
-	for (const member of pool.models) {
-		const engine = await options.engineFor(member);
-		for (const [taskClass, bucket] of byTaskClass) {
-			const suite = await runEvalSuite(engine, bucket.map((entry) => entry.case), options.suite ?? {});
-			const cell = {
-				model: member.model,
-				...member.effort === void 0 ? {} : { effort: member.effort },
-				taskClass,
-				passRate: suite.passRate,
-				n: suite.results.length,
-				totalCostUsd: suite.totalCostUsd,
-				caseNames: suite.results.map((result) => result.name)
-			};
-			cells.push(cell);
-			const polarity = cell.passRate >= thresholds.strength ? "strength" : cell.passRate <= thresholds.weakness ? "weakness" : void 0;
-			if (polarity !== void 0 && cell.n > 0) {
-				const epoch = options.modelEpochFor?.(member);
-				claims.push({
-					id: claimIdOf(options.reportId, member, taskClass),
-					subject: {
-						model: member.model,
-						...member.effort === void 0 ? {} : { effort: member.effort }
-					},
-					taskClass,
-					polarity,
-					statement: statementOf(cell, polarity),
-					metrics: {
-						passRate: cell.passRate,
-						n: cell.n,
-						graderId: "eval-suite"
-					},
-					confidence: cell.n >= 20 ? "high" : cell.n >= 5 ? "medium" : "low",
-					observedAt: options.observedAt,
-					evidence: [{
-						kind: "eval",
-						reportId: options.reportId,
-						caseIds: cell.caseNames
-					}],
-					...epoch === void 0 ? {} : { modelEpoch: epoch }
-				});
-			}
-		}
-	}
-	const report = {
-		reportId: options.reportId,
-		observedAt: options.observedAt,
-		cells,
-		claims
-	};
-	if (options.store !== void 0 && claims.length > 0) report.committedVersion = await commitEvalMeasured(options.store, claims, {
-		committerId: options.committerId,
-		reportId: options.reportId
-	});
-	return report;
-}
-//#endregion
-export { EvalJudgeError, JUDGE_VERDICT_SCHEMA, SWEEP_THRESHOLD_DEFAULTS, canaryFingerprint, commitEvalMeasured, evalMeasuredClaim, flipStaleOnCanaryDrift, goldenGrader, judgeGrader, normalizeCanaryOutput, renderCheckpointReport, rubricGrader, runEvalCase, runEvalMatrix, runEvalSuite, runSweepMatrix, runValueCheckpoint, rungRuleHolds };