@tangle-network/agent-eval 0.142.2 → 0.144.0

package/dist/{skillopt-optimization-method-DV6c4ooy.js → skillopt-optimization-method-Ds8J1_K8.js}

@@ -2,13 +2,13 @@ import { c as ValidationError, i as JudgeError, t as AgentEvalError } from "./er
 import { i as CostLedger, t as CostAccountingIncompleteError } from "./cost-ledger-DMFxsLKr.js";
 import { f as maximumChargeForLlmRequest, l as costReceiptFromLlm, m as stripFencedJson, u as costReceiptFromLlmError } from "./llm-client-B3WXSH5Y.js";
 import { a as clamp01, o as combineAbortSignals, t as assertProposalFindings } from "./proposal-findings-2GIUo1et.js";
-import { C as safePathComponent, S as removeCredentialEnvironment, _ as assertJsonValue, b as isExternalTextCandidate, d as runWithCleanup, f as startExternalOptimizerModelProxy, g as assertExternalOptimizerModelBudget, h as sendJson, l as runExternalOptimizerProcess, m as listenLocal, n as createRunCostLedger, p as closeServer, r as fsCampaignStorage, t as acquireSingleRunLock, u as closeExternalOptimizerResources, v as assertNoCredentialValues, x as isRecord, y as isCandidateText } from "./single-run-lock-BcvPQY57.js";
+import { C as assertNoCredentialValues, D as removeCredentialEnvironment, E as isRecord, O as safePathComponent, S as assertJsonValue, T as isExternalTextCandidate, _ as canonicalJson, d as runWithCleanup, f as startExternalOptimizerModelProxy, h as sendJson, l as runExternalOptimizerProcess, m as listenLocal, n as createRunCostLedger, p as closeServer, r as fsCampaignStorage, t as acquireSingleRunLock, u as closeExternalOptimizerResources, v as contentHash, w as isCandidateText, x as assertExternalOptimizerModelBudget } from "./single-run-lock-t1si1ob7.js";
 import { p as mapConcurrent } from "./ledger-core-Dxz0Rkwa.js";
 import { E as pairedBootstrap, H as weightedComposite, M as pairedRiskDifferenceScore, N as pairedSignTest, O as pairedDeltaTieFraction, T as pairedBinaryScale, d as confidenceInterval, j as pairedRiskDifferenceExact } from "./statistics-ByxzSiOM.js";
 import { t as DEFAULT_REDACTION_RULES } from "./redact-7Aq1ukl-.js";
-import { a as campaignCellExecutionEvidence, l as projectCampaignCellQuality, t as detectRewardHacking } from "./reward-hacking-GyN0kMd8.js";
+import { a as campaignCellCostProvenance, o as campaignCellExecutionEvidence, t as detectRewardHacking, u as projectCampaignCellQuality } from "./reward-hacking-DjTi9HLb.js";
 import { z } from "zod";
-import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { writeFileSync } from "node:fs";
 import { basename, isAbsolute, join } from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
@@ -656,160 +656,6 @@ function paretoFrontierWithCrowding(candidates, objectives) {
 	return crowdingDistance(frontier, objectives).sort((a, b) => b.distance - a.distance);
 }
 //#endregion
-//#region src/verdict-cache.ts
-/**
-* Content-addressed judge-verdict caching.
-*
-* LAW: cache JUDGE VERDICTS only — judging the same artifact with the same
-* judge+rubric is pure. NEVER cache agent rollouts. (A router that cached
-* identical fanout prompts silently destroyed best-of-N diversity; rollout
-* caching reintroduces that failure class. Judging has no diversity to
-* destroy — same artifact + same rubric ⇒ same verdict is the desired
-* property, not a bug.)
-*
-* The cache key is a sha-256 over the canonical JSON of everything that can
-* change a verdict: the artifact content, the scenario id, the judge name,
-* the full dimension list (key + description — the description IS the rubric
-* text shown to the judge), and a caller-supplied `judgeVersion`.
-* `judgeVersion` is REQUIRED: a judge whose prompt/model/ensemble changes
-* without a version bump would otherwise silently serve stale verdicts.
-*
-* Strict canonicalization (`canonicalJson`) throws on undefined / function /
-* symbol / non-finite numbers — an artifact that cannot be unambiguously
-* serialized cannot be content-addressed, and coercing it would let two
-* different artifacts collide on one key.
-*/
-function canonicalizeAt(value, path) {
-	if (value === null) return "null";
-	switch (typeof value) {
-		case "boolean": return value ? "true" : "false";
-		case "number":
-			if (!Number.isFinite(value)) throw new Error(`canonicalJson: non-finite number (${value}) at ${path} — ambiguity is an error, not a coercion`);
-			return JSON.stringify(value);
-		case "string": return JSON.stringify(value);
-		case "undefined":
-		case "function":
-		case "symbol": throw new Error(`canonicalJson: ${typeof value} at ${path} — ambiguity is an error, not a coercion`);
-		case "bigint": throw new Error(`canonicalJson: bigint at ${path} — not representable in JSON`);
-		case "object": break;
-	}
-	const obj = value;
-	if (typeof obj.toJSON === "function") return canonicalizeAt(obj.toJSON(), path);
-	if (Array.isArray(obj)) return `[${obj.map((item, i) => canonicalizeAt(item, `${path}[${i}]`)).join(",")}]`;
-	if (obj instanceof Map || obj instanceof Set) throw new Error(`canonicalJson: ${obj instanceof Map ? "Map" : "Set"} at ${path} — would serialize as '{}'; convert to a plain object/array first`);
-	return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${canonicalizeAt(obj[k], `${path}.${k}`)}`).join(",")}}`;
-}
-/**
-* Stable JSON stringify: object keys sorted recursively, so two semantically
-* equal values produce byte-identical output regardless of key insertion
-* order. Throws on undefined / function / symbol / NaN / ±Infinity / bigint /
-* Map / Set — anything JSON.stringify would coerce or drop silently.
-*
-* Distinct from `pre-registration.ts`'s `canonicalize`/`hashJson`, which are
-* permissive (coercion allowed) and async (web-crypto). Use THIS pair when a
-* hash collision or silent coercion would corrupt a cache key or attestation.
-*/
-function canonicalJson(value) {
-	return canonicalizeAt(value, "$");
-}
-/** Hex sha-256 over `canonicalJson(value)`. The content address used by the
-*  verdict cache and report attestation. */
-function contentHash(value) {
-	return createHash("sha256").update(canonicalJson(value)).digest("hex");
-}
-/** Process-local Map-backed store. */
-function inMemoryVerdictCache() {
-	const entries = /* @__PURE__ */ new Map();
-	return {
-		get: (key) => entries.get(key),
-		set: (key, score) => {
-			entries.set(key, score);
-		}
-	};
-}
-function parseCacheLine(line, path, lineNo) {
-	let parsed;
-	try {
-		parsed = JSON.parse(line);
-	} catch (err) {
-		throw new Error(`fileVerdictCache: corrupt JSONL at ${path}:${lineNo} — ${err instanceof Error ? err.message : String(err)}`);
-	}
-	const rec = parsed;
-	if (typeof rec !== "object" || rec === null || typeof rec.key !== "string" || typeof rec.score !== "object" || rec.score === null || typeof rec.score.composite !== "number" || typeof rec.score.dimensions !== "object") throw new Error(`fileVerdictCache: invalid record shape at ${path}:${lineNo} — expected {key, score:{dimensions, composite, notes}}`);
-	return rec;
-}
-/**
-* JSONL-file-backed store: the full file is loaded into an in-memory index at
-* construction; every `set` appends one line synchronously (durable before
-* the verdict is returned). A corrupt or malformed line throws at load with
-* file:line — a skipped line would silently re-judge (cost) or, worse, mask
-* a half-written file that needs operator attention.
-*/
-function fileVerdictCache(path) {
-	const entries = /* @__PURE__ */ new Map();
-	if (existsSync(path)) {
-		const lines = readFileSync(path, "utf8").split("\n");
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i];
-			if (line === void 0 || line.trim() === "") continue;
-			const rec = parseCacheLine(line, path, i + 1);
-			entries.set(rec.key, rec.score);
-		}
-	}
-	return {
-		get: (key) => entries.get(key),
-		set: (key, score) => {
-			appendFileSync(path, `${JSON.stringify({
-				key,
-				score
-			})}\n`, "utf8");
-			entries.set(key, score);
-		}
-	};
-}
-/**
-* Wrap a `JudgeConfig` so repeat judgments of the same artifact are served
-* from the store instead of re-invoking `score()`. The wrapper is generic
-* over the judge's own type parameters and preserves `appliesTo` — it is a
-* drop-in replacement anywhere a `JudgeConfig` is accepted.
-*
-* A judge that throws is NOT cached: the error propagates and the next
-* attempt re-judges (caching a failure would pin a transient outage forever).
-*/
-function cachedJudge(judge, store, options) {
-	if (typeof options.judgeVersion !== "string" || options.judgeVersion.trim() === "") throw new Error("cachedJudge: judgeVersion is required and must be a non-empty string");
-	const stats = {
-		hits: 0,
-		misses: 0
-	};
-	const wrapped = {
-		name: judge.name,
-		dimensions: judge.dimensions,
-		judgeVersion: options.judgeVersion,
-		async score(input) {
-			const key = contentHash({
-				artifact: canonicalJson(input.artifact),
-				scenarioId: input.scenario.id,
-				judgeName: judge.name,
-				dimensions: judge.dimensions,
-				judgeVersion: options.judgeVersion
-			});
-			const cached = await store.get(key);
-			if (cached !== void 0) {
-				stats.hits += 1;
-				return cached;
-			}
-			const score = await judge.score(input);
-			await store.set(key, score);
-			stats.misses += 1;
-			return score;
-		},
-		stats: () => ({ ...stats })
-	};
-	if (judge.appliesTo) wrapped.appliesTo = judge.appliesTo;
-	return wrapped;
-}
-//#endregion
 //#region src/llm-judge.ts
 /**
 * `llmJudge` — the single-LLM-call bridge that turns a rubric prompt into a
@@ -1813,6 +1659,8 @@ async function startExternalOptimizerCallback(args) {
 	let closePromise;
 	const activeControllers = /* @__PURE__ */ new Set();
 	const activeHandlers = /* @__PURE__ */ new Set();
+	const proposedCandidateHashes = /* @__PURE__ */ new Set();
+	let observationSequence = 0;
 	const server = createServer((request, response) => {
 		if (!accepting) {
 			sendJsonIfOpen(response, 503, { error: "external optimizer callback is closing" });
@@ -1833,7 +1681,13 @@ async function startExternalOptimizerCallback(args) {
 			if (accepted > args.maxEvaluations) return void 0;
 			evaluations += 1;
 			return accepted;
-		}).finally(() => {
+		}, (observation) => {
+			if (!args.observe) return;
+			args.observe({
+				...observation,
+				sequence: ++observationSequence
+			});
+		}, proposedCandidateHashes).finally(() => {
 			controller.signal.removeEventListener("abort", abortRequest);
 			activeControllers.delete(controller);
 			activeHandlers.delete(handler);
@@ -1868,7 +1722,7 @@ async function startExternalOptimizerCallback(args) {
 		if (serverResult?.status === "rejected") throw serverResult.reason;
 	}
 }
-async function handleCallback(request, response, signal, args, nextEvaluation) {
+async function handleCallback(request, response, signal, args, nextEvaluation, observe, proposedCandidateHashes) {
 	try {
 		if (request.method !== "POST" || request.url !== "/evaluate") {
 			sendJsonIfOpen(response, 404, { error: "not found" });
@@ -1878,19 +1732,76 @@ async function handleCallback(request, response, signal, args, nextEvaluation) {
 			sendJsonIfOpen(response, 401, { error: "unauthorized" });
 			return;
 		}
-		const body = await readJson(request);
+		let body;
+		try {
+			body = await readJson(request);
+		} catch {
+			observe({
+				kind: "refusal",
+				reason: "invalid-request"
+			});
+			sendJsonIfOpen(response, 400, { error: "request body must be bounded valid JSON" });
+			return;
+		}
 		if (!isRecord(body) || !isExternalTextCandidate(body.candidate) || typeof body.exampleId !== "string") {
+			observe({
+				kind: "refusal",
+				reason: "invalid-request"
+			});
 			sendJsonIfOpen(response, 400, { error: "candidate and exampleId are required strings" });
 			return;
 		}
-		if (nextEvaluation() === void 0) {
+		const candidate = cloneCandidate(body.candidate);
+		const candidateHash = contentHash({
+			kind: "external-text-candidate",
+			candidate
+		});
+		if (!proposedCandidateHashes.has(candidateHash)) {
+			observe({
+				kind: "proposal",
+				candidate,
+				candidateHash
+			});
+			proposedCandidateHashes.add(candidateHash);
+		}
+		const count = nextEvaluation();
+		if (count === void 0) {
+			observe({
+				kind: "refusal",
+				reason: "evaluation-limit",
+				candidate,
+				candidateHash,
+				exampleId: body.exampleId
+			});
 			sendJsonIfOpen(response, 429, { error: "evaluation limit reached" });
 			return;
 		}
-		sendJsonIfOpen(response, 200, await args.evaluate({
-			candidate: body.candidate,
-			exampleId: body.exampleId
-		}, signal));
+		let result;
+		try {
+			result = await args.evaluate({
+				candidate,
+				exampleId: body.exampleId
+			}, signal);
+		} catch {
+			observe({
+				kind: "refusal",
+				reason: "evaluation-failed",
+				candidate,
+				candidateHash,
+				exampleId: body.exampleId
+			});
+			sendJsonIfOpen(response, 500, { error: "evaluation failed" });
+			return;
+		}
+		observe({
+			kind: "evaluation",
+			candidate,
+			candidateHash,
+			exampleId: body.exampleId,
+			evaluationNumber: count,
+			response: structuredClone(result)
+		});
+		sendJsonIfOpen(response, 200, result);
 	} catch {
 		sendJsonIfOpen(response, 500, { error: "evaluation failed" });
 	}
@@ -1930,6 +1841,10 @@ function assertCallbackConfig(args) {
 	if (!Number.isSafeInteger(args.maxEvaluations) || args.maxEvaluations <= 0) throw new Error("external optimizer callback: maxEvaluations must be a positive safe integer");
 	if (args.acceptEvaluation !== void 0 && typeof args.acceptEvaluation !== "function") throw new Error("external optimizer callback: acceptEvaluation must be a function");
 	if (typeof args.evaluate !== "function") throw new Error("external optimizer callback: evaluate must be a function");
+	if (args.observe !== void 0 && typeof args.observe !== "function") throw new Error("external optimizer callback: observe must be a function");
+}
+function cloneCandidate(candidate) {
+	return typeof candidate === "string" ? candidate : { ...candidate };
 }
 //#endregion
 //#region src/campaign/external-optimizer-run-budget.ts
@@ -2069,6 +1984,15 @@ async function runCampaign(opts) {
 	const cells = [];
 	const artifactsByPath = {};
 	const schedule = buildCellSchedule(opts.scenarios, seed, reps);
+	if (resumable) assertScheduleCachesReusable({
+		schedule,
+		runDir: opts.runDir,
+		manifestHash,
+		storage,
+		costLedger,
+		costTags: opts.costTags,
+		rerunInvalidCachedCells: opts.rerunInvalidCachedCells ?? false
+	});
 	const campaignAbort = new AbortController();
 	const onOwnerAbort = () => campaignAbort.abort(opts.signal?.reason);
 	if (opts.signal?.aborted) campaignAbort.abort(opts.signal.reason);
@@ -2153,15 +2077,9 @@ async function runCampaign(opts) {
 }
 async function executeCell(args) {
 	const storage = args.storage;
-	const cellDir = join(args.opts.runDir, args.slot.cellId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+	const cellDir = cellDirectory(args.opts.runDir, args.slot.cellId);
 	storage.ensureDir(cellDir);
-	const stableCostTags = {
-		...args.opts.costTags ?? {},
-		runDir: args.opts.runDir,
-		cellId: args.slot.cellId,
-		scenarioId: args.slot.scenario.id,
-		rep: String(args.slot.rep)
-	};
+	const stableCostTags = stableCostTagsFor(args.opts, args.slot);
 	const costTags = {
 		...stableCostTags,
 		runAttemptId: args.runAttemptId
@@ -2174,24 +2092,27 @@ async function executeCell(args) {
 			cellId: args.slot.cellId,
 			manifestHash: args.manifestHash
 		});
+		if (cached.status === "miss" && cacheIssueRequiresExplicitRerun(cached.reason) && !args.opts.rerunInvalidCachedCells) throw invalidCachedCellsError([{
+			cellId: args.slot.cellId,
+			reason: cached.reason
+		}]);
 		if (cached.status === "hit") {
-			enforceDispatchUsage(cached.cell, args.opts.expectUsage ?? "warn");
-			const cachedHasUsage = cached.cell.costUsd > 0 || cached.cell.tokenUsage.input > 0 || cached.cell.tokenUsage.output > 0;
-			if (cached.cell.costCallIds === void 0) {
-				if (cachedHasUsage || Object.keys(cached.cell.judgeScores).length > 0) throw new CostAccountingIncompleteError(`runCampaign: cached cell '${args.slot.cellId}' does not identify its ledger receipts`);
-			} else if (!Array.isArray(cached.cell.costCallIds) || cached.cell.costCallIds.some((callId) => typeof callId !== "string" || callId.trim().length === 0) || new Set(cached.cell.costCallIds).size !== cached.cell.costCallIds.length) throw new CostAccountingIncompleteError(`runCampaign: cached cell '${args.slot.cellId}' has invalid ledger receipt IDs`);
-			else {
-				const restoredCallIds = new Set(args.costLedger.list({ tags: stableCostTags }).map((receipt) => receipt.callId));
-				const missingCallIds = cached.cell.costCallIds.filter((callId) => !restoredCallIds.has(callId));
-				if (missingCallIds.length > 0) throw new CostAccountingIncompleteError(`runCampaign: cached cell '${args.slot.cellId}' is missing ledger receipt(s): ${missingCallIds.join(", ")}`);
+			const receiptProblem = cachedCellReceiptProblem(cached.cell, args.costLedger, stableCostTags);
+			if (receiptProblem === void 0) {
+				enforceDispatchUsage(cached.cell, args.opts.expectUsage ?? "warn");
+				return {
+					cell: {
+						...cached.cell,
+						cached: true
+					},
+					artifactsByPath: {}
+				};
 			}
-			return {
-				cell: {
-					...cached.cell,
-					cached: true
-				},
-				artifactsByPath: {}
-			};
+			if (!args.opts.rerunInvalidCachedCells) throw invalidCachedCellsError([{
+				cellId: args.slot.cellId,
+				reason: "invalid-cost-receipts",
+				detail: receiptProblem
+			}]);
 		}
 	}
 	const startMs = Date.now();
@@ -2321,7 +2242,9 @@ async function executeCell(args) {
 	const tokenUsage = {
 		input: agentCost.inputTokens,
 		output: agentCost.outputTokens,
-		...agentCost.cachedTokens > 0 ? { cached: agentCost.cachedTokens } : {}
+		...agentCost.reasoningTokens !== void 0 && agentCost.reasoningTokens > 0 ? { reasoning: agentCost.reasoningTokens } : {},
+		...agentCost.cachedTokens > 0 ? { cached: agentCost.cachedTokens } : {},
+		...agentCost.cacheWriteTokens !== void 0 && agentCost.cacheWriteTokens > 0 ? { cacheWrite: agentCost.cacheWriteTokens } : {}
 	};
 	const resolvedModel = agentReceipts.at(-1)?.model;
 	const dispatchResult = {
@@ -2377,7 +2300,7 @@ async function executeCell(args) {
 		artifact: artifact ?? null,
 		judgeScores,
 		costUsd: agentCost.totalCostUsd,
-		costEstimated: agentReceipts.some((receipt) => receipt.actualCostUsd === void 0 && !receipt.costUnknown),
+		costProvenance: agentCost.costProvenance,
 		costCallIds,
 		tokenUsage,
 		...resolvedModel ? { resolvedModel } : {},
@@ -2467,6 +2390,11 @@ function planCampaignRun(opts) {
 	assertCampaignDesign(opts.scenarios, reps);
 	if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) throw new Error("planCampaignRun: runDir is required and must be a non-empty string");
 	opts.runDir = resolveRunDir(opts.runDir, opts.repo);
+	const costLedger = opts.costLedger ?? createRunCostLedger({
+		storage,
+		runDir: opts.runDir,
+		ensureRunDir: false
+	});
 	const manifestHash = computeManifestHash({
 		scenarios: opts.scenarios,
 		judges: opts.judges ?? [],
@@ -2476,7 +2404,7 @@ function planCampaignRun(opts) {
 	});
 	const splitDigest = campaignSplitDigest(opts.scenarios, reps);
 	const cells = buildCellSchedule(opts.scenarios, seed, reps).map((slot) => {
-		const cachePath = join(opts.runDir, slot.cellId.replace(/[^a-zA-Z0-9_-]/g, "_"), "cached-result.json");
+		const cachePath = cellCachePath(opts.runDir, slot.cellId);
 		if (!resumable) return {
 			cellId: slot.cellId,
 			scenarioId: slot.scenario.id,
@@ -2492,31 +2420,48 @@ function planCampaignRun(opts) {
 			cellId: slot.cellId,
 			manifestHash
 		});
-		if (cached.status === "hit") return {
-			cellId: slot.cellId,
-			scenarioId: slot.scenario.id,
-			rep: slot.rep,
-			seed: slot.cellSeed,
-			cachePath,
-			status: "cached"
-		};
+		if (cached.status === "hit") {
+			if (cachedCellReceiptProblem(cached.cell, costLedger, stableCostTagsFor({
+				runDir: opts.runDir,
+				costTags: opts.costTags
+			}, slot)) !== void 0) return {
+				cellId: slot.cellId,
+				scenarioId: slot.scenario.id,
+				rep: slot.rep,
+				seed: slot.cellSeed,
+				cachePath,
+				status: opts.rerunInvalidCachedCells ? "run" : "blocked",
+				reason: "invalid-cost-receipts"
+			};
+			return {
+				cellId: slot.cellId,
+				scenarioId: slot.scenario.id,
+				rep: slot.rep,
+				seed: slot.cellSeed,
+				cachePath,
+				status: "cached"
+			};
+		}
+		const blocked = cacheIssueRequiresExplicitRerun(cached.reason) && !opts.rerunInvalidCachedCells;
 		return {
 			cellId: slot.cellId,
 			scenarioId: slot.scenario.id,
 			rep: slot.rep,
 			seed: slot.cellSeed,
 			cachePath,
-			status: "run",
+			status: blocked ? "blocked" : "run",
 			reason: cached.reason
 		};
 	});
 	const cellsCached = cells.filter((cell) => cell.status === "cached").length;
+	const cellsBlocked = cells.filter((cell) => cell.status === "blocked").length;
 	return {
 		manifestHash,
 		splitDigest,
 		totalCells: cells.length,
 		cellsCached,
-		cellsToRun: cells.length - cellsCached,
+		cellsBlocked,
+		cellsToRun: cells.filter((cell) => cell.status === "run").length,
 		cells
 	};
 }
@@ -2633,6 +2578,59 @@ function buildCellSchedule(scenarios, seed, reps) {
 	}
 	return schedule;
 }
+function cellDirectory(runDir, cellId) {
+	return join(runDir, cellId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+}
+function cellCachePath(runDir, cellId) {
+	return join(cellDirectory(runDir, cellId), "cached-result.json");
+}
+function stableCostTagsFor(opts, slot) {
+	return {
+		...opts.costTags ?? {},
+		runDir: opts.runDir,
+		cellId: slot.cellId,
+		scenarioId: slot.scenario.id,
+		rep: String(slot.rep)
+	};
+}
+function assertScheduleCachesReusable(args) {
+	const blocked = [];
+	for (const slot of args.schedule) {
+		const cached = readCachedCell({
+			storage: args.storage,
+			cachePath: cellCachePath(args.runDir, slot.cellId),
+			cellId: slot.cellId,
+			manifestHash: args.manifestHash
+		});
+		if (cached.status === "hit") {
+			const receiptProblem = cachedCellReceiptProblem(cached.cell, args.costLedger, stableCostTagsFor({
+				runDir: args.runDir,
+				costTags: args.costTags
+			}, slot));
+			if (receiptProblem !== void 0 && !args.rerunInvalidCachedCells) blocked.push({
+				cellId: slot.cellId,
+				reason: "invalid-cost-receipts",
+				detail: receiptProblem
+			});
+		} else if (cacheIssueRequiresExplicitRerun(cached.reason) && !args.rerunInvalidCachedCells) blocked.push({
+			cellId: slot.cellId,
+			reason: cached.reason
+		});
+	}
+	if (blocked.length > 0) throw invalidCachedCellsError(blocked);
+}
+function cachedCellReceiptProblem(cached, costLedger, stableCostTags) {
+	const reportsPaidActivity = cached.costProvenance.kind !== "observed" || cached.costUsd > 0 || cached.tokenUsage.input > 0 || cached.tokenUsage.output > 0;
+	if (cached.costCallIds === void 0) {
+		if (reportsPaidActivity || Object.keys(cached.judgeScores).length > 0) return "does not identify its ledger receipts";
+		return;
+	}
+	if (!Array.isArray(cached.costCallIds) || cached.costCallIds.some((callId) => typeof callId !== "string" || callId.trim().length === 0) || new Set(cached.costCallIds).size !== cached.costCallIds.length) return "has invalid ledger receipt IDs";
+	if (cached.costCallIds.length === 0 && reportsPaidActivity) return "does not identify its ledger receipts";
+	const restoredCallIds = new Set(costLedger.list({ tags: stableCostTags }).map((receipt) => receipt.callId));
+	const missingCallIds = cached.costCallIds.filter((callId) => !restoredCallIds.has(callId));
+	if (missingCallIds.length > 0) return `is missing ledger receipt(s): ${missingCallIds.join(", ")}`;
+}
 function dispatchRefFor(dispatch, override) {
 	const ref = override ?? dispatch?.name ?? "anonymous";
 	if (typeof ref !== "string" || ref.trim().length === 0) throw new Error("runCampaign: dispatchRef must be a non-empty string when provided");
@@ -2642,18 +2640,32 @@ function readCachedCell(args) {
 	const raw = args.storage.read(args.cachePath);
 	if (raw === void 0) return {
 		status: "miss",
-		reason: "missing"
+		reason: args.storage.exists(args.cachePath) ? "corrupt" : "missing"
 	};
+	let parsed;
 	try {
-		const cached = JSON.parse(raw);
-		if (cached.cellId !== args.cellId) return {
-			status: "miss",
-			reason: "cell-mismatch"
-		};
-		if (cached.manifestHash !== args.manifestHash) return {
+		parsed = JSON.parse(raw);
+	} catch {
+		return {
 			status: "miss",
-			reason: "manifest-mismatch"
+			reason: "corrupt"
 		};
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {
+		status: "miss",
+		reason: "corrupt"
+	};
+	const cached = parsed;
+	if (cached.cellId !== args.cellId) return {
+		status: "miss",
+		reason: "cell-mismatch"
+	};
+	if (cached.manifestHash !== args.manifestHash) return {
+		status: "miss",
+		reason: "manifest-mismatch"
+	};
+	try {
+		campaignCellCostProvenance(cached);
 		return {
 			status: "hit",
 			cell: cached
@@ -2661,10 +2673,16 @@ function readCachedCell(args) {
 	} catch {
 		return {
 			status: "miss",
-			reason: "corrupt"
+			reason: cached.costProvenance === void 0 ? "missing-cost-provenance" : "invalid-cost-provenance"
 		};
 	}
 }
+function cacheIssueRequiresExplicitRerun(reason) {
+	return reason === "cell-mismatch" || reason === "missing-cost-provenance" || reason === "invalid-cost-provenance" || reason === "invalid-cost-receipts" || reason === "corrupt";
+}
+function invalidCachedCellsError(cells) {
+	return new CostAccountingIncompleteError(`runCampaign: cached cell(s) require explicit paid re-dispatch: ${cells.map((cell) => `${cell.cellId} (${cell.reason}${cell.detail ? `: ${cell.detail}` : ""})`).join(", ")}; refusing to begin campaign. Inspect planCampaignRun, then set rerunInvalidCachedCells: true to rerun only these cells while retaining valid caches, or resumable: false when a full rerun is intended.`);
+}
 async function captureToStore(args) {
 	await args.store.observe({
 		scenario: args.scenario,
@@ -3389,7 +3407,7 @@ async function compareOptimizationMethods(opts) {
 			throw error;
 		}
 	});
-	assertReportedCostWithinCeiling(combineCosts(optimized.map((result) => ({
+	assertReportedCostWithinCeiling(combineComparisonCosts(optimized.map((result) => ({
 		label: `method '${result.name}'`,
 		cost: result.cost
 	}))).totalCostUsd, opts.costCeiling, "optimization");
@@ -3474,12 +3492,12 @@ async function compareOptimizationMethods(opts) {
 			favored
 		};
 	});
-	const optimizationCost = combineCosts(scores.map((score) => ({
+	const optimizationCost = combineComparisonCosts(scores.map((score) => ({
 		label: `method '${score.name}'`,
 		cost: score.optimizationCost
 	})));
 	const testCost = costFromLedgerSummary(costLedger.summary({ phase: testCostPhase }));
-	const totalCost = combineCosts([{
+	const totalCost = combineComparisonCosts([{
 		label: "optimization",
 		cost: optimizationCost
 	}, {
@@ -3542,6 +3560,7 @@ function assertOptimizationProvenance(methodName, value) {
 	for (const [field, entry] of [["sourceUrl", value.source.sourceUrl], ["revision", value.source.revision]]) if (entry !== void 0 && (typeof entry !== "string" || !entry.trim())) fail(`source.${field}`);
 	if (typeof value.runId !== "string" || !value.runId.trim()) fail("runId");
 	if (value.optimizerModel !== void 0 && (typeof value.optimizerModel !== "string" || !value.optimizerModel.trim() || value.optimizerModel.trim() !== value.optimizerModel)) fail("optimizerModel");
+	if (value.optimizerCallRef !== void 0 && (typeof value.optimizerCallRef !== "string" || !value.optimizerCallRef.trim() || value.optimizerCallRef.trim() !== value.optimizerCallRef)) fail("optimizerCallRef");
 	if (typeof value.resumed !== "boolean") fail("resumed");
 	if (!Number.isSafeInteger(value.evaluationCount) || value.evaluationCount < 0) fail("evaluationCount");
 	if (typeof value.artifactDir !== "string" || !value.artifactDir.trim()) fail("artifactDir");
@@ -3564,6 +3583,24 @@ function assertOptimizationProvenance(methodName, value) {
 		if (value.tokenUsage.reasoningTokens !== void 0 && value.tokenUsage.reasoningTokens > value.tokenUsage.outputTokens) fail("tokenUsage.reasoningTokens");
 		if (value.tokenUsage.totalTokens !== value.tokenUsage.inputTokens + value.tokenUsage.outputTokens) fail("tokenUsage.totalTokens");
 	}
+	if (value.observations !== void 0) {
+		if (value.observations.scope !== "callback-submitted-candidates" || typeof value.observations.path !== "string" || !value.observations.path.trim() || typeof value.observations.sha256 !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value.observations.sha256)) fail("observations");
+		for (const field of [
+			"submittedCandidates",
+			"evaluations",
+			"refusals"
+		]) if (!Number.isSafeInteger(value.observations[field]) || value.observations[field] < 0) fail(`observations.${field}`);
+	}
+	if (value.modelExecutions !== void 0) {
+		if (value.modelExecutions.scope !== "runtime-model-calls" || typeof value.modelExecutions.path !== "string" || !value.modelExecutions.path.trim() || typeof value.modelExecutions.sha256 !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value.modelExecutions.sha256)) fail("modelExecutions");
+		for (const field of [
+			"calls",
+			"succeeded",
+			"failed"
+		]) if (!Number.isSafeInteger(value.modelExecutions[field]) || value.modelExecutions[field] < 0) fail(`modelExecutions.${field}`);
+		if (value.modelExecutions.calls !== value.modelExecutions.succeeded + value.modelExecutions.failed) fail("modelExecutions.calls");
+	}
+	if (value.optimizerModel === void 0 !== (value.optimizerCallRef === void 0) || value.optimizerModel === void 0 !== (value.modelExecutions === void 0)) fail("optimizerModel execution provenance");
 }
 function assertComparisonControls(opts, seed, resamples, confidence) {
 	if (opts.optimizationRunOptions && "costCeiling" in opts.optimizationRunOptions) throw new Error("compareOptimizationMethods: optimizationRunOptions.costCeiling is not supported; costCeiling covers optimization and final scoring");
@@ -3707,6 +3744,7 @@ function callerDispatchRef(opts) {
 function costFromLedgerSummary(summary) {
 	const cost = {
 		totalCostUsd: summary.totalCostUsd,
+		costProvenance: structuredClone(summary.costProvenance),
 		accountingComplete: summary.accountingComplete,
 		incompleteReasons: [...summary.incompleteReasons]
 	};
@@ -3733,19 +3771,37 @@ function optimizationTokenUsageFromSummary(summary, receipts) {
 		calls: summary.totalCalls
 	};
 }
-function combineCosts(entries) {
-	return {
-		totalCostUsd: entries.reduce((total, entry) => total + entry.cost.totalCostUsd, 0),
+/** Combine method costs without turning one unknown bill into a known total. */
+function combineComparisonCosts(entries) {
+	const totalCostUsd = entries.reduce((total, entry) => total + entry.cost.totalCostUsd, 0);
+	const cost = {
+		totalCostUsd,
+		costProvenance: entries.some((entry) => entry.cost.costProvenance.kind === "uncaptured") ? {
+			kind: "uncaptured",
+			usd: null
+		} : entries.every((entry) => entry.cost.costProvenance.kind === "observed") ? {
+			kind: "observed",
+			usd: totalCostUsd
+		} : {
+			kind: "estimated",
+			usd: totalCostUsd
+		},
 		accountingComplete: entries.every((entry) => entry.cost.accountingComplete),
 		incompleteReasons: entries.flatMap((entry) => entry.cost.incompleteReasons.map((reason) => `${entry.label}: ${reason}`))
 	};
+	assertComparisonCost(cost, "combined cost");
+	return cost;
 }
 function assertComparisonCost(cost, label) {
 	if (!cost || typeof cost !== "object") throw new Error(`compareOptimizationMethods: ${label} returned no cost`);
 	if (!Number.isFinite(cost.totalCostUsd) || cost.totalCostUsd < 0) throw new Error(`compareOptimizationMethods: ${label} returned an invalid totalCostUsd`);
+	const provenance = cost.costProvenance;
+	if (!provenance || typeof provenance !== "object" || provenance.kind !== "observed" && provenance.kind !== "estimated" && provenance.kind !== "uncaptured" || (provenance.kind === "uncaptured" ? provenance.usd !== null : !Number.isFinite(provenance.usd) || provenance.usd < 0)) throw new Error(`compareOptimizationMethods: ${label} returned invalid costProvenance`);
+	if (provenance.kind !== "uncaptured" && provenance.usd !== cost.totalCostUsd) throw new Error(`compareOptimizationMethods: ${label} returned costProvenance inconsistent with totalCostUsd`);
 	if (typeof cost.accountingComplete !== "boolean") throw new Error(`compareOptimizationMethods: ${label} returned invalid accountingComplete`);
 	if (!Array.isArray(cost.incompleteReasons) || cost.incompleteReasons.some((reason) => typeof reason !== "string" || reason.trim().length === 0)) throw new Error(`compareOptimizationMethods: ${label} returned invalid incompleteReasons`);
 	if (cost.accountingComplete !== (cost.incompleteReasons.length === 0)) throw new Error(`compareOptimizationMethods: ${label} returned inconsistent cost completeness and reasons`);
+	if (cost.accountingComplete && provenance.kind === "uncaptured") throw new Error(`compareOptimizationMethods: ${label} cannot mark uncaptured cost as complete`);
 }
 //#endregion
 //#region src/campaign/external-text-optimization.ts
@@ -3994,16 +4050,23 @@ function externalTextOptimizationMethod(config) {
 						status: "completed"
 					}
 				});
+				const measuredCost = combineComparisonCosts([{
+					label: "evaluation",
+					cost: evaluationCost
+				}, {
+					label: "optimizer",
+					cost: optimizerCost
+				}]);
 				return {
 					winnerSurface: decodeExternalTextCandidate(result.bestCandidate),
 					cost: {
-						totalCostUsd: evaluationCost.totalCostUsd + optimizerCost.totalCostUsd,
-						accountingComplete: evaluationCost.accountingComplete && optimizerCost.accountingComplete && externalCostReason === void 0,
-						incompleteReasons: [
-							...evaluationCost.incompleteReasons.map((reason) => `evaluation: ${reason}`),
-							...optimizerCost.incompleteReasons.map((reason) => `optimizer: ${reason}`),
-							...externalCostReason ? [`optimizer: external spend is not observed: ${externalCostReason}`] : []
-						]
+						...measuredCost,
+						...externalCostReason ? { costProvenance: {
+							kind: "uncaptured",
+							usd: null
+						} } : {},
+						accountingComplete: measuredCost.accountingComplete && externalCostReason === void 0,
+						incompleteReasons: [...measuredCost.incompleteReasons, ...externalCostReason ? [`optimizer: external spend is not observed: ${externalCostReason}`] : []]
 					},
 					durationMs: Date.now() - started,
 					provenance: {
@@ -5236,8 +5299,8 @@ const TOKEN_USAGE_FIELDS = [
 	"calls"
 ];
 function assertPriorExternalOptimizerUsage(summary, budget, name) {
-	if (!summary.accountingComplete || !summary.usageComplete) throw new Error(`${name}: cannot resume optimizer-model work with incomplete prior cost or usage`);
-	if (summary.totalCalls > budget.maxRequests || summary.totalCostUsd > budget.maxCostUsd + Number.EPSILON) throw new Error(`${name}: prior optimizer-model usage exceeds the configured budget`);
+	if (!summary.usageComplete || budget.maxCostUsd !== void 0 && !summary.accountingComplete) throw new Error(`${name}: cannot resume optimizer-model work with incomplete bounded usage`);
+	if (summary.totalCalls > budget.maxRequests || budget.maxCostUsd !== void 0 && summary.totalCostUsd > budget.maxCostUsd + Number.EPSILON) throw new Error(`${name}: prior optimizer-model usage exceeds the configured budget`);
 }
 function assertExternalOptimizerTokenUsage(usage, name, optimizer) {
 	if (usage === void 0) return;
@@ -5252,6 +5315,78 @@ function assertExternalOptimizerCompletionCount(upstream, requestAttempts, succe
 	if (upstream.requestAttempts !== void 0 && upstream.requestAttempts !== requestAttempts) throw new Error(`${name}: ${optimizer} reported ${upstream.requestAttempts} model attempts but the proxy received ${requestAttempts}`);
 }
 //#endregion
+//#region src/campaign/external-optimizer-observations.ts
+/** Append-only observation log for one external-optimizer attempt. */
+function openExternalOptimizerObservationLog(input) {
+	if (input.storage.read(input.path) !== void 0 || input.storage.exists(input.path)) throw new Error(`external optimizer observation log already exists at '${input.path}'`);
+	input.storage.write(input.path, "");
+	let revision = 0;
+	const counts = {
+		submittedCandidates: 0,
+		evaluations: 0,
+		refusals: 0
+	};
+	return {
+		observe(observation) {
+			const expectedSequence = counts.submittedCandidates + counts.evaluations + counts.refusals + 1;
+			if (observation.sequence !== expectedSequence) throw new Error(`external optimizer observation log expected sequence ${expectedSequence}, got ${observation.sequence}`);
+			const line = `${canonicalJson(observation)}\n`;
+			const next = input.storage.append(input.path, line, revision);
+			if (next === void 0) throw new Error(`external optimizer observation log changed concurrently at '${input.path}'`);
+			revision = next;
+			if (observation.kind === "proposal") counts.submittedCandidates += 1;
+			else if (observation.kind === "evaluation") counts.evaluations += 1;
+			else counts.refusals += 1;
+		},
+		summary() {
+			const contents = input.storage.read(input.path) ?? "";
+			const bytes = new TextEncoder().encode(contents);
+			if (bytes.byteLength !== revision) throw new Error(`external optimizer observation log revision changed at '${input.path}'`);
+			return {
+				scope: "callback-submitted-candidates",
+				path: input.path,
+				sha256: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
+				...counts
+			};
+		}
+	};
+}
+/** Append-only opaque Runtime execution records for one optimizer attempt. */
+function openExternalOptimizerExecutionLog(input) {
+	if (input.storage.read(input.path) !== void 0 || input.storage.exists(input.path)) throw new Error(`external optimizer execution log already exists at '${input.path}'`);
+	input.storage.write(input.path, "");
+	let revision = 0;
+	const counts = {
+		calls: 0,
+		succeeded: 0,
+		failed: 0
+	};
+	return {
+		observe(observation) {
+			if (observation.sequence !== counts.calls + 1) throw new Error(`external optimizer execution log expected sequence ${counts.calls + 1}, got ${observation.sequence}`);
+			const line = `${canonicalJson(observation)}\n`;
+			const next = input.storage.append(input.path, line, revision);
+			if (next === void 0) throw new Error(`external optimizer execution log changed concurrently at '${input.path}'`);
+			revision = next;
+			counts.calls += 1;
+			if (observation.succeeded) counts.succeeded += 1;
+			else counts.failed += 1;
+		},
+		summary() {
+			const contents = input.storage.read(input.path) ?? "";
+			const bytes = new TextEncoder().encode(contents);
+			if (bytes.byteLength !== revision) throw new Error(`external optimizer execution log revision changed at '${input.path}'`);
+			if (counts.calls !== counts.succeeded + counts.failed) throw new Error(`external optimizer execution log counts disagree at '${input.path}'`);
+			return {
+				scope: "runtime-model-calls",
+				path: input.path,
+				sha256: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
+				...counts
+			};
+		}
+	};
+}
+//#endregion
 //#region src/campaign/external-optimizer-run-config.ts
 function externalOptimizerRunnerIdentity(runner, module) {
 	return {
@@ -5343,27 +5478,16 @@ function assertExternalOptimizerRuntimeIdentity(value, expectedPackage, label) {
 //#region src/campaign/optimizer-model.ts
 function assertOptimizerModel(value, label) {
 	if (!value || typeof value !== "object") throw new Error(`${label} is required`);
-	for (const field of [
-		"model",
-		"baseUrl",
-		"apiKey"
-	]) {
-		const item = value[field];
-		if (typeof item !== "string" || !item.trim() || item.trim() !== item) throw new Error(`${label}.${field} must be trimmed and non-empty`);
-	}
-	let url;
-	try {
-		url = new URL(value.baseUrl);
-	} catch {
-		throw new Error(`${label}.baseUrl must be an absolute HTTP URL`);
-	}
-	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error(`${label}.baseUrl must use HTTP or HTTPS without credentials, query, or fragment`);
+	for (const [field, item] of [["model", value.model], ["callRef", value.callRef]]) if (typeof item !== "string" || !item.trim() || item.trim() !== item) throw new Error(`${label}.${field} must be trimmed and non-empty`);
+	if (typeof value.call !== "function") throw new Error(`${label}.call must be a function`);
 	assertExternalOptimizerModelBudget(value.budget, `${label}.budget`);
 }
 function snapshotOptimizerModel(value) {
 	return {
-		...value,
-		budget: structuredClone(value.budget)
+		model: value.model,
+		budget: structuredClone(value.budget),
+		call: value.call,
+		callRef: value.callRef
 	};
 }
 const MAX_TIMER_DELAY_MS$1 = 2147483647;
@@ -5478,7 +5602,7 @@ function assertEngineRun(run, label) {
 function assertEngineOptions(run, label) {
 	if (!run || typeof run !== "object") throw new Error(`gepaOptimizationMethod: ${label} is required`);
 	if (typeof run.engine !== "string" || !run.engine.trim() || run.engine.trim() !== run.engine) throw new Error(`gepaOptimizationMethod: ${label}.engine must be a trimmed non-empty string`);
-	if (!Number.isFinite(run.maxProposerCostUsd) || run.maxProposerCostUsd <= 0) throw new Error(`gepaOptimizationMethod: ${label}.maxProposerCostUsd must be a positive finite number`);
+	if (run.maxProposerCostUsd !== void 0 && (!Number.isFinite(run.maxProposerCostUsd) || run.maxProposerCostUsd <= 0)) throw new Error(`gepaOptimizationMethod: ${label}.maxProposerCostUsd must be a positive finite number when supplied`);
 	if (run.maxConcurrency !== void 0) assertPositiveSafeInteger$1(run.maxConcurrency, `${label}.maxConcurrency`);
 	if (run.stopAtScore !== void 0 && !Number.isFinite(run.stopAtScore)) throw new Error(`gepaOptimizationMethod: ${label}.stopAtScore must be a finite number`);
 	if (run.sandbox !== void 0 && typeof run.sandbox !== "boolean") throw new Error(`gepaOptimizationMethod: ${label}.sandbox must be a boolean`);
@@ -5605,7 +5729,7 @@ function gepaOptimizationMethod(config) {
 				maxEvidenceChars,
 				optimizerModel: config.optimizer ? {
 					model: config.optimizer.model,
-					baseUrl: config.optimizer.baseUrl,
+					callRef: config.optimizer.callRef,
 					budget: config.optimizer.budget
 				} : null,
 				runner: externalOptimizerRunnerIdentity(bridgeRunner, "agent_eval_rpc.gepa_bridge"),
@@ -5624,6 +5748,14 @@ function gepaOptimizationMethod(config) {
 				attemptId,
 				maxEvaluations: evaluationLimit
 			});
+			const observationLog = openExternalOptimizerObservationLog({
+				storage,
+				path: `${runDir}/observations-${attemptId}.jsonl`
+			});
+			const executionLog = config.optimizer ? openExternalOptimizerExecutionLog({
+				storage,
+				path: `${runDir}/model-executions-${attemptId}.jsonl`
+			}) : void 0;
 			const scenarioById = mapExternalScenarios(input.trainScenarios, input.selectionScenarios, "GEPA bridge");
 			const evaluate = createExternalTextEvaluator({
 				input,
@@ -5643,6 +5775,7 @@ function gepaOptimizationMethod(config) {
 				maxEvaluations: evaluationLimit,
 				acceptEvaluation: () => runBudget.acceptEvaluation(),
 				evaluate,
+				observe: observationLog.observe,
 				...signal ? { signal } : {}
 			});
 			const runnerEnv = bridgeRunner?.env ?? {};
@@ -5662,8 +5795,9 @@ function gepaOptimizationMethod(config) {
 						});
 						assertPriorExternalOptimizerUsage(priorOptimizerUsage, config.optimizer.budget, name);
 						modelProxy = await startExternalOptimizerModelProxy({
-							upstreamBaseUrl: config.optimizer.baseUrl,
-							upstreamApiKey: config.optimizer.apiKey,
+							call: config.optimizer.call,
+							callRef: config.optimizer.callRef,
+							recordExecution: executionLog.observe,
 							model: config.optimizer.model,
 							budget: config.optimizer.budget,
 							costLedger,
@@ -5672,7 +5806,7 @@ function gepaOptimizationMethod(config) {
 							tags: { ...runBudget.attemptTags },
 							initialUsage: {
 								requests: priorOptimizerUsage.totalCalls,
-								costUsd: priorOptimizerUsage.totalCostUsd
+								...priorOptimizerUsage.costProvenance.kind === "uncaptured" ? {} : { costUsd: priorOptimizerUsage.totalCostUsd }
 							},
 							...signal ? { signal } : {}
 						});
@@ -5751,17 +5885,31 @@ function gepaOptimizationMethod(config) {
 			});
 			const optimizerCost = costFromLedgerSummary(optimizerSummary);
 			const reportedProposerCost = result.proposerCostUsd ?? 0;
-			if (modelProxy) assertExternalOptimizerCompletionCount(result.tokenUsage, modelProxy.requestAttempts(), modelProxy.successfulCompletions(), name, "GEPA");
+			if (modelProxy) {
+				modelProxy.assertExecutionComplete();
+				assertExternalOptimizerCompletionCount(result.tokenUsage, modelProxy.requestAttempts(), modelProxy.successfulCompletions(), name, "GEPA");
+			}
 			const tokenUsage = modelProxy ? optimizationTokenUsageFromSummary(optimizerSummary, optimizerReceipts) : void 0;
 			const runtime = observedExternalOptimizerRuntime(runtimeIdentity);
+			const meteredCost = modelProxy ? combineComparisonCosts([{
+				label: "evaluation",
+				cost: evaluationCost
+			}, {
+				label: "optimizer model",
+				cost: optimizerCost
+			}]) : void 0;
+			const externalTotalCostUsd = evaluationCost.totalCostUsd + reportedProposerCost;
 			return {
 				winnerSurface: decodeExternalTextCandidate(result.bestCandidate),
-				cost: modelProxy ? {
-					totalCostUsd: evaluationCost.totalCostUsd + optimizerCost.totalCostUsd,
-					accountingComplete: evaluationCost.accountingComplete && optimizerCost.accountingComplete,
-					incompleteReasons: [...evaluationCost.incompleteReasons.map((reason) => `evaluation: ${reason}`), ...optimizerCost.incompleteReasons.map((reason) => `optimizer model: ${reason}`)]
-				} : {
-					totalCostUsd: evaluationCost.totalCostUsd + reportedProposerCost,
+				cost: modelProxy ? meteredCost : {
+					totalCostUsd: externalTotalCostUsd,
+					costProvenance: result.proposerCostAccounting === "reported" && evaluationCost.costProvenance.kind !== "uncaptured" ? {
+						kind: "estimated",
+						usd: externalTotalCostUsd
+					} : {
+						kind: "uncaptured",
+						usd: null
+					},
 					accountingComplete: false,
 					incompleteReasons: [
 						...evaluationCost.incompleteReasons,
@@ -5772,13 +5920,18 @@ function gepaOptimizationMethod(config) {
 				durationMs: Date.now() - started,
 				provenance: {
 					...runtime,
-					...config.optimizer ? { optimizerModel: config.optimizer.model } : {},
+					...config.optimizer ? {
+						optimizerModel: config.optimizer.model,
+						optimizerCallRef: config.optimizer.callRef
+					} : {},
 					compatibleRunId,
 					runId,
 					resumed: result.resumed,
 					evaluationCount: runBudget.acceptedEvaluations(),
 					artifactDir: outputDir,
-					...tokenUsage ? { tokenUsage } : {}
+					...tokenUsage ? { tokenUsage } : {},
+					observations: observationLog.summary(),
+					...executionLog ? { modelExecutions: executionLog.summary() } : {}
 				}
 			};
 		}
@@ -6524,7 +6677,7 @@ function campaignMeasurementDigest(campaign) {
 			generation: cell.generation ?? null,
 			judgeScores: cell.judgeScores,
 			costUsd: cell.costUsd,
-			costEstimated: cell.costEstimated ?? null,
+			costProvenance: cell.costProvenance,
 			costCallIds: [...cell.costCallIds ?? []].sort(),
 			tokenUsage: cell.tokenUsage,
 			resolvedModel: cell.resolvedModel ?? null,
@@ -6973,7 +7126,7 @@ function skillOptOptimizationMethod(config) {
 				background: config.background ?? "",
 				optimizerModel: {
 					model: config.optimizer.model,
-					baseUrl: config.optimizer.baseUrl,
+					callRef: config.optimizer.callRef,
 					budget: config.optimizer.budget
 				},
 				seedCandidate: input.baselineSurface,
@@ -6998,6 +7151,14 @@ function skillOptOptimizationMethod(config) {
 				attemptId,
 				maxEvaluations: config.maxEvaluations
 			});
+			const observationLog = openExternalOptimizerObservationLog({
+				storage,
+				path: `${runDir}/observations-${attemptId}.jsonl`
+			});
+			const executionLog = openExternalOptimizerExecutionLog({
+				storage,
+				path: `${runDir}/model-executions-${attemptId}.jsonl`
+			});
 			const scenarioById = mapExternalScenarios(input.trainScenarios, input.selectionScenarios, "SkillOpt bridge");
 			const evaluate = createExternalTextEvaluator({
 				input,
@@ -7017,6 +7178,7 @@ function skillOptOptimizationMethod(config) {
 				maxEvaluations: config.maxEvaluations,
 				acceptEvaluation: () => runBudget.acceptEvaluation(),
 				evaluate,
+				observe: observationLog.observe,
 				...signal ? { signal } : {}
 			});
 			const runnerEnv = bridgeRunner?.env ?? {};
@@ -7035,8 +7197,9 @@ function skillOptOptimizationMethod(config) {
 					});
 					assertPriorExternalOptimizerUsage(priorOptimizerUsage, config.optimizer.budget, name);
 					const modelProxy = await startExternalOptimizerModelProxy({
-						upstreamBaseUrl: config.optimizer.baseUrl,
-						upstreamApiKey: config.optimizer.apiKey,
+						call: config.optimizer.call,
+						callRef: config.optimizer.callRef,
+						recordExecution: executionLog.observe,
 						model: config.optimizer.model,
 						budget: config.optimizer.budget,
 						costLedger,
@@ -7045,7 +7208,7 @@ function skillOptOptimizationMethod(config) {
 						tags: { ...runBudget.attemptTags },
 						initialUsage: {
 							requests: priorOptimizerUsage.totalCalls,
-							costUsd: priorOptimizerUsage.totalCostUsd
+							...priorOptimizerUsage.costProvenance.kind === "uncaptured" ? {} : { costUsd: priorOptimizerUsage.totalCostUsd }
 						},
 						...signal ? { signal } : {}
 					});
@@ -7134,32 +7297,39 @@ function skillOptOptimizationMethod(config) {
 				tags: runBudget.runTags
 			});
 			const optimizerCost = costFromLedgerSummary(optimizerUsage);
+			modelProxy.assertExecutionComplete();
 			assertExternalOptimizerCompletionCount(result.tokenUsage, modelProxy.requestAttempts(), modelProxy.successfulCompletions(), name, "SkillOpt");
 			const tokenUsage = optimizationTokenUsageFromSummary(optimizerUsage, optimizerReceipts);
 			const runtime = observedExternalOptimizerRuntime(runtimeIdentity);
+			const combinedCost = combineComparisonCosts([{
+				label: "evaluation",
+				cost: evaluationCost
+			}, {
+				label: "optimizer model",
+				cost: optimizerCost
+			}]);
 			return {
 				winnerSurface: result.bestCandidate,
-				cost: {
-					totalCostUsd: evaluationCost.totalCostUsd + optimizerCost.totalCostUsd,
-					accountingComplete: evaluationCost.accountingComplete && optimizerCost.accountingComplete,
-					incompleteReasons: [...evaluationCost.incompleteReasons.map((reason) => `evaluation: ${reason}`), ...optimizerCost.incompleteReasons.map((reason) => `optimizer model: ${reason}`)]
-				},
+				cost: combinedCost,
 				durationMs: Date.now() - started,
 				provenance: {
 					...runtime,
 					optimizerModel: config.optimizer.model,
+					optimizerCallRef: config.optimizer.callRef,
 					compatibleRunId,
 					runId,
 					resumed: result.resumed,
 					evaluationCount: runBudget.acceptedEvaluations(),
 					artifactDir: outputDir,
-					...tokenUsage ? { tokenUsage } : {}
+					...tokenUsage ? { tokenUsage } : {},
+					observations: observationLog.summary(),
+					modelExecutions: executionLog.summary()
 				}
 			};
 		}
 	};
 }
 //#endregion
-export { campaignScenarioIdentity as $, assertOptimizationResult as A, pairedDeltaTest as At, surfaceHash as B, detectScale as C, paretoFrontier as Ct, runCanaries as D, decidePairedPromotion as Dt, pairHoldout as E, recoverTruncatedJson as Et, assertComponentSurface as F, summarizeBackendIntegrity as Ft, buildReflectionPrompt as G, campaignMeanComposite as H, codeSurfaceIdentityMaterial as I, JudgeParseError as It, runCampaign as J, parseReflectionResponse as K, componentSurfaceIdentityMaterial as L, costFromLedgerSummary as M, assertRealAgentReceipts as Mt, optimizationTokenUsageFromSummary as N, assertRealBackend as Nt, composeGate as O, pairedDecisionShape as Ot, assertCodeSurfaceIdentity as P, summarizeAgentReceiptIntegrity as Pt, assertCampaignSplitIdentity as Q, renderSurfaceDiff as R, defaultProductionGate as S, dominates as St, heldoutSignificance as T, scalarScore as Tt, compareRankKeys as U, campaignBreakdown as V, DEFAULT_MUTATION_PRIMITIVES as W, tangleTracesRoot as X, resolveRunDir as Y, assertCampaignDesign as Z, buildEvidenceVector as _, canonicalJson as _t, emitLoopProvenance as a, createReferenceEquivalenceJudge as at, powerPreflight as b, inMemoryVerdictCache as bt, provenanceRecordPath as c, redTeamDataset as ct, runImprovementLoop as d, toolNamesForRun as dt, campaignSplitDigest as et, runOptimization as f, Dataset as ft, gepaOptimizationMethod as g, cachedJudge as gt, labelTrustRank as h, llmJudge as ht, canonicalDigest as i, REFERENCE_EQUIVALENCE_JUDGE_VERSION as it, compareOptimizationMethods as j, BackendIntegrityError as jt, externalTextOptimizationMethod as k, minimumPairsForPairedDeltaTest as kt, provenanceSpansPath as l, redTeamReport as lt, isProposedCandidate as m, hashScenarios as mt, buildLoopProvenanceRecord as n, openAutoPr as nt, loopProvenanceArgsFromResult as o, runReferenceEquivalenceJudge as ot, runEval as p, HoldoutLockedError as pt, planCampaignRun as q, campaignMeasurementDigest as r, REFERENCE_EQUIVALENCE_INPUT_LIMITS as rt, loopProvenanceSpans as s, DEFAULT_RED_TEAM_CORPUS as st, skillOptOptimizationMethod as t, campaignSplitDigestFromIdentities as tt, verifyLoopProvenanceRecord as u, scoreRedTeamOutput as ut, paretoPolicy as v, contentHash as vt, dimensionRegressions as w, paretoFrontierWithCrowding as wt, heldOutGate as x, crowdingDistance as xt, paretoSignificanceGate as y, fileVerdictCache as yt, surfaceContentHash as z };
+export { assertCampaignSplitIdentity as $, assertOptimizationResult as A, summarizeAgentReceiptIntegrity as At, surfaceContentHash as B, detectScale as C, decidePairedPromotion as Ct, runCanaries as D, BackendIntegrityError as Dt, pairHoldout as E, pairedDeltaTest as Et, assertCodeSurfaceIdentity as F, DEFAULT_MUTATION_PRIMITIVES as G, campaignBreakdown as H, assertComponentSurface as I, planCampaignRun as J, buildReflectionPrompt as K, codeSurfaceIdentityMaterial as L, compareOptimizationMethods as M, JudgeParseError as Mt, costFromLedgerSummary as N, composeGate as O, assertRealAgentReceipts as Ot, optimizationTokenUsageFromSummary as P, assertCampaignDesign as Q, componentSurfaceIdentityMaterial as R, defaultProductionGate as S, recoverTruncatedJson as St, heldoutSignificance as T, minimumPairsForPairedDeltaTest as Tt, campaignMeanComposite as U, surfaceHash as V, compareRankKeys as W, resolveRunDir as X, runCampaign as Y, tangleTracesRoot as Z, buildEvidenceVector as _, crowdingDistance as _t, emitLoopProvenance as a, REFERENCE_EQUIVALENCE_JUDGE_VERSION as at, powerPreflight as b, paretoFrontierWithCrowding as bt, provenanceRecordPath as c, DEFAULT_RED_TEAM_CORPUS as ct, runImprovementLoop as d, scoreRedTeamOutput as dt, campaignScenarioIdentity as et, runOptimization as f, toolNamesForRun as ft, gepaOptimizationMethod as g, llmJudge as gt, labelTrustRank as h, hashScenarios as ht, canonicalDigest as i, REFERENCE_EQUIVALENCE_INPUT_LIMITS as it, combineComparisonCosts as j, summarizeBackendIntegrity as jt, externalTextOptimizationMethod as k, assertRealBackend as kt, provenanceSpansPath as l, redTeamDataset as lt, isProposedCandidate as m, HoldoutLockedError as mt, buildLoopProvenanceRecord as n, campaignSplitDigestFromIdentities as nt, loopProvenanceArgsFromResult as o, createReferenceEquivalenceJudge as ot, runEval as p, Dataset as pt, parseReflectionResponse as q, campaignMeasurementDigest as r, openAutoPr as rt, loopProvenanceSpans as s, runReferenceEquivalenceJudge as st, skillOptOptimizationMethod as t, campaignSplitDigest as tt, verifyLoopProvenanceRecord as u, redTeamReport as ut, paretoPolicy as v, dominates as vt, dimensionRegressions as w, pairedDecisionShape as wt, heldOutGate as x, scalarScore as xt, paretoSignificanceGate as y, paretoFrontier as yt, renderSurfaceDiff as z };
 
-//# sourceMappingURL=skillopt-optimization-method-DV6c4ooy.js.map
+//# sourceMappingURL=skillopt-optimization-method-Ds8J1_K8.js.map