@tangle-network/agent-eval 0.217.1 → 0.219.0

package/dist/{campaign-CJGkxAQ6.js → campaign-BVPC6ODQ.js}

@@ -1,22 +1,22 @@
 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-B_jw6C9p.js";
+import { c as agentProfileModelId, o as agentProfileHash, r as verifyCompletion, s as agentProfileId, u as harnessAxisOf } from "./completion-verifier-Cigap8CG.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-C8jMTNNG.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-Cc8vDJh_.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-CQYw8_0H.js";
-import { a as mapConcurrent } from "./journal-CR4QikYp.js";
-import { M as fsCampaignStorage } from "./external-optimizer-subprocess-XIHBOSKt.js";
-import "./pareto-BzsxidFD.js";
-import "./search-ledger-TUvB5gWH.js";
-import "./search-summary-DQIvJsSB.js";
-import "./external-optimizer-process-KVFGvYX1.js";
-import "./skillopt-optimization-method-kyL94-ri.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-D670Oxf2.js";
+import "./pareto-BiBnQXAE.js";
+import "./search-ledger-CZRqtFbW.js";
+import "./search-summary-D4bwYnAE.js";
+import "./external-optimizer-process-wOLfzsCC.js";
+import "./skillopt-optimization-method-DLKqdhcR.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 } from "node:fs";
@@ -24,6 +24,145 @@ 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/cost-breakdown.ts
+/** Read the source rates for this execution, never a copied model price table.
+* inputTokens includes cachedTokens. Seat credits are standard model credits;
+* discounts and MCP charges require provider observations, not token guesses.
+* The existing USD receipt remains the Router charge. Sandbox is additional.
+*/
+async function measureCampaignCost(input) {
+	const sources = [];
+	const unknown = {
+		kind: "uncaptured",
+		usd: null
+	};
+	if (input.routerUsd !== void 0) finite(input.routerUsd, "routerUsd");
+	const result = {
+		router: input.routerUsd === void 0 ? unknown : {
+			kind: "observed",
+			usd: input.routerUsd
+		},
+		sandbox: unknown,
+		seatCredits: {
+			kind: "uncaptured",
+			credits: null,
+			reason: "No seat usage supplied"
+		},
+		sources
+	};
+	const read = async (url) => {
+		const response = await fetch(url, { signal: input.signal ? AbortSignal.any([input.signal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3) });
+		if (!response.ok) throw new Error(`Rate source HTTP ${response.status}`);
+		if (Number(response.headers.get("content-length")) > 1e6) throw new Error("Rate source too large");
+		const chunks = [];
+		let bytes = 0;
+		for await (const chunk of response.body ?? []) {
+			bytes += chunk.byteLength;
+			if (bytes > 1e6) throw new Error("Rate source too large");
+			chunks.push(chunk);
+		}
+		const text = Buffer.concat(chunks).toString("utf8");
+		return {
+			text,
+			snapshot: {
+				url,
+				readAt: (/* @__PURE__ */ new Date()).toISOString(),
+				sha256: createHash("sha256").update(text).digest("hex")
+			}
+		};
+	};
+	if (input.sandbox) {
+		for (const [key, value] of Object.entries(input.sandbox)) if (key !== "pool") finite(value, `sandbox.${key}`);
+		try {
+			const { text, snapshot } = await read("https://sandbox.tangle.tools/v1/pricing/sandboxes");
+			const card = JSON.parse(text).pools?.[input.sandbox.pool ?? "general"];
+			const rates = {};
+			for (const key of [
+				"cpuCoreHourUsd",
+				"memoryGBHourUsd",
+				"diskGBHourUsd",
+				"minChargeHourUsd"
+			]) {
+				finite(card?.[key], key);
+				rates[key] = card[key];
+			}
+			const s = input.sandbox;
+			const usd = Math.max(rates.minChargeHourUsd, s.cpu * rates.cpuCoreHourUsd + s.memoryGB * rates.memoryGBHourUsd + s.diskGB * rates.diskGBHourUsd) * s.seconds / 3600;
+			finite(usd, "sandbox USD estimate");
+			result.sandbox = {
+				kind: "estimated",
+				usd
+			};
+			sources.push({
+				...snapshot,
+				rates
+			});
+		} catch {}
+	}
+	if (input.seat) {
+		const { usage, model } = input.seat;
+		if (usage.usageUnknown || usage.cachedTokens === void 0) {
+			result.seatCredits = {
+				kind: "uncaptured",
+				credits: null,
+				reason: "Seat token or cached-input usage is unknown"
+			};
+			return result;
+		}
+		for (const key of [
+			"inputTokens",
+			"cachedTokens",
+			"outputTokens"
+		]) {
+			const value = usage[key];
+			if (!Number.isSafeInteger(value) || value < 0) throw new Error(`seat.${key} must be a known nonnegative token count`);
+		}
+		if (usage.cachedTokens > usage.inputTokens) throw new Error("cachedTokens exceeds inputTokens");
+		try {
+			const { text, snapshot } = await read("https://docs.z.ai/devpack/overview.md");
+			const modelName = model.split("/").at(-1).toLowerCase();
+			const section = text.split("#### Credit Calculation")[1]?.split("#### Estimated Token Allowance")[0];
+			if (!section) throw new Error("Credit calculation section unavailable");
+			const matching = [...section.matchAll(/<tr>\s*([\s\S]*?)<\/tr>/gu)].filter((row) => {
+				return [...row[1].matchAll(/<td\b[^>]*>([\s\S]*?)<\/td>/gu)].map((cell) => cell[1].trim()).some((cell) => cell.split(/\\|\n|</u)[0].trim().toLowerCase() === modelName);
+			});
+			if (matching.length !== 1) throw new Error(`No unique live credit row for '${model}'`);
+			const rateCells = [...matching[0][1].matchAll(/<td\b[^>]*>([\s\S]*?)<\/td>/gu)].map((cell) => cell[1].trim()).slice(-3);
+			if (rateCells.length !== 3 || rateCells.some((cell) => !/^(?:\d+)(?:\.\d+)?$/u.test(cell))) throw new Error("Invalid live credit multipliers");
+			const multipliers = rateCells.map(Number);
+			for (const rate of multipliers) finite(rate, "credit multiplier");
+			const divisor = Number(section.match(/Model credit usage[^\n]*\/\s*([\d,]+)/u)?.[1]?.replaceAll(",", ""));
+			if (!Number.isFinite(divisor) || divisor <= 0) throw new Error("No live credit divisor");
+			const [fresh, cached, output] = multipliers;
+			const credits = ((usage.inputTokens - usage.cachedTokens) * fresh + usage.cachedTokens * cached + usage.outputTokens * output) / divisor;
+			finite(credits, "standard seat credits");
+			result.seatCredits = {
+				kind: "estimated",
+				credits
+			};
+			sources.push({
+				...snapshot,
+				rates: {
+					inputMultiplier: fresh,
+					cachedInputMultiplier: cached,
+					outputMultiplier: output,
+					divisor
+				}
+			});
+		} catch (error) {
+			result.seatCredits = {
+				kind: "uncaptured",
+				credits: null,
+				reason: error instanceof Error ? error.message : "Credit source unavailable"
+			};
+		}
+	}
+	return result;
+}
+function finite(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error(`${label} must be finite and nonnegative`);
+}
+//#endregion
 //#region src/campaign/cross-surface-context.ts
 function validateCrossSurfaceInput(input) {
 	assertNonEmptyUnique(input.taskOrder, "taskOrder");
@@ -2036,6 +2175,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.
@@ -2047,157 +2189,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");
@@ -2209,145 +2386,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;
@@ -2925,6 +3095,6 @@ function resolveWorktreePath(surface, worktreeDir) {
 	return verifyCodeSurface(surface, worktreeDir).path;
 }
 //#endregion
-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 };
+export { measureCampaignCost as C, 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-CJGkxAQ6.js.map
+//# sourceMappingURL=campaign-BVPC6ODQ.js.map