@tangle-network/agent-eval 0.216.1 → 0.218.1

package/dist/{campaign-BudZ70zo.js → campaign-CGvUTnmc.js}

@@ -1,115 +1,29 @@
-import { s as ValidationError, t as AgentEvalError } from "./errors-DVZiqS7K.js";
-import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-B2RqLofv.js";
-import { c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, s as agentProfileHash, t as extractProducedState } from "./produced-state-BsDmnwxc.js";
-import { o as buildAgentProfileCell } from "./agent-profile-cell-BK8mlqlq.js";
-import { c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, o as runTaskScore } from "./run-record-Boc5IUTp.js";
-import { i as pairedBootstrap } from "./mean-DHoMiudD.js";
-import { t as comparePairedArms } from "./paired-arms-CwMGJsrS.js";
-import { o as pairHoldout } from "./statistical-heldout-42NlCNDe.js";
-import { n as contentHash, t as canonicalJson } from "./verdict-cache-Bm8EKL2s.js";
-import { _ as labelTrustRank, at as resolveRunDir, c as executeOptimizationMethod, d as combineComparisonCosts, it as planCampaignRun, lt as cellCachePath, rt as runCampaign, ut as computeManifestHash } from "./llm-judge-CG12SQJq.js";
-import { n as campaignCellToRunRecord, r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-C5e7FjhJ.js";
-import { n as CostAccountingIncompleteError } from "./cost-ledger-BP8V4kUQ.js";
-import { B as assertCampaignDesign, N as surfaceContentHash, R as assertRealBackend, W as campaignScenarioIdentity, k as assertCodeSurfaceIdentity, z as summarizeBackendIntegrity } from "./campaign-evidence-Clrn4hBV.js";
-import { m as mapConcurrent } from "./journal-DfRz9kps.js";
-import { P as fsCampaignStorage } from "./external-optimizer-subprocess-BqW0hHcI.js";
-import "./pareto-Cm6ndrWN.js";
-import "./search-ledger-CVUGLDZp.js";
-import "./search-summary-BQCSWf1g.js";
-import { a as scoreAnalystFindings } from "./benchmark-CXmVVHH2.js";
-import "./external-optimizer-process-BjMGUuds.js";
-import "./skillopt-optimization-method-BiwA8nfX.js";
-import "./sequential-Bf_pbE50.js";
+import { s as ValidationError, t as AgentEvalError } from "./errors-BcOs5MKW.js";
+import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-Dq2hOQ8L.js";
+import { c as agentProfileModelId, o as agentProfileHash, r as verifyCompletion, s as agentProfileId, u as harnessAxisOf } from "./completion-verifier-DbLVf3i8.js";
+import { i as buildAgentProfileCell } from "./agent-profile-cell-B1V1gUZs.js";
+import { c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, o as runTaskScore } from "./run-record-DhEJgoPz.js";
+import { t as comparePairedArms } from "./paired-arms-Ct4LTKc1.js";
+import { i as pairedBootstrap } from "./mean-BbA_JCzW.js";
+import { o as pairHoldout } from "./statistical-heldout-Bksv92Th.js";
+import { n as contentHash, t as canonicalJson } from "./verdict-cache-CL_7tePD.js";
+import { $ as planCampaignRun, Q as runCampaign, et as resolveRunDir, nt as cellCachePath, rt as computeManifestHash, s as executeOptimizationMethod, u as combineComparisonCosts } from "./llm-judge-Djxh-Uhs.js";
+import { n as campaignCellToRunRecord, r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-CysKLB93.js";
+import { C as assertCodeSurfaceIdentity, D as surfaceContentHash, M as assertRealBackend, N as summarizeBackendIntegrity, P as assertCampaignDesign, R as campaignScenarioIdentity } from "./campaign-evidence-DunzcJGv.js";
+import { a as mapConcurrent } from "./journal-C7om8Gum.js";
+import { M as fsCampaignStorage } from "./external-optimizer-subprocess-B5gdLRZv.js";
+import "./pareto-CTv8vozZ.js";
+import "./search-ledger-ClpN4I3e.js";
+import "./search-summary-CrBuvVnf.js";
+import "./external-optimizer-process-C3Wm7Vhn.js";
+import "./skillopt-optimization-method-5dlex7MJ.js";
+import "./sequential-CimQrbjv.js";
 import { createHash } from "node:crypto";
-import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync } from "node:fs";
 import { z } from "zod";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { devNull, tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
-//#region src/campaign/analyst-surface.ts
-function buildTraceAnalystSurfaceDispatch(options) {
-	return async (surface, scenario, context) => {
-		if (typeof surface !== "string") throw new TypeError(`buildTraceAnalystSurfaceDispatch requires a string prompt, received ${surface.kind}`);
-		return options.analyze({
-			instructions: surface,
-			traceStore: scenario.traceStore,
-			runId: `${context.cellId}:${scenario.id}`,
-			signal: context.signal
-		});
-	};
-}
-function traceAnalystQualityJudge() {
-	return {
-		name: "trace-analyst-quality",
-		judgeVersion: "agent-eval:trace-analyst-quality:v3",
-		dimensions: [
-			{
-				key: "issue_recall",
-				description: "share of labeled issues found"
-			},
-			{
-				key: "finding_precision",
-				description: "share of findings tied to a labeled issue"
-			},
-			{
-				key: "f1",
-				description: "harmonic mean of issue recall and finding precision"
-			},
-			{
-				key: "critical_step_accuracy",
-				description: "share of labeled causal steps cited"
-			},
-			{
-				key: "citation_coverage",
-				description: "share of findings with evidence citations"
-			},
-			{
-				key: "citation_label_agreement",
-				description: "share of citations matching a labeled case location"
-			},
-			{
-				key: "clean",
-				description: "1 when a clean case produces no findings"
-			}
-		],
-		appliesTo: (scenario) => scenario.kind === "trace-analyst" && scenario.labelState !== "unlabeled",
-		score({ artifact, scenario }) {
-			assertScorableScenario(scenario);
-			return traceAnalystJudgeScore(scoreAnalystFindings({
-				id: scenario.id,
-				expectedIssues: scenario.expectedIssues,
-				labeledEvidence: scenario.labeledEvidence
-			}, artifact.findings));
-		}
-	};
-}
-function assertScorableScenario(scenario) {
-	if (scenario.labelState === "unlabeled") throw new TypeError(`trace analyst scenario '${scenario.id}' has no quality labels`);
-	if (scenario.labelState === "positive" && scenario.expectedIssues.length === 0) throw new TypeError(`positive trace analyst scenario '${scenario.id}' requires expected issues`);
-	if (scenario.labelState === "trusted-negative" && scenario.expectedIssues.length > 0) throw new TypeError(`trusted-negative trace analyst scenario '${scenario.id}' cannot contain expected issues`);
-}
-function traceAnalystJudgeScore(score) {
-	const dimensions = {
-		issue_recall: score.issueRecall,
-		finding_precision: score.findingPrecision,
-		f1: score.f1,
-		clean: score.predictionOnLabelEmptyCase ? 0 : 1
-	};
-	if (score.criticalStepAccuracy !== null) dimensions.critical_step_accuracy = score.criticalStepAccuracy;
-	if (score.citationCoverage !== null) dimensions.citation_coverage = score.citationCoverage;
-	if (score.citationLabelAgreement !== null) dimensions.citation_label_agreement = score.citationLabelAgreement;
-	const notes = [
-		`${score.matchedIssueIds.length}/${score.expectedIssueCount} issues found`,
-		`${score.supportedFindingIndexes.length}/${score.supportedFindingIndexes.length + score.unsupportedFindingIndexes.length} findings supported`,
-		`${score.unlabeledEvidence.length} citations outside labeled locations`
-	].join("; ");
-	return {
-		dimensions,
-		composite: score.criticalStepAccuracy === null ? score.f1 : (score.f1 + score.criticalStepAccuracy) / 2,
-		notes
-	};
-}
-//#endregion
 //#region src/campaign/cross-surface-context.ts
 function validateCrossSurfaceInput(input) {
 	assertNonEmptyUnique(input.taskOrder, "taskOrder");
@@ -1045,264 +959,6 @@ function neutralizationGate(options) {
 	};
 }
 //#endregion
-//#region src/campaign/grounded-reflection.ts
-/**
-* Deterministic per-field diff of call arguments between passing and failing
-* rollouts. A field set by failing rollouts but left unset by passing ones is
-* the classic poison-input signature; a field whose values differ across the
-* split points at the correct value. Feed `text` to the reviser verbatim.
-*/
-function rolloutArgumentDiff(rollouts, opts = {}) {
-	const passThreshold = opts.passThreshold ?? 1;
-	const maxValues = opts.maxValuesPerField ?? 4;
-	const collect = (pass) => {
-		const byField = /* @__PURE__ */ new Map();
-		for (const r of rollouts) {
-			if (pass !== r.score >= passThreshold) continue;
-			for (const c of r.calls) for (const [k, v] of Object.entries(c.args)) {
-				const set = byField.get(k) ?? /* @__PURE__ */ new Set();
-				set.add(String(v));
-				byField.set(k, set);
-			}
-		}
-		return byField;
-	};
-	const passing = collect(true);
-	const failing = collect(false);
-	const lines = [];
-	for (const field of /* @__PURE__ */ new Set([...passing.keys(), ...failing.keys()])) {
-		const pv = [...passing.get(field) ?? []].slice(0, maxValues);
-		const fv = [...failing.get(field) ?? []].slice(0, maxValues);
-		const render = (vals) => vals.length ? JSON.stringify(vals) : "NOT SET (omitted)";
-		lines.push(`  ${field}: passing runs -> ${render(pv)} | failing runs -> ${render(fv)}`);
-	}
-	const lower = (m) => {
-		const out = /* @__PURE__ */ new Set();
-		for (const vals of m.values()) for (const v of vals) out.add(v.toLowerCase());
-		return out;
-	};
-	return {
-		text: lines.join("\n") || "  (no calls observed)",
-		passingValues: lower(passing),
-		failingValues: lower(failing)
-	};
-}
-/**
-* Scan revised artifact text for single-quoted single-word literals (the
-* "use exactly 'new'" pattern) that appear in no passing rollout's argument
-* values. Multi-word quotes pass (they are prose, not prescriptions).
-* Callers should reject on `harmful` (with a bounded retry) and at most log
-* `ungrounded` - see the module header for why the severities differ.
-*/
-function classifyUngroundedLiterals(text, diff) {
-	const ungrounded = /* @__PURE__ */ new Set();
-	for (const m of text.matchAll(/'([a-z][a-z_-]{1,19})'/gi)) {
-		const w = m[1].toLowerCase();
-		if (!diff.passingValues.has(w)) ungrounded.add(w);
-	}
-	const all = [...ungrounded];
-	return {
-		ungrounded: all,
-		harmful: all.filter((w) => diff.failingValues.has(w))
-	};
-}
-//#endregion
-//#region src/campaign/labeled-store/fs-adapter.ts
-/**
-* Filesystem `LabeledScenarioStore` adapter. The default capture sink for
-* traces + eval artifacts. Production deployments typically swap for a
-* Turso/SQLite adapter (same interface).
-*
-* Records land as one JSONL file per source under `<root>/<source>.jsonl`.
-* Each line is a `LabeledScenarioRecord`. Append-only — no in-place edits.
-*
-* Safety properties enforced at write-time:
-*
-*   - **Provenance required**: writes without `source`, `sourceVersionHash`,
-*     `capturedAt`, `redactionStatus` are rejected. Closes the alignment
-*     reviewer's data-poisoning gap.
-*   - **Per-source rate limits**: optional `rateLimitBucket` + `maxWritesPerMinute`
-*     stops a single tenant/source from flooding the store.
-*
-* Safety properties enforced at sample-time:
-*
-*   - **Required split + capturedBefore**: substrate refuses to sample without
-*     an explicit `split` ('train' | 'test') AND a temporal cutoff. Eliminates
-*     accidental train/test contamination.
-*   - **Default training-source filter**: when the store is sampled with
-*     `split: 'train'`, production-trace records are EXCLUDED unless the
-*     caller passes `filter.source: 'production-trace'` explicitly. Closes
-*     the contamination-by-default gap flagged by the senior eval engineer.
-*/
-/** Typed rejection from a labeled-scenario store (bad provenance, rate limit, invalid sample args) — carries a stable string `code`. */
-var LabeledScenarioStoreError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-		this.name = "LabeledScenarioStoreError";
-	}
-};
-/**
-* Filesystem `LabeledScenarioStore`: appends one JSONL file per source with provenance and
-* rate-limit guards. For tests, local dev, and small workloads — high-throughput lands in Turso.
-*/
-var FsLabeledScenarioStore = class {
-	options;
-	now;
-	rateLimits = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.options = options;
-		if (!existsSync(options.root)) mkdirSync(options.root, { recursive: true });
-		this.now = options.now ?? Date.now;
-	}
-	async observe(write) {
-		this.assertProvenance(write);
-		this.assertRateLimit(write);
-		const record = this.toRecord(write);
-		appendLine(this.pathForSource(write.source), `${JSON.stringify(record)}\n`);
-	}
-	async sample(args) {
-		if (!args.split) throw new LabeledScenarioStoreError("split_required", "sample() requires an explicit `split` (train | test) — substrate refuses ambiguous reads");
-		if (!args.capturedBefore) throw new LabeledScenarioStoreError("capturedBefore_required", "sample() requires an explicit `capturedBefore` timestamp for temporal-split discipline");
-		const all = [];
-		for (const source of ALL_SOURCES) {
-			if (args.split === "train" && source === "production-trace") {
-				if (!sourceFilterContains(args.filter?.source, "production-trace")) continue;
-			}
-			const path = this.pathForSource(source);
-			if (!existsSync(path)) continue;
-			const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
-			for (const line of lines) {
-				let record;
-				try {
-					record = JSON.parse(line);
-				} catch {
-					continue;
-				}
-				if (!matchesFilter(record, args, source)) continue;
-				all.push(record);
-			}
-		}
-		all.sort((a, b) => {
-			if (a.capturedAt !== b.capturedAt) return compareCodeUnits(a.capturedAt, b.capturedAt);
-			return compareCodeUnits(a.recordHash, b.recordHash);
-		});
-		return all.slice(0, args.count);
-	}
-	async size() {
-		const bySource = {};
-		const byTrust = {
-			unverified: 0,
-			"verified-signal": 0,
-			"human-rated": 0
-		};
-		let total = 0;
-		for (const source of ALL_SOURCES) {
-			const path = this.pathForSource(source);
-			if (!existsSync(path)) {
-				bySource[source] = 0;
-				continue;
-			}
-			const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
-			bySource[source] = lines.length;
-			total += lines.length;
-			for (const line of lines) {
-				let trust = "unverified";
-				try {
-					trust = JSON.parse(line).labelTrust ?? "unverified";
-				} catch {}
-				byTrust[trust] += 1;
-			}
-		}
-		return {
-			train: total,
-			test: total,
-			bySource,
-			byTrust
-		};
-	}
-	assertProvenance(write) {
-		if (!write.source) throw new LabeledScenarioStoreError("missing_source", "LabeledScenarioWrite requires `source`");
-		if (!write.sourceVersionHash || write.sourceVersionHash.length === 0) throw new LabeledScenarioStoreError("missing_source_version", "LabeledScenarioWrite requires `sourceVersionHash` (git sha or substrate version)");
-		if (!write.capturedAt) throw new LabeledScenarioStoreError("missing_captured_at", "LabeledScenarioWrite requires `capturedAt` ISO timestamp");
-		if (!write.redactionStatus) throw new LabeledScenarioStoreError("missing_redaction_status", "LabeledScenarioWrite requires explicit `redactionStatus` — raw / redacted-pii / redacted-secrets / fully-redacted");
-		if (!ALL_SOURCES.includes(write.source)) throw new LabeledScenarioStoreError("unknown_source", `LabeledScenarioWrite.source must be one of: ${ALL_SOURCES.join(", ")}`);
-	}
-	assertRateLimit(write) {
-		const cap = this.options.maxWritesPerMinutePerBucket;
-		if (!cap || !write.rateLimitBucket) return;
-		const now = this.now();
-		const windowMs = 6e4;
-		let state = this.rateLimits.get(write.rateLimitBucket);
-		if (!state || now - state.windowStartMs >= windowMs) {
-			state = {
-				bucket: write.rateLimitBucket,
-				windowStartMs: now,
-				count: 0
-			};
-			this.rateLimits.set(write.rateLimitBucket, state);
-		}
-		if (state.count >= cap) throw new LabeledScenarioStoreError("rate_limit_exceeded", `LabeledScenarioStore: bucket ${write.rateLimitBucket} exceeded ${cap} writes/min`);
-		state.count += 1;
-	}
-	toRecord(write) {
-		const recordHash = sha256$1(JSON.stringify({
-			id: write.scenario.id,
-			src: write.source,
-			at: write.capturedAt,
-			ver: write.sourceVersionHash
-		}));
-		return {
-			...write,
-			recordHash,
-			split: "train"
-		};
-	}
-	pathForSource(source) {
-		return join(this.options.root, `${source}.jsonl`);
-	}
-};
-const ALL_SOURCES = [
-	"production-trace",
-	"eval-run",
-	"manual",
-	"red-team",
-	"synthetic"
-];
-function sourceFilterContains(filter, needle) {
-	if (!filter) return false;
-	if (Array.isArray(filter)) return filter.includes(needle);
-	return filter === needle;
-}
-function matchesFilter(record, args, source) {
-	if (args.split === "train" && record.capturedAt >= args.capturedBefore) return false;
-	if (args.split === "test" && record.capturedAt < args.capturedBefore) return false;
-	const f = args.filter;
-	if (!f) return true;
-	if (f.kind && record.scenario.kind !== f.kind) return false;
-	if (f.source) {
-		if (!(Array.isArray(f.source) ? f.source : [f.source]).includes(source)) return false;
-	}
-	if (f.minComposite !== void 0 || f.maxComposite !== void 0) {
-		const composites = Object.values(record.judgeScores).map((s) => s.composite);
-		const max = composites.length === 0 ? 0 : Math.max(...composites);
-		if (f.minComposite !== void 0 && max < f.minComposite) return false;
-		if (f.maxComposite !== void 0 && max > f.maxComposite) return false;
-	}
-	if (f.minTrust !== void 0 && labelTrustRank(record.labelTrust) < labelTrustRank(f.minTrust)) return false;
-	return true;
-}
-function sha256$1(input) {
-	return createHash("sha256").update(input).digest("hex").slice(0, 16);
-}
-function appendLine(path, line) {
-	if (existsSync(path)) {
-		const existing = readFileSync(path, "utf8");
-		writeFileSync(path, existing + line);
-	} else writeFileSync(path, line);
-}
-//#endregion
 //#region src/campaign/neutralize.ts
 /**
 * @module
@@ -1442,20 +1098,6 @@ function sequentialOptimizationMethod(options) {
 //#endregion
 //#region src/campaign/presets/playback.ts
 /**
-* Adapt a `PlaybackDriver` into a `runProfileMatrix` dispatch. The artifact the
-* matrix scores is the `ProducedState` extracted from the driver's event
-* stream — grade it with `scoreUserStory` (or a judge wrapping it).
-*/
-function makePlaybackDispatch(driver) {
-	return async (profile, scenario, ctx) => {
-		const events = await driver.run(scenario, {
-			...ctx,
-			profile
-		});
-		return extractProducedState(events);
-	};
-}
-/**
 * Score one story's produced state against its requirements. Thin wrapper over
 * `verifyCompletion` that builds the gold from the story and returns a
 * per-requirement PASS/FAIL verdict. `checkCorrectness` is injected — a
@@ -2394,6 +2036,9 @@ const anchorEntrySchema = z.object({
 	bytes: z.number().int().positive(),
 	digest
 }).strict();
+function fail(message) {
+	throw new ValidationError(`retained dispatch: ${message}`);
+}
 /**
 * Persist dispatch intent before an external call and its validated result afterward.
 * Replays settled calls; never repeats an uncertain call or refunds its allowance.
@@ -2405,157 +2050,192 @@ const anchorEntrySchema = z.object({
 function createRetainedDispatch(options) {
 	if (!options.runDir.trim()) throw new ValidationError("retained dispatch requires a run directory");
 	const storage = options.storage ?? fsCampaignStorage();
-	const parse = options.parse;
 	const header = headerSchema.parse({
 		kind: "retained-dispatch-v1",
 		scope: hashCanonical(options.scope),
 		limits: Object.entries(options.limits).sort(([a], [b]) => compareCodeUnits(a, b))
 	});
 	if (!header.limits.length) throw new ValidationError("retained dispatch requires named allowances");
-	const limits = new Map(header.limits);
-	const counts = /* @__PURE__ */ new Map();
-	const calls = /* @__PURE__ */ new Map();
+	const journal = {
+		storage,
+		parse: options.parse,
+		header,
+		limits: new Map(header.limits),
+		counts: /* @__PURE__ */ new Map(),
+		calls: /* @__PURE__ */ new Map(),
+		indexPath: join(options.runDir, "dispatches.jsonl"),
+		scopePath: join(options.runDir, "dispatch-scope.json"),
+		anchorPath: join(options.runDir, "dispatch-anchor.jsonl"),
+		receiptsDir: join(options.runDir, "dispatch-results"),
+		scopeText: canonicalString(header),
+		scopeDigest: hashCanonical(header),
+		retainedText: "",
+		revision: 0,
+		chain: null,
+		opened: false
+	};
 	const active = /* @__PURE__ */ new Map();
-	const indexPath = join(options.runDir, "dispatches.jsonl");
-	const scopePath = join(options.runDir, "dispatch-scope.json");
-	const anchorPath = join(options.runDir, "dispatch-anchor.jsonl");
-	const scopeText = canonicalString(header);
-	const scopeDigest = hashCanonical(header);
-	const receiptsDir = join(options.runDir, "dispatch-results");
-	const resultPath = (id) => join(receiptsDir, `${id.slice(7)}.json`);
 	storage.ensureDir(options.runDir);
-	storage.ensureDir(receiptsDir);
-	let retainedText = "";
-	let revision = 0;
-	let chain = null;
-	let opened = false;
-	const fail = (message) => {
-		throw new ValidationError(`retained dispatch: ${message}`);
-	};
-	const apply = (event) => {
-		const existing = calls.get(event.id);
-		if (event.kind === "started") {
-			const limit = limits.get(event.lane);
-			const count = counts.get(event.lane) ?? 0;
-			if (existing || limit === void 0 || count >= limit) fail("invalid or over-budget dispatch history");
-			calls.set(event.id, { lane: event.lane });
-			counts.set(event.lane, count + 1);
-		} else {
-			if (!existing || existing.receipt) return fail("settlement has no unique pending dispatch");
-			existing.receipt = event.receipt;
-		}
-	};
-	const readAnchor = () => {
-		const content = storage.read(anchorPath);
-		if (content === void 0 && storage.exists(anchorPath)) fail("cannot read durable anchor");
-		const text = content ?? "";
-		if (text && !text.endsWith("\n")) fail("durable anchor is torn");
-		const entries = [];
-		let previous = 0;
-		const lines = text.split("\n");
-		if (lines.at(-1) === "") lines.pop();
-		if (lines.some((line) => !line)) fail("durable anchor contains an empty record");
-		for (const line of lines) {
-			const entry = anchorEntrySchema.parse(JSON.parse(line));
-			if (entry.scope !== scopeDigest) fail("durable anchor scope changed");
-			if (entry.bytes <= previous) fail("durable anchor is not append-only");
-			previous = entry.bytes;
-			entries.push(entry);
-		}
-		return {
-			text,
-			entries
-		};
-	};
-	const refresh = () => {
-		if (storage.read(scopePath) !== scopeText) fail("scope anchor is missing or changed");
-		const stored = storage.read(indexPath);
-		if (stored === void 0 && storage.exists(indexPath)) fail("cannot read existing history");
-		const text = stored ?? "";
-		if (!text.startsWith(retainedText) || text && !text.endsWith("\n")) fail("history was truncated, replaced or torn");
-		const { entries } = readAnchor();
-		const bytes = Buffer.byteLength(text);
-		const applied = Buffer.byteLength(retainedText);
-		if (text && !entries.length) fail("durable anchor is missing");
-		const highWater = entries[entries.length - 1];
-		if (highWater && bytes !== highWater.bytes) {
-			if (bytes < highWater.bytes) fail("history was truncated below its durable anchor");
-			fail("history extends beyond its durable anchor");
-		}
-		let offset = 0;
-		let running = null;
-		let entryIndex = 0;
-		let seenHeader = opened;
-		for (const line of text.split("\n")) {
-			if (!line) continue;
-			running = hashCanonical([running, line]);
-			offset += Buffer.byteLength(line) + 1;
-			while (entryIndex < entries.length && entries[entryIndex].bytes === offset) {
-				if (entries[entryIndex].digest !== running) fail("history diverges from its durable anchor");
-				entryIndex += 1;
-			}
-			if (offset <= applied) continue;
-			if (!seenHeader) {
-				const value = JSON.parse(line);
-				if (hashCanonical(headerSchema.parse(value)) !== hashCanonical(header)) fail("resume changed its scope or allowances");
-				seenHeader = true;
-			} else apply(eventSchema.parse(JSON.parse(line)));
+	storage.ensureDir(journal.receiptsDir);
+	openJournal(journal, options.requireExisting);
+	return {
+		/** The input binds all behavior-affecting request material, not just a caller-selected nonce. */
+		run(request) {
+			const id = hashCanonical([
+				header.scope,
+				request.lane,
+				request.input
+			]);
+			const pending = active.get(id);
+			if (pending) return pending;
+			const promise = dispatchOnce(journal, id, request);
+			active.set(id, promise);
+			promise.finally(() => {
+				active.delete(id);
+			}).catch(() => {});
+			return promise;
+		},
+		/** Counts include uncertain dispatches, which keep their reservation. No pricing is inferred. */
+		committed() {
+			refreshJournal(journal);
+			return new Map(header.limits.map(([lane]) => [lane, journal.counts.get(lane) ?? 0]));
 		}
-		if (entries.length && entryIndex !== entries.length) fail("history diverges from its durable anchor");
-		chain = running;
-		retainedText = text;
-		revision = bytes;
-		opened = seenHeader;
 	};
-	const append = (event) => {
-		const encoded = canonicalString(event);
-		const line = `${encoded}\n`;
-		const next = storage.append(indexPath, line, revision);
-		if (next === void 0) {
-			refresh();
-			return false;
-		}
-		if (next !== revision + Buffer.byteLength(line)) fail("storage returned an invalid append revision");
-		chain = hashCanonical([chain, encoded]);
-		retainedText += line;
-		revision = next;
-		if (event.kind === "retained-dispatch-v1") opened = true;
-		else apply(event);
-		return true;
+}
+/** Fold one journal event into the per-lane counts and pending-call map. */
+function applyEvent(journal, event) {
+	const existing = journal.calls.get(event.id);
+	if (event.kind === "started") {
+		const limit = journal.limits.get(event.lane);
+		const count = journal.counts.get(event.lane) ?? 0;
+		if (existing || limit === void 0 || count >= limit) fail("invalid or over-budget dispatch history");
+		journal.calls.set(event.id, { lane: event.lane });
+		journal.counts.set(event.lane, count + 1);
+	} else {
+		if (!existing || existing.receipt) fail("settlement has no unique pending dispatch");
+		existing.receipt = event.receipt;
+	}
+}
+/** Read the durable anchor file, refusing a torn, empty-record, foreign-scope or non-monotonic one. */
+function readAnchor(journal) {
+	const { storage, anchorPath } = journal;
+	const content = storage.read(anchorPath);
+	if (content === void 0 && storage.exists(anchorPath)) fail("cannot read durable anchor");
+	const text = content ?? "";
+	if (text && !text.endsWith("\n")) fail("durable anchor is torn");
+	const entries = [];
+	let previous = 0;
+	const lines = text.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	if (lines.some((line) => !line)) fail("durable anchor contains an empty record");
+	for (const line of lines) {
+		const entry = anchorEntrySchema.parse(JSON.parse(line));
+		if (entry.scope !== journal.scopeDigest) fail("durable anchor scope changed");
+		if (entry.bytes <= previous) fail("durable anchor is not append-only");
+		previous = entry.bytes;
+		entries.push(entry);
+	}
+	return {
+		text,
+		entries
 	};
-	const advanceAnchor = () => {
-		const currentChain = chain ?? fail("cannot anchor an empty history");
-		if (revision <= 0) fail("cannot anchor an empty history");
-		const { text, entries } = readAnchor();
-		const last = entries[entries.length - 1];
-		if (last) {
-			if (last.bytes > revision) fail("history is behind its durable anchor");
-			if (last.bytes === revision) {
-				if (last.digest !== currentChain) fail("history diverges from its durable anchor");
-				return;
-			}
+}
+/** Re-read the journal, prove it extends what was applied and matches its anchor, and apply the new events. */
+function refreshJournal(journal) {
+	const { storage } = journal;
+	if (storage.read(journal.scopePath) !== journal.scopeText) fail("scope anchor is missing or changed");
+	const stored = storage.read(journal.indexPath);
+	if (stored === void 0 && storage.exists(journal.indexPath)) fail("cannot read existing history");
+	const text = stored ?? "";
+	if (!text.startsWith(journal.retainedText) || text && !text.endsWith("\n")) fail("history was truncated, replaced or torn");
+	const { entries } = readAnchor(journal);
+	const bytes = Buffer.byteLength(text);
+	const applied = Buffer.byteLength(journal.retainedText);
+	if (text && !entries.length) fail("durable anchor is missing");
+	const highWater = entries[entries.length - 1];
+	if (highWater && bytes !== highWater.bytes) {
+		if (bytes < highWater.bytes) fail("history was truncated below its durable anchor");
+		fail("history extends beyond its durable anchor");
+	}
+	let offset = 0;
+	let running = null;
+	let entryIndex = 0;
+	let seenHeader = journal.opened;
+	for (const line of text.split("\n")) {
+		if (!line) continue;
+		running = hashCanonical([running, line]);
+		offset += Buffer.byteLength(line) + 1;
+		while (entryIndex < entries.length && entries[entryIndex].bytes === offset) {
+			if (entries[entryIndex].digest !== running) fail("history diverges from its durable anchor");
+			entryIndex += 1;
 		}
-		const line = `${canonicalString({
-			kind: "retained-dispatch-anchor-v1",
-			scope: scopeDigest,
-			bytes: revision,
-			digest: currentChain
-		})}\n`;
-		const next = storage.append(anchorPath, line, Buffer.byteLength(text));
-		if (next === void 0) {
-			const concurrent = readAnchor().entries.at(-1);
-			if (concurrent?.bytes === revision && concurrent.digest === chain) return;
-			fail("durable anchor append is busy; retry with the same run directory");
+		if (offset <= applied) continue;
+		if (!seenHeader) {
+			const value = JSON.parse(line);
+			if (hashCanonical(headerSchema.parse(value)) !== hashCanonical(journal.header)) fail("resume changed its scope or allowances");
+			seenHeader = true;
+		} else applyEvent(journal, eventSchema.parse(JSON.parse(line)));
+	}
+	if (entries.length && entryIndex !== entries.length) fail("history diverges from its durable anchor");
+	journal.chain = running;
+	journal.retainedText = text;
+	journal.revision = bytes;
+	journal.opened = seenHeader;
+}
+/** Compare-and-append one event; a lost race refreshes the journal and returns false. */
+function appendEvent(journal, event) {
+	const encoded = canonicalString(event);
+	const line = `${encoded}\n`;
+	const next = journal.storage.append(journal.indexPath, line, journal.revision);
+	if (next === void 0) {
+		refreshJournal(journal);
+		return false;
+	}
+	if (next !== journal.revision + Buffer.byteLength(line)) fail("storage returned an invalid append revision");
+	journal.chain = hashCanonical([journal.chain, encoded]);
+	journal.retainedText += line;
+	journal.revision = next;
+	if (event.kind === "retained-dispatch-v1") journal.opened = true;
+	else applyEvent(journal, event);
+	return true;
+}
+/** Record the journal's current length and digest in the durable anchor. */
+function advanceAnchor(journal) {
+	const currentChain = journal.chain ?? fail("cannot anchor an empty history");
+	if (journal.revision <= 0) fail("cannot anchor an empty history");
+	const { text, entries } = readAnchor(journal);
+	const last = entries[entries.length - 1];
+	if (last) {
+		if (last.bytes > journal.revision) fail("history is behind its durable anchor");
+		if (last.bytes === journal.revision) {
+			if (last.digest !== currentChain) fail("history diverges from its durable anchor");
+			return;
 		}
-		if (next !== Buffer.byteLength(text) + Buffer.byteLength(line)) fail("storage returned an invalid durable anchor revision");
-	};
-	/** An event takes effect only after both its journal append and its anchor entry are durable. */
-	const commit = (event) => {
-		if (!append(event)) return false;
-		advanceAnchor();
-		return true;
-	};
-	if (options.requireExisting && (!storage.exists(scopePath) || !storage.exists(indexPath) || !storage.exists(anchorPath))) fail("required retained history is missing");
+	}
+	const line = `${canonicalString({
+		kind: "retained-dispatch-anchor-v1",
+		scope: journal.scopeDigest,
+		bytes: journal.revision,
+		digest: currentChain
+	})}\n`;
+	const next = journal.storage.append(journal.anchorPath, line, Buffer.byteLength(text));
+	if (next === void 0) {
+		const concurrent = readAnchor(journal).entries.at(-1);
+		if (concurrent?.bytes === journal.revision && concurrent.digest === journal.chain) return;
+		fail("durable anchor append is busy; retry with the same run directory");
+	}
+	if (next !== Buffer.byteLength(text) + Buffer.byteLength(line)) fail("storage returned an invalid durable anchor revision");
+}
+/** An event takes effect only after both its journal append and its anchor entry are durable. */
+function commitEvent(journal, event) {
+	if (!appendEvent(journal, event)) return false;
+	advanceAnchor(journal);
+	return true;
+}
+/** Create or verify the scope anchor, load existing history, and commit the header on a fresh journal. */
+function openJournal(journal, requireExisting) {
+	const { storage, scopePath, indexPath, anchorPath, scopeText } = journal;
+	if (requireExisting && (!storage.exists(scopePath) || !storage.exists(indexPath) || !storage.exists(anchorPath))) fail("required retained history is missing");
 	if (storage.exists(scopePath)) {
 		if (storage.read(scopePath) !== scopeText) fail("resume changed its scope or allowances");
 		if (!storage.read(indexPath)?.trim()) fail("dispatch history is missing or empty");
@@ -2567,145 +2247,138 @@ function createRetainedDispatch(options) {
 			if (storage.read(scopePath) !== scopeText || !storage.read(indexPath)?.trim()) fail("scope initialization is busy; retry the same scope");
 		} else if (created !== Buffer.byteLength(scopeText)) fail("storage returned an invalid scope revision");
 	}
-	refresh();
-	if (!opened && !commit(header) && !opened) fail("history is busy; retry with the same run directory");
-	const readResult = (id) => {
-		const content = storage.read(resultPath(id));
-		if (content === void 0) return void 0;
-		const result = resultSchema.parse(JSON.parse(content));
-		if (result.id !== id) return fail("retained result dispatch id mismatch");
-		if (hashCanonical(result.value) !== result.receipt) return fail("retained result digest mismatch");
-		const value = parse(result.value);
-		if (hashCanonical(value) !== result.receipt) return fail("result decoder changed retained output");
-		return {
-			value,
-			receipt: result.receipt
-		};
+	refreshJournal(journal);
+	if (!journal.opened && !commitEvent(journal, journal.header) && !journal.opened) fail("history is busy; retry with the same run directory");
+}
+/** Read and verify a retained result file, or undefined when none was written. */
+function readResult(journal, id) {
+	const content = journal.storage.read(resultPath(journal, id));
+	if (content === void 0) return void 0;
+	const result = resultSchema.parse(JSON.parse(content));
+	if (result.id !== id) return fail("retained result dispatch id mismatch");
+	if (hashCanonical(result.value) !== result.receipt) return fail("retained result digest mismatch");
+	const value = journal.parse(result.value);
+	if (hashCanonical(value) !== result.receipt) return fail("result decoder changed retained output");
+	return {
+		value,
+		receipt: result.receipt
 	};
-	const settle = (id, receipt) => {
-		while (true) {
-			const existing = calls.get(id);
-			if (existing?.receipt) {
-				if (existing.receipt !== receipt) fail("settled result digest mismatch");
-				return;
-			}
-			if (!existing) fail("settlement has no pending dispatch");
-			const previousRevision = revision;
-			if (commit({
-				kind: "settled",
-				id,
-				receipt
-			})) return;
-			if (revision === previousRevision) fail("settlement is busy; retained result awaits reconciliation");
+}
+function resultPath(journal, id) {
+	return join(journal.receiptsDir, `${id.slice(7)}.json`);
+}
+/** Commit the settlement of a dispatch whose result is already durable. */
+function settle(journal, id, receipt) {
+	while (true) {
+		const existing = journal.calls.get(id);
+		if (existing?.receipt) {
+			if (existing.receipt !== receipt) fail("settled result digest mismatch");
+			return;
 		}
-	};
-	const load = (id, receipt) => {
-		const result = readResult(id);
-		if (!result) return fail("settled result is missing");
-		if (result.receipt !== receipt) return fail("settled result digest mismatch");
-		return {
-			succeeded: true,
-			value: result.value,
-			dispatchId: id,
-			receiptDigest: receipt,
-			replayed: true
-		};
-	};
+		if (!existing) fail("settlement has no pending dispatch");
+		const previousRevision = journal.revision;
+		if (commitEvent(journal, {
+			kind: "settled",
+			id,
+			receipt
+		})) return;
+		if (journal.revision === previousRevision) fail("settlement is busy; retained result awaits reconciliation");
+	}
+}
+/** Replay a settled dispatch from its retained result. */
+function loadSettled(journal, id, receipt) {
+	const result = readResult(journal, id);
+	if (!result) return fail("settled result is missing");
+	if (result.receipt !== receipt) return fail("settled result digest mismatch");
 	return {
-		/** The input binds all behavior-affecting request material, not just a caller-selected nonce. */
-		run(request) {
-			const { lane, dispatch, signal } = request;
-			const id = hashCanonical([
-				header.scope,
-				lane,
-				request.input
-			]);
-			const pending = active.get(id);
-			if (pending) return pending;
-			const work = async () => {
-				if (!limits.has(lane)) return fail("unknown allowance lane");
-				refresh();
-				while (true) {
-					const existing = calls.get(id);
-					if (existing) {
-						if (existing.receipt) return load(id, existing.receipt);
-						const result = readResult(id);
-						if (!result) return {
-							succeeded: false,
-							reason: "outcome_unknown",
-							dispatchId: id
-						};
-						settle(id, result.receipt);
-						return {
-							succeeded: true,
-							value: result.value,
-							dispatchId: id,
-							receiptDigest: result.receipt,
-							replayed: true
-						};
-					}
-					signal?.throwIfAborted();
-					if ((counts.get(lane) ?? 0) >= limits.get(lane)) return {
-						succeeded: false,
-						reason: "allowance_exhausted",
-						dispatchId: id
-					};
-					const previousRevision = revision;
-					if (commit({
-						kind: "started",
-						id,
-						lane
-					})) break;
-					if (revision === previousRevision) return fail("history is busy; retry with the same input");
-				}
-				let value;
-				try {
-					signal?.throwIfAborted();
-					value = parse(await dispatch());
-				} catch (error) {
-					return {
-						succeeded: false,
-						reason: "outcome_unknown",
-						dispatchId: id,
-						diagnostic: error instanceof Error ? error.message : String(error)
-					};
-				}
-				const encoded = canonicalString(value);
-				const decoded = JSON.parse(encoded);
-				const retainedValue = parse(decoded);
-				if (canonicalString(retainedValue) !== encoded) return fail("result decoder is not stable across serialization");
-				const receipt = hashCanonical(decoded);
-				const retainedResult = canonicalString({
-					kind: "retained-dispatch-result-v1",
-					id,
-					receipt,
-					value: decoded
-				});
-				const file = resultPath(id);
-				if (storage.append(file, retainedResult, 0) === void 0 && storage.read(file) !== retainedResult) fail("cannot retain dispatch result");
-				settle(id, receipt);
-				return {
-					succeeded: true,
-					value: retainedValue,
-					dispatchId: id,
-					receiptDigest: receipt,
-					replayed: false
-				};
+		succeeded: true,
+		value: result.value,
+		dispatchId: id,
+		receiptDigest: receipt,
+		replayed: true
+	};
+}
+/** Replay a known dispatch, or commit its started intent; returns the outcome when no call should be made. */
+function claimDispatch(journal, id, lane, signal) {
+	while (true) {
+		const existing = journal.calls.get(id);
+		if (existing) {
+			if (existing.receipt) return loadSettled(journal, id, existing.receipt);
+			const result = readResult(journal, id);
+			if (!result) return {
+				succeeded: false,
+				reason: "outcome_unknown",
+				dispatchId: id
+			};
+			settle(journal, id, result.receipt);
+			return {
+				succeeded: true,
+				value: result.value,
+				dispatchId: id,
+				receiptDigest: result.receipt,
+				replayed: true
 			};
-			const promise = work();
-			active.set(id, promise);
-			promise.finally(() => {
-				active.delete(id);
-			}).catch(() => {});
-			return promise;
-		},
-		/** Counts include uncertain dispatches, which keep their reservation. No pricing is inferred. */
-		committed() {
-			refresh();
-			return new Map(header.limits.map(([lane]) => [lane, counts.get(lane) ?? 0]));
 		}
+		signal?.throwIfAborted();
+		if ((journal.counts.get(lane) ?? 0) >= journal.limits.get(lane)) return {
+			succeeded: false,
+			reason: "allowance_exhausted",
+			dispatchId: id
+		};
+		const previousRevision = journal.revision;
+		if (commitEvent(journal, {
+			kind: "started",
+			id,
+			lane
+		})) return void 0;
+		if (journal.revision === previousRevision) return fail("history is busy; retry with the same input");
+	}
+}
+/** Retain a dispatched value's result file, settle it, and return the decoded outcome. */
+function retainResult(journal, id, value) {
+	const encoded = canonicalString(value);
+	const decoded = JSON.parse(encoded);
+	const retainedValue = journal.parse(decoded);
+	if (canonicalString(retainedValue) !== encoded) return fail("result decoder is not stable across serialization");
+	const receipt = hashCanonical(decoded);
+	const retainedResult = canonicalString({
+		kind: "retained-dispatch-result-v1",
+		id,
+		receipt,
+		value: decoded
+	});
+	const file = resultPath(journal, id);
+	if (journal.storage.append(file, retainedResult, 0) === void 0 && journal.storage.read(file) !== retainedResult) fail("cannot retain dispatch result");
+	settle(journal, id, receipt);
+	return {
+		succeeded: true,
+		value: retainedValue,
+		dispatchId: id,
+		receiptDigest: receipt,
+		replayed: false
 	};
 }
+/** Replay, claim an allowance, call the dispatch once, and retain its result. */
+async function dispatchOnce(journal, id, request) {
+	const { lane, dispatch, signal } = request;
+	if (!journal.limits.has(lane)) return fail("unknown allowance lane");
+	refreshJournal(journal);
+	const claimed = claimDispatch(journal, id, lane, signal);
+	if (claimed) return claimed;
+	let value;
+	try {
+		signal?.throwIfAborted();
+		value = journal.parse(await dispatch());
+	} catch (error) {
+		return {
+			succeeded: false,
+			reason: "outcome_unknown",
+			dispatchId: id,
+			diagnostic: error instanceof Error ? error.message : String(error)
+		};
+	}
+	return retainResult(journal, id, value);
+}
 //#endregion
 //#region src/campaign/scenario-selection.ts
 const DEFAULT_SATURATION_CEILING = .999;
@@ -2761,155 +2434,6 @@ function scoreDiscrimination(signals, opts) {
 		};
 	}).sort(compareDiscrimination);
 }
-/**
-* Select the top-`k` most discriminative scenario ids for a holdout, EXCLUDING
-* fully saturated ties when enough non-tied scenarios exist (a tie in the
-* holdout wastes a paired cell).
-*
-* Prefers non-tied scenarios; if fewer than `k` non-tied exist, fills with the
-* least-saturated tied ones (tied scenarios are already ordered least-saturated
-* first by `meanScore` asc). Deterministic. Throws if `k < 1`. If
-* `signals.length <= k`, returns all ids in discrimination order.
-*/
-function selectDiscriminative(signals, k, opts) {
-	if (k < 1) throw new Error(`selectDiscriminative: k must be >= 1 (got ${k})`);
-	const ranked = scoreDiscrimination(signals, opts);
-	if (ranked.length <= k) return ranked.map((s) => s.scenarioId);
-	const nonTied = ranked.filter((s) => !s.tied);
-	if (nonTied.length >= k) return nonTied.slice(0, k).map((s) => s.scenarioId);
-	const fill = ranked.filter((s) => s.tied).slice(0, k - nonTied.length);
-	return [...nonTied, ...fill].map((s) => s.scenarioId);
-}
-//#endregion
-//#region src/campaign/upstream-evaluators.ts
-function phoenixEvaluatorJudge(evaluator, options) {
-	if ((evaluator.optimizationDirection === "MINIMIZE" || evaluator.optimizationDirection === "NEUTRAL") && !options.toComposite) throw new TypeError(`phoenixEvaluatorJudge requires toComposite for a ${evaluator.optimizationDirection} evaluator`);
-	const paidCall = validatePaidEvaluation(evaluator.name, evaluator.kind, options.paidCall);
-	return upstreamJudge({
-		name: options.name ?? evaluator.name,
-		dimension: options.dimension,
-		judgeVersion: options.judgeVersion,
-		appliesTo: options.appliesTo,
-		toComposite: options.toComposite
-	}, async (input) => {
-		const result = await runUpstreamEvaluation({
-			name: evaluator.name,
-			kind: evaluator.kind,
-			signal: input.signal,
-			costLedger: input.costLedger,
-			costPhase: input.costPhase,
-			costTags: input.costTags,
-			scenarioId: input.scenario.id,
-			paidCall,
-			execute: (context) => evaluator.evaluate(options.mapInput({
-				artifact: input.artifact,
-				scenario: input.scenario
-			}), context)
-		});
-		if (result.score === void 0 || !Number.isFinite(result.score)) throw new Error(`${evaluator.name}: Phoenix evaluator returned no finite score`);
-		return {
-			score: result.score,
-			notes: [result.label, result.explanation].filter(Boolean).join(": ") || evaluator.name
-		};
-	});
-}
-function autoevalsScorerJudge(scorer, options) {
-	const paidCall = validatePaidEvaluation(options.name, options.kind, options.paidCall);
-	return upstreamJudge(options, async (input) => {
-		const result = await runUpstreamEvaluation({
-			name: options.name,
-			kind: options.kind,
-			signal: input.signal,
-			costLedger: input.costLedger,
-			costPhase: input.costPhase,
-			costTags: input.costTags,
-			scenarioId: input.scenario.id,
-			paidCall,
-			execute: (context) => scorer(options.mapInput({
-				artifact: input.artifact,
-				scenario: input.scenario
-			}), context)
-		});
-		if (result.score === null || !Number.isFinite(result.score)) throw new Error(`${options.name}: Autoevals scorer returned no finite score`);
-		return {
-			score: result.score,
-			notes: result.metadata ? JSON.stringify(result.metadata) : result.name
-		};
-	});
-}
-function upstreamJudge(options, evaluate) {
-	const dimension = options.dimension ?? options.name;
-	return {
-		name: options.name,
-		judgeVersion: options.judgeVersion,
-		dimensions: [{
-			key: dimension,
-			description: `Score from ${options.name}`
-		}],
-		appliesTo: options.appliesTo,
-		async score(input) {
-			const result = await evaluate(input);
-			const composite = options.toComposite ? options.toComposite(result.score) : result.score;
-			if (!Number.isFinite(composite)) throw new Error(`${options.name}: toComposite returned a non-finite score`);
-			return {
-				dimensions: { [dimension]: result.score },
-				composite,
-				notes: result.notes
-			};
-		}
-	};
-}
-function validatePaidEvaluation(name, kind, paidCall) {
-	if (kind === "CODE") {
-		if (paidCall) throw new TypeError(`${name}: CODE evaluator cannot declare paidCall`);
-		return;
-	}
-	if (!paidCall) throw new TypeError(`${name}: LLM evaluator requires paidCall cost and token capture`);
-	if (!paidCall.model.trim()) throw new TypeError(`${name}: paidCall.model must be non-empty`);
-	return paidCall;
-}
-async function runUpstreamEvaluation(input) {
-	if (input.kind === "CODE") return abortableEvaluation(input.signal, () => input.execute({ signal: input.signal }));
-	if (!input.paidCall) throw new CostAccountingIncompleteError(`${input.name}: missing paid-call configuration`);
-	if (!input.costLedger) throw new CostAccountingIncompleteError(`${input.name}: LLM evaluator requires the campaign cost ledger`);
-	const paid = await input.costLedger.runPaidCall({
-		channel: "judge",
-		phase: input.costPhase ?? "judge",
-		actor: input.name,
-		model: input.paidCall.model,
-		...input.paidCall.maximumCharge ? { maximumCharge: input.paidCall.maximumCharge } : {},
-		tags: {
-			...input.costTags,
-			scenarioId: input.scenarioId
-		},
-		signal: input.signal,
-		execute: (signal, callId) => Promise.resolve(input.execute({
-			signal,
-			callId
-		})),
-		receipt: input.paidCall.receipt,
-		...input.paidCall.receiptFromError ? { receiptFromError: input.paidCall.receiptFromError } : {}
-	});
-	if (!paid.succeeded) throw paid.error;
-	const recorded = input.costLedger.list().find((receipt) => receipt.callId === paid.callId);
-	if (!recorded) throw new CostAccountingIncompleteError(`${input.name}: paid evaluator returned without a recorded cost receipt`);
-	if (recorded.costUnknown || recorded.usageUnknown) throw new CostAccountingIncompleteError(`${input.name}: paid evaluator returned without complete cost and token usage`);
-	return paid.value;
-}
-async function abortableEvaluation(signal, execute) {
-	if (signal.aborted) throw signal.reason;
-	let rejectAborted;
-	const aborted = new Promise((_resolve, reject) => {
-		rejectAborted = reject;
-	});
-	const onAbort = () => rejectAborted(signal.reason);
-	signal.addEventListener("abort", onAbort, { once: true });
-	try {
-		return await Promise.race([Promise.resolve().then(execute), aborted]);
-	} finally {
-		signal.removeEventListener("abort", onAbort);
-	}
-}
 //#endregion
 //#region src/campaign/worktree/index.ts
 /**
@@ -3432,6 +2956,6 @@ function resolveWorktreePath(surface, worktreeDir) {
 	return verifyCodeSurface(surface, worktreeDir).path;
 }
 //#endregion
-export { loadEvalFixtureScenarios as A, FsLabeledScenarioStore as C, neutralizationGate as D, rolloutArgumentDiff as E, analyzeCrossSurfaceInteractions as M, buildTraceAnalystSurfaceDispatch as N, discoverEvalFixtures as O, traceAnalystQualityJudge as P, neutralizeText as S, classifyUngroundedLiterals as T, scoreUserStory as _, autoevalsScorerJudge as a, scopedOptimizationMethod as b, selectDiscriminative as c, finalizeProfileMatrix as d, runProfileMatrixSegment as f, renderScoreboardMarkdown as g, makePlaybackDispatch as h, verifyCodeSurface as i, planEvalFixtureRun as j, loadEvalFixture as k, createRetainedDispatch as l, runProfileMatrix as m, gitWorktreeAdapter as n, phoenixEvaluatorJudge as o, ProfileMatrixError as p, resolveWorktreePath as r, scoreDiscrimination as s, WorktreeAdapterError as t, createProfileMatrixPlan as u, scoreboardSummary as v, LabeledScenarioStoreError as w, sequentialOptimizationMethod as x, userStoryScoreboard as y };
+export { analyzeCrossSurfaceInteractions as S, neutralizationGate as _, createRetainedDispatch as a, loadEvalFixtureScenarios as b, runProfileMatrixSegment as c, scoreUserStory as d, scoreboardSummary as f, neutralizeText as g, sequentialOptimizationMethod as h, scoreDiscrimination as i, runProfileMatrix as l, scopedOptimizationMethod as m, resolveWorktreePath as n, createProfileMatrixPlan as o, userStoryScoreboard as p, verifyCodeSurface as r, finalizeProfileMatrix as s, gitWorktreeAdapter as t, renderScoreboardMarkdown as u, discoverEvalFixtures as v, planEvalFixtureRun as x, loadEvalFixture as y };
 
-//# sourceMappingURL=campaign-BudZ70zo.js.map
+//# sourceMappingURL=campaign-CGvUTnmc.js.map