@tangle-network/agent-eval 0.144.9 → 0.144.10

package/dist/{skillopt-optimization-method-D8wysvU1.d.ts → skillopt-optimization-method-9J8dJbrM.d.ts}

@@ -3,7 +3,7 @@ import { a as RunRecord } from "./run-record-CF4Dwpxr.js";
 import { A as ChatClient, U as LlmCallMetadata } from "./types-D216SgwM.js";
 import { s as TraceStore } from "./store-CT9YIIve.js";
 import { _ as ProposalFinding } from "./types-BvDKaULh.js";
-import { _ as ExternalTextEvaluationRequest, c as ExternalOptimizerModelBudget, g as ExternalTextCandidate, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall, m as ExternalOptimizerResumeMode, r as ExternalOptimizerCallbackLimits } from "./external-optimizer-contracts-CZuJNcT5.js";
+import { _ as ExternalTextEvaluationRequest, c as ExternalOptimizerModelBudget, g as ExternalTextCandidate, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall, m as ExternalOptimizerResumeMode, o as ExternalOptimizerEvaluationObservation, r as ExternalOptimizerCallbackLimits } from "./external-optimizer-contracts-CZuJNcT5.js";
 import { C as JudgeDimension, H as SurfaceProposer, N as ParetoParent, R as Scenario, S as JudgeConfig, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, o as CampaignScenarioIdentity, p as Gate, r as CampaignCellResult, v as GateResult, y as GenerationCandidate } from "./types-BnjdJ70P.js";
 import { a as DatasetScenario, t as Dataset } from "./dataset-C8xaLXdY.js";
 import { t as DetectRewardHackingInput } from "./reward-hacking-BI0OMAlo.js";
@@ -216,6 +216,37 @@ interface ExternalOptimizerExecutionSummary {
   succeeded: number;
   failed: number;
 }
+interface ExternalOptimizerSubmittedCandidate {
+  /** Exact text or named-component surface submitted to the evaluation callback. */
+  readonly candidate: ExternalTextCandidate;
+  /** Eval's canonical content identity for `candidate`. */
+  readonly candidateHash: string;
+  readonly candidateDigest: `sha256:${string}`;
+  readonly proposalSequence: number;
+  /** Exact observation artifact that proves this candidate was submitted. */
+  readonly provenance: {
+    readonly path: string;
+    readonly sha256: `sha256:${string}`;
+  };
+}
+interface ExternalOptimizerObservationArtifact {
+  readonly summary: ExternalOptimizerObservationSummary;
+  readonly observations: readonly ExternalOptimizerEvaluationObservation[];
+  /** Every distinct callback-submitted candidate in proposal order. */
+  readonly candidates: readonly ExternalOptimizerSubmittedCandidate[];
+}
+/**
+ * Read and verify the exact callback observation artifact addressed by method provenance.
+ *
+ * The reader checks the raw SHA-256, canonical JSONL bytes, sequence, candidate
+ * identities, and summary counts before it returns any candidate.
+ * This proves that the bytes match the supplied summary. The caller remains
+ * responsible for obtaining that summary from trusted provenance.
+ */
+declare function readExternalOptimizerObservationArtifact(input: {
+  summary: ExternalOptimizerObservationSummary;
+  storage?: CampaignStorage;
+}): ExternalOptimizerObservationArtifact;
 //#endregion
 //#region src/campaign/run-campaign.d.ts
 interface RunCampaignOptions<TScenario extends Scenario, TArtifact> {
@@ -627,6 +658,7 @@ interface ExternalTextEvaluationResponse {
     artifact?: unknown;
   };
 }
+declare function decodeExternalTextCandidate(candidate: ExternalTextCandidate): MutableSurface;
 //#endregion
 //#region src/campaign/external-text-optimization-contract.d.ts
 interface ExternalTextOptimizerContext {
@@ -1507,5 +1539,5 @@ interface SkillOptOptimizationMethodConfig<TScenario extends Scenario, TArtifact
 /** Run Microsoft's SkillOpt trainer as a complete optimization method. */
 declare function skillOptOptimizationMethod<TScenario extends Scenario, TArtifact>(config: SkillOptOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
 //#endregion
-export { redTeamDataset as $, openAutoPr as $t, RunEvalOptions as A, compareOptimizationMethods as At, OptimizerModelBudget as B, ExternalOptimizerExecutionSummary as Bt, RunImprovementLoopOptions as C, OptimizationMethodProvenance as Ct, RunOptimizationOptions as D, OptimizationPackageSource as Dt, PremeasuredOptimizationBaseline as E, OptimizationMethodScore as Et, GepaOptimizationMethodConfig as F, CampaignRunPlanCell as Ft, DefaultProductionRewardHackingOptions as G, inMemoryCampaignStorage as Gt, heldOutGate as H, CampaignStorage as Ht, GepaOptimizationRecipe as I, PlanCampaignRunOptions as It, RedTeamCase as J, campaignScenarioIdentity as Jt, defaultProductionGate as K, assertCampaignDesign as Kt, GepaRunnerCommand as L, RunCampaignOptions as Lt, GepaAdaptiveEngineRun as M, optimizationTokenUsageFromSummary as Mt, GepaEngineOptions as N, CampaignCellFailureReceipt as Nt, RunOptimizationResult as O, OptimizationTokenUsage as Ot, GepaEngineRun as P, CampaignRunPlan as Pt, RedTeamReport as Q, OpenAutoPrResult as Qt, gepaOptimizationMethod as R, planCampaignRun as Rt, verifyLoopProvenanceRecord as S, OptimizationMethodPairwise as St, runImprovementLoop as T, OptimizationMethodRunOptions as Tt, DefaultProductionGateCheck as U, createRunCostLedger as Ut, HeldOutGateOptions as V, ExternalOptimizerObservationSummary as Vt, DefaultProductionGateOptions as W, fsCampaignStorage as Wt, RedTeamFinding as X, campaignSplitDigestFromIdentities as Xt, RedTeamCategory as Y, campaignSplitDigest as Yt, RedTeamPayload as Z, OpenAutoPrOptions as Zt, emitLoopProvenance as _, CompareOptimizationMethodsOptions as _t, BuildLoopProvenanceArgs as a, ReferenceEquivalenceScenario as an, CanaryKind as at, provenanceRecordPath as b, OptimizationMethodComparison as bt, LoopProvenanceArgsFromResult as c, LlmJudgeDimension as cn, CanarySeverity as ct, LoopProvenanceEvidence as d, externalTextOptimizationMethod as dt, REFERENCE_EQUIVALENCE_INPUT_LIMITS as en, redTeamReport as et, LoopProvenanceOptimizationMethod as f, ExternalTextOptimizationMethodConfig as ft, canonicalDigest as g, ExternalTextEvaluationResponse as gt, campaignMeasurementDigest as h, ExternalOptimizationExample as ht, skillOptOptimizationMethod as i, ReferenceEquivalenceJudgeResult as in, CanaryEvaluation as it, runEval as j, costFromLedgerSummary as jt, runOptimization as k, combineComparisonCosts as kt, LoopProvenanceBackend as l, LlmJudgeOptions as ln, runCanaries as lt, buildLoopProvenanceRecord as m, ExternalTextOptimizerResult as mt, SkillOptRunnerCommand as n, ReferenceEquivalenceJudgeInput as nn, toolNamesForRun as nt, EmitLoopProvenanceArgs as o, createReferenceEquivalenceJudge as on, CanaryOptions as ot, LoopProvenanceRecord as p, ExternalTextOptimizerContext as pt, DEFAULT_RED_TEAM_CORPUS as q, assertCampaignSplitIdentity as qt, SkillOptTrainerConfig as r, ReferenceEquivalenceJudgeOptions as rn, CanaryAlert as rt, EmitLoopProvenanceResult as s, runReferenceEquivalenceJudge as sn, CanaryReport as st, SkillOptOptimizationMethodConfig as t, REFERENCE_EQUIVALENCE_JUDGE_VERSION as tn, scoreRedTeamOutput as tt, LoopProvenanceCandidate as u, llmJudge as un, composeGate as ut, loopProvenanceArgsFromResult as v, ComparisonCost as vt, RunImprovementLoopResult as w, OptimizationMethodResult as wt, provenanceSpansPath as x, OptimizationMethodInput as xt, loopProvenanceSpans as y, OptimizationMethod as yt, OpenAICompatibleOptimizerModel as z, runCampaign as zt };
-//# sourceMappingURL=skillopt-optimization-method-D8wysvU1.d.ts.map
+export { redTeamDataset as $, campaignSplitDigest as $t, RunEvalOptions as A, combineComparisonCosts as At, OptimizerModelBudget as B, runCampaign as Bt, RunImprovementLoopOptions as C, OptimizationMethodPairwise as Ct, RunOptimizationOptions as D, OptimizationMethodScore as Dt, PremeasuredOptimizationBaseline as E, OptimizationMethodRunOptions as Et, GepaOptimizationMethodConfig as F, CampaignRunPlan as Ft, DefaultProductionRewardHackingOptions as G, readExternalOptimizerObservationArtifact as Gt, heldOutGate as H, ExternalOptimizerObservationArtifact as Ht, GepaOptimizationRecipe as I, CampaignRunPlanCell as It, RedTeamCase as J, fsCampaignStorage as Jt, defaultProductionGate as K, CampaignStorage as Kt, GepaRunnerCommand as L, PlanCampaignRunOptions as Lt, GepaAdaptiveEngineRun as M, costFromLedgerSummary as Mt, GepaEngineOptions as N, optimizationTokenUsageFromSummary as Nt, RunOptimizationResult as O, OptimizationPackageSource as Ot, GepaEngineRun as P, CampaignCellFailureReceipt as Pt, RedTeamReport as Q, campaignScenarioIdentity as Qt, gepaOptimizationMethod as R, RunCampaignOptions as Rt, verifyLoopProvenanceRecord as S, OptimizationMethodInput as St, runImprovementLoop as T, OptimizationMethodResult as Tt, DefaultProductionGateCheck as U, ExternalOptimizerObservationSummary as Ut, HeldOutGateOptions as V, ExternalOptimizerExecutionSummary as Vt, DefaultProductionGateOptions as W, ExternalOptimizerSubmittedCandidate as Wt, RedTeamFinding as X, assertCampaignDesign as Xt, RedTeamCategory as Y, inMemoryCampaignStorage as Yt, RedTeamPayload as Z, assertCampaignSplitIdentity as Zt, emitLoopProvenance as _, decodeExternalTextCandidate as _t, BuildLoopProvenanceArgs as a, REFERENCE_EQUIVALENCE_JUDGE_VERSION as an, CanaryKind as at, provenanceRecordPath as b, OptimizationMethod as bt, LoopProvenanceArgsFromResult as c, ReferenceEquivalenceJudgeResult as cn, CanarySeverity as ct, LoopProvenanceEvidence as d, runReferenceEquivalenceJudge as dn, externalTextOptimizationMethod as dt, campaignSplitDigestFromIdentities as en, redTeamReport as et, LoopProvenanceOptimizationMethod as f, LlmJudgeDimension as fn, ExternalTextOptimizationMethodConfig as ft, canonicalDigest as g, ExternalTextEvaluationResponse as gt, campaignMeasurementDigest as h, ExternalOptimizationExample as ht, skillOptOptimizationMethod as i, REFERENCE_EQUIVALENCE_INPUT_LIMITS as in, CanaryEvaluation as it, runEval as j, compareOptimizationMethods as jt, runOptimization as k, OptimizationTokenUsage as kt, LoopProvenanceBackend as l, ReferenceEquivalenceScenario as ln, runCanaries as lt, buildLoopProvenanceRecord as m, llmJudge as mn, ExternalTextOptimizerResult as mt, SkillOptRunnerCommand as n, OpenAutoPrResult as nn, toolNamesForRun as nt, EmitLoopProvenanceArgs as o, ReferenceEquivalenceJudgeInput as on, CanaryOptions as ot, LoopProvenanceRecord as p, LlmJudgeOptions as pn, ExternalTextOptimizerContext as pt, DEFAULT_RED_TEAM_CORPUS as q, createRunCostLedger as qt, SkillOptTrainerConfig as r, openAutoPr as rn, CanaryAlert as rt, EmitLoopProvenanceResult as s, ReferenceEquivalenceJudgeOptions as sn, CanaryReport as st, SkillOptOptimizationMethodConfig as t, OpenAutoPrOptions as tn, scoreRedTeamOutput as tt, LoopProvenanceCandidate as u, createReferenceEquivalenceJudge as un, composeGate as ut, loopProvenanceArgsFromResult as v, CompareOptimizationMethodsOptions as vt, RunImprovementLoopResult as w, OptimizationMethodProvenance as wt, provenanceSpansPath as x, OptimizationMethodComparison as xt, loopProvenanceSpans as y, ComparisonCost as yt, OpenAICompatibleOptimizerModel as z, planCampaignRun as zt };
+//# sourceMappingURL=skillopt-optimization-method-9J8dJbrM.d.ts.map

package/dist/skillopt-optimization-method-9J8dJbrM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillopt-optimization-method-9J8dJbrM.d.ts","names":[],"sources":["../src/llm-judge.ts","../src/reference-equivalence-judge.ts","../src/campaign/auto-pr.ts","../src/campaign/coverage.ts","../src/campaign/storage.ts","../src/campaign/external-optimizer-observations.ts","../src/campaign/run-campaign.ts","../src/campaign/presets/compare-optimization-methods.ts","../src/campaign/external-text-evaluation.ts","../src/campaign/external-text-optimization-contract.ts","../src/campaign/external-text-optimization.ts","../src/campaign/gates/compose.ts","../src/canary.ts","../src/red-team.ts","../src/campaign/gates/default-production-gate.ts","../src/campaign/gates/heldout-gate.ts","../src/campaign/optimizer-model.ts","../src/campaign/gepa-optimization-method.ts","../src/campaign/presets/run-eval.ts","../src/campaign/presets/run-optimization.ts","../src/campaign/presets/run-improvement-loop.ts","../src/campaign/provenance.ts","../src/campaign/skillopt-optimization-method.ts"],"mappings":"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"}

package/dist/{skillopt-optimization-method-Dtzp7QpP.js → skillopt-optimization-method-D6Q4dLbh.js}

@@ -1,8 +1,9 @@
 import { c as ValidationError, i as JudgeError, t as AgentEvalError } from "./errors-D-LKuDhb.js";
 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-DzvMUsS_.js";
+import { a as deepFreezeCanonicalJson } from "./usage-receipt-t7vAzCRQ.js";
 import { a as clamp01, o as combineAbortSignals, t as assertProposalFindings } from "./proposal-findings-2GIUo1et.js";
-import { C as isExternalTextCandidate, D as resolveExternalOptimizerProcessLimits, E as resolveExternalOptimizerCallbackLimits, O as safePathComponent, S as isCandidateText, T as removeCredentialEnvironment, b as assertJsonValue, d as closeExternalOptimizerResources, f as runWithCleanup, l as startExternalOptimizerCallback, n as createRunCostLedger, p as startExternalOptimizerModelProxy, r as fsCampaignStorage, t as acquireSingleRunLock, u as runExternalOptimizerProcess, w as isRecord, x as assertNoCredentialValues, y as assertExternalOptimizerModelBudget } from "./single-run-lock-BMQEv1wG.js";
+import { C as isExternalTextCandidate, D as resolveExternalOptimizerProcessLimits, E as resolveExternalOptimizerCallbackLimits, O as safePathComponent, S as isCandidateText, T as removeCredentialEnvironment, b as assertJsonValue, d as closeExternalOptimizerResources, f as runWithCleanup, i as fsCampaignStorage, n as startExternalOptimizerCallback, p as startExternalOptimizerModelProxy, r as createRunCostLedger, t as acquireSingleRunLock, u as runExternalOptimizerProcess, w as isRecord, x as assertNoCredentialValues, y as assertExternalOptimizerModelBudget } from "./single-run-lock-DFWHEB09.js";
 import { n as canonicalJson, r as contentHash } from "./verdict-cache-BCcOh0kF.js";
 import { p as mapConcurrent } from "./ledger-core-DXZIqu17.js";
 import { E as pairedBootstrap, H as weightedComposite, d as confidenceInterval } from "./statistics-ByxzSiOM.js";
@@ -1413,73 +1414,241 @@ function designedCellIds(scenarios, reps) {
 	return ids;
 }
 //#endregion
-//#region src/campaign/external-optimizer-run-budget.ts
-function externalOptimizerRunKey(input) {
-	if (!input.attemptId.trim() || input.attemptId.trim() !== input.attemptId) throw new Error("external optimizer attemptId must be trimmed and non-empty");
-	if (typeof input.resumeEnabled !== "boolean") throw new Error("external optimizer resumeEnabled must be a boolean");
-	const compatible = externalOptimizerCompatibleRunKey(input.material);
-	return input.resumeEnabled ? compatible : `${compatible}-${input.attemptId}`;
-}
-function externalOptimizerCompatibleRunKey(material) {
-	return contentHash(material);
-}
-function openExternalOptimizerRunBudget(input) {
-	if (!input.runKey.trim() || input.runKey.trim() !== input.runKey) throw new Error("external optimizer runKey must be trimmed and non-empty");
-	if (!input.attemptId.trim() || input.attemptId.trim() !== input.attemptId) throw new Error("external optimizer attemptId must be trimmed and non-empty");
-	if (!Number.isSafeInteger(input.maxEvaluations) || input.maxEvaluations <= 0) throw new Error("external optimizer maxEvaluations must be a positive safe integer");
-	const budgetDir = `${input.runDir}/budgets`;
-	const statePath = `${budgetDir}/${input.runKey}.jsonl`;
-	input.storage.ensureDir(budgetDir);
-	const runTags = Object.freeze({ optimizerRun: input.runKey });
-	const attemptTags = Object.freeze({
-		optimizerRun: input.runKey,
-		optimizerAttempt: input.attemptId
+//#region src/campaign/external-optimizer-observations.ts
+/**
+* Read and verify the exact callback observation artifact addressed by method provenance.
+*
+* The reader checks the raw SHA-256, canonical JSONL bytes, sequence, candidate
+* identities, and summary counts before it returns any candidate.
+* This proves that the bytes match the supplied summary. The caller remains
+* responsible for obtaining that summary from trusted provenance.
+*/
+function readExternalOptimizerObservationArtifact(input) {
+	const { summary } = input;
+	assertObservationSummary(summary);
+	const storage = input.storage ?? fsCampaignStorage();
+	const contents = storage.read(summary.path);
+	if (contents === void 0) {
+		const state = storage.exists(summary.path) ? "unreadable" : "missing";
+		throw new Error(`external optimizer observation artifact is ${state} at '${summary.path}'`);
+	}
+	const sha256 = `sha256:${createHash("sha256").update(contents).digest("hex")}`;
+	if (sha256 !== summary.sha256) throw new Error(`external optimizer observation artifact digest mismatch at '${summary.path}': expected ${summary.sha256}, got ${sha256}`);
+	if (contents.length > 0 && !contents.endsWith("\n")) throw new Error(`external optimizer observation artifact must end with a newline at '${summary.path}'`);
+	const observations = contents.length === 0 ? [] : parseObservationLines(contents, summary.path);
+	const candidates = [];
+	const proposed = /* @__PURE__ */ new Map();
+	const evaluationNumbers = /* @__PURE__ */ new Set();
+	let evaluations = 0;
+	let failedEvaluations = 0;
+	let refusals = 0;
+	for (const [index, observation] of observations.entries()) {
+		if (observation.sequence !== index + 1) throw new Error(`external optimizer observation artifact expected sequence ${index + 1}, got ${observation.sequence}`);
+		if (observation.kind === "proposal") {
+			assertCandidateIdentity(observation.candidate, observation.candidateHash, observation.sequence);
+			if (proposed.has(observation.candidateHash)) throw new Error(`external optimizer observation artifact repeats candidate ${observation.candidateHash}`);
+			const candidate = {
+				candidate: structuredClone(observation.candidate),
+				candidateHash: observation.candidateHash,
+				candidateDigest: `sha256:${observation.candidateHash}`,
+				proposalSequence: observation.sequence,
+				provenance: {
+					path: summary.path,
+					sha256: summary.sha256
+				}
+			};
+			proposed.set(observation.candidateHash, candidate);
+			candidates.push(candidate);
+			continue;
+		}
+		if (observation.kind === "evaluation") {
+			evaluations += 1;
+			if (evaluationNumbers.has(observation.evaluationNumber)) throw new Error(`external optimizer observation artifact repeats evaluation number ${observation.evaluationNumber}`);
+			evaluationNumbers.add(observation.evaluationNumber);
+			assertObservedCandidate(observation, proposed);
+			assertJsonValue(observation.response, "external optimizer evaluation response");
+			continue;
+		}
+		refusals += 1;
+		if (observation.reason !== "invalid-request" && observation.reason !== "evaluation-limit" && observation.reason !== "evaluation-failed") throw new Error(`external optimizer observation artifact has invalid refusal reason at sequence ${observation.sequence}`);
+		if (observation.reason === "evaluation-failed") failedEvaluations += 1;
+		const candidateFields = [observation.candidate, observation.candidateHash];
+		if (observation.reason !== "invalid-request" && candidateFields.some((value) => value === void 0)) throw new Error(`external optimizer observation artifact omits a refused candidate at sequence ${observation.sequence}`);
+		if (candidateFields.some((value) => value !== void 0)) {
+			if (candidateFields.some((value) => value === void 0)) throw new Error(`external optimizer observation artifact has incomplete candidate identity at sequence ${observation.sequence}`);
+			assertObservedCandidate(observation, proposed);
+		}
+	}
+	const acceptedEvaluations = evaluations + failedEvaluations;
+	for (const evaluationNumber of evaluationNumbers) if (evaluationNumber > acceptedEvaluations) throw new Error(`external optimizer observation artifact has out-of-range evaluation number ${evaluationNumber}`);
+	if (candidates.length !== summary.submittedCandidates || evaluations !== summary.evaluations || refusals !== summary.refusals) throw new Error(`external optimizer observation artifact counts disagree at '${summary.path}': expected ${summary.submittedCandidates}/${summary.evaluations}/${summary.refusals}, got ${candidates.length}/${evaluations}/${refusals}`);
+	return deepFreezeCanonicalJson({
+		summary: structuredClone(summary),
+		observations,
+		candidates
 	});
+}
+/** 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 {
-		runKey: input.runKey,
-		attemptId: input.attemptId,
-		runTags,
-		attemptTags,
-		acceptedEvaluations: () => readState(input.storage.read(statePath), input.maxEvaluations, statePath).accepted,
-		acceptEvaluation() {
-			for (let attempt = 0; attempt < 16; attempt += 1) {
-				const current = input.storage.read(statePath) ?? "";
-				const state = readState(current, input.maxEvaluations, statePath);
-				if (state.accepted >= input.maxEvaluations) return void 0;
-				if (!input.storage.append) throw new Error("external optimizer evaluation budgets require appendable storage");
-				const next = state.accepted + 1;
-				const event = `${JSON.stringify({
-					maxEvaluations: input.maxEvaluations,
-					accepted: next
-				})}\n`;
-				const expectedBytes = new TextEncoder().encode(current).byteLength;
-				if (input.storage.append(statePath, event, expectedBytes) !== void 0) return next;
-			}
-			throw new Error(`external optimizer evaluation counter for '${input.runKey}' was updated concurrently`);
+		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
+			};
 		}
 	};
 }
-function readState(text, maxEvaluations, statePath) {
-	if (text === void 0 || text === "") return {
-		maxEvaluations,
-		accepted: 0
-	};
-	let accepted = 0;
-	for (const line of text.split("\n")) {
-		if (!line) continue;
-		let value;
+function assertObservationSummary(summary) {
+	if (summary.scope !== "callback-submitted-candidates") throw new Error("external optimizer observation summary has an invalid scope");
+	if (typeof summary.path !== "string" || summary.path.trim().length === 0) throw new Error("external optimizer observation summary has an invalid path");
+	if (!/^sha256:[a-f0-9]{64}$/u.test(summary.sha256)) throw new Error("external optimizer observation summary has an invalid SHA-256");
+	for (const [field, value] of [
+		["submittedCandidates", summary.submittedCandidates],
+		["evaluations", summary.evaluations],
+		["refusals", summary.refusals]
+	]) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`external optimizer observation summary ${field} must be a non-negative integer`);
+}
+function parseObservationLines(contents, path) {
+	return contents.slice(0, -1).split("\n").map((line, index) => {
+		let observation;
 		try {
-			value = JSON.parse(line);
+			observation = JSON.parse(line);
 		} catch (cause) {
-			throw new Error(`external optimizer evaluation state is invalid at '${statePath}'`, { cause });
+			throw new Error(`external optimizer observation artifact has invalid JSON at '${path}' line ${index + 1}`, { cause });
 		}
-		if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "accepted,maxEvaluations" || value.maxEvaluations !== maxEvaluations || value.accepted !== accepted + 1) throw new Error(`external optimizer evaluation state does not match at '${statePath}'`);
-		accepted += 1;
+		assertObservationShape(observation, index + 1);
+		if (canonicalJson(observation) !== line) throw new Error(`external optimizer observation artifact is not canonical at '${path}' line ${index + 1}`);
+		return observation;
+	});
+}
+function assertObservationShape(value, line) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`external optimizer observation artifact line ${line} must be an object`);
+	const observation = value;
+	if (!Number.isSafeInteger(observation.sequence) || Number(observation.sequence) <= 0) throw new Error(`external optimizer observation artifact line ${line} has an invalid sequence`);
+	if (observation.kind === "proposal") {
+		assertExactKeys(observation, [
+			"candidate",
+			"candidateHash",
+			"kind",
+			"sequence"
+		], line);
+		assertCandidateFields(observation, line);
+		return;
 	}
-	if (accepted > maxEvaluations) throw new Error(`external optimizer evaluation state exceeds its limit at '${statePath}'`);
+	if (observation.kind === "evaluation") {
+		assertExactKeys(observation, [
+			"candidate",
+			"candidateHash",
+			"evaluationNumber",
+			"exampleId",
+			"kind",
+			"response",
+			"sequence"
+		], line);
+		assertCandidateFields(observation, line);
+		if (typeof observation.exampleId !== "string") throw new Error(`external optimizer observation artifact line ${line} has an invalid exampleId`);
+		if (!Number.isSafeInteger(observation.evaluationNumber) || Number(observation.evaluationNumber) <= 0) throw new Error(`external optimizer observation artifact line ${line} has an invalid evaluationNumber`);
+		assertJsonValue(observation.response, `external optimizer observation artifact line ${line}`);
+		return;
+	}
+	if (observation.kind === "refusal") {
+		assertAllowedKeys(observation, [
+			"candidate",
+			"candidateHash",
+			"exampleId",
+			"kind",
+			"reason",
+			"sequence"
+		], line);
+		if (typeof observation.reason !== "string") throw new Error(`external optimizer observation artifact line ${line} has an invalid reason`);
+		if (observation.candidate !== void 0 || observation.candidateHash !== void 0) assertCandidateFields(observation, line);
+		if (observation.exampleId !== void 0 && typeof observation.exampleId !== "string") throw new Error(`external optimizer observation artifact line ${line} has an invalid exampleId`);
+		return;
+	}
+	throw new Error(`external optimizer observation artifact line ${line} has an invalid kind`);
+}
+function assertCandidateFields(observation, line) {
+	if (!isExternalTextCandidate(observation.candidate)) throw new Error(`external optimizer observation artifact line ${line} has an invalid candidate`);
+	if (typeof observation.candidateHash !== "string" || !/^[a-f0-9]{64}$/u.test(observation.candidateHash)) throw new Error(`external optimizer observation artifact line ${line} has an invalid candidateHash`);
+}
+function assertExactKeys(value, expected, line) {
+	assertAllowedKeys(value, expected, line);
+	for (const key of expected) if (!(key in value)) throw new Error(`external optimizer observation artifact line ${line} is missing ${key}`);
+}
+function assertAllowedKeys(value, allowed, line) {
+	const extras = Object.keys(value).filter((key) => !allowed.includes(key));
+	if (extras.length > 0) throw new Error(`external optimizer observation artifact line ${line} has unexpected field ${extras[0]}`);
+}
+function assertCandidateIdentity(candidate, candidateHash, sequence) {
+	if (candidateHash !== contentHash({
+		kind: "external-text-candidate",
+		candidate
+	})) throw new Error(`external optimizer observation artifact candidate hash mismatch at sequence ${sequence}`);
+}
+function assertObservedCandidate(observation, proposed) {
+	assertCandidateIdentity(observation.candidate, observation.candidateHash, observation.sequence);
+	const candidate = proposed.get(observation.candidateHash);
+	if (!candidate) throw new Error(`external optimizer observation artifact references an unproposed candidate at sequence ${observation.sequence}`);
+	if (!isDeepStrictEqual(observation.candidate, candidate.candidate)) throw new Error(`external optimizer observation artifact changes candidate bytes at sequence ${observation.sequence}`);
+}
+/** 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 {
-		maxEvaluations,
-		accepted
+		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
@@ -2830,6 +2999,76 @@ function deepFreeze$1(value) {
 	return value;
 }
 //#endregion
+//#region src/campaign/external-optimizer-run-budget.ts
+function externalOptimizerRunKey(input) {
+	if (!input.attemptId.trim() || input.attemptId.trim() !== input.attemptId) throw new Error("external optimizer attemptId must be trimmed and non-empty");
+	if (typeof input.resumeEnabled !== "boolean") throw new Error("external optimizer resumeEnabled must be a boolean");
+	const compatible = externalOptimizerCompatibleRunKey(input.material);
+	return input.resumeEnabled ? compatible : `${compatible}-${input.attemptId}`;
+}
+function externalOptimizerCompatibleRunKey(material) {
+	return contentHash(material);
+}
+function openExternalOptimizerRunBudget(input) {
+	if (!input.runKey.trim() || input.runKey.trim() !== input.runKey) throw new Error("external optimizer runKey must be trimmed and non-empty");
+	if (!input.attemptId.trim() || input.attemptId.trim() !== input.attemptId) throw new Error("external optimizer attemptId must be trimmed and non-empty");
+	if (!Number.isSafeInteger(input.maxEvaluations) || input.maxEvaluations <= 0) throw new Error("external optimizer maxEvaluations must be a positive safe integer");
+	const budgetDir = `${input.runDir}/budgets`;
+	const statePath = `${budgetDir}/${input.runKey}.jsonl`;
+	input.storage.ensureDir(budgetDir);
+	const runTags = Object.freeze({ optimizerRun: input.runKey });
+	const attemptTags = Object.freeze({
+		optimizerRun: input.runKey,
+		optimizerAttempt: input.attemptId
+	});
+	return {
+		runKey: input.runKey,
+		attemptId: input.attemptId,
+		runTags,
+		attemptTags,
+		acceptedEvaluations: () => readState(input.storage.read(statePath), input.maxEvaluations, statePath).accepted,
+		acceptEvaluation() {
+			for (let attempt = 0; attempt < 16; attempt += 1) {
+				const current = input.storage.read(statePath) ?? "";
+				const state = readState(current, input.maxEvaluations, statePath);
+				if (state.accepted >= input.maxEvaluations) return void 0;
+				if (!input.storage.append) throw new Error("external optimizer evaluation budgets require appendable storage");
+				const next = state.accepted + 1;
+				const event = `${JSON.stringify({
+					maxEvaluations: input.maxEvaluations,
+					accepted: next
+				})}\n`;
+				const expectedBytes = new TextEncoder().encode(current).byteLength;
+				if (input.storage.append(statePath, event, expectedBytes) !== void 0) return next;
+			}
+			throw new Error(`external optimizer evaluation counter for '${input.runKey}' was updated concurrently`);
+		}
+	};
+}
+function readState(text, maxEvaluations, statePath) {
+	if (text === void 0 || text === "") return {
+		maxEvaluations,
+		accepted: 0
+	};
+	let accepted = 0;
+	for (const line of text.split("\n")) {
+		if (!line) continue;
+		let value;
+		try {
+			value = JSON.parse(line);
+		} catch (cause) {
+			throw new Error(`external optimizer evaluation state is invalid at '${statePath}'`, { cause });
+		}
+		if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "accepted,maxEvaluations" || value.maxEvaluations !== maxEvaluations || value.accepted !== accepted + 1) throw new Error(`external optimizer evaluation state does not match at '${statePath}'`);
+		accepted += 1;
+	}
+	if (accepted > maxEvaluations) throw new Error(`external optimizer evaluation state exceeds its limit at '${statePath}'`);
+	return {
+		maxEvaluations,
+		accepted
+	};
+}
+//#endregion
 //#region src/campaign/external-text-optimization-contract.ts
 const MAX_TIMER_DELAY_MS$3 = 2147483647;
 function assertExternalTextOptimizationConfig(config) {
@@ -4493,78 +4732,6 @@ 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 {
@@ -6528,6 +6695,6 @@ function skillOptOptimizationMethod(config) {
 	};
 }
 //#endregion
-export { runReferenceEquivalenceJudge as $, componentSurfaceIdentityMaterial as A, planCampaignRun as B, combineComparisonCosts as C, assertCodeSurfaceIdentity as D, optimizationTokenUsageFromSummary as E, campaignMeanComposite as F, assertCampaignSplitIdentity as G, resolveRunDir as H, compareRankKeys as I, campaignSplitDigestFromIdentities as J, campaignScenarioIdentity as K, DEFAULT_MUTATION_PRIMITIVES as L, surfaceContentHash as M, surfaceHash as N, assertComponentSurface as O, campaignBreakdown as P, createReferenceEquivalenceJudge as Q, buildReflectionPrompt as R, assertOptimizationResult as S, costFromLedgerSummary as T, tangleTracesRoot as U, runCampaign as V, assertCampaignDesign as W, REFERENCE_EQUIVALENCE_INPUT_LIMITS as X, openAutoPr as Y, REFERENCE_EQUIVALENCE_JUDGE_VERSION as Z, heldOutGate as _, assertRealBackend as _t, emitLoopProvenance as a, Dataset as at, composeGate as b, JudgeParseError as bt, provenanceRecordPath as c, llmJudge as ct, runImprovementLoop as d, paretoFrontier as dt, DEFAULT_RED_TEAM_CORPUS as et, runOptimization as f, paretoFrontierWithCrowding as ft, gepaOptimizationMethod as g, assertRealAgentReceipts as gt, labelTrustRank as h, BackendIntegrityError as ht, canonicalDigest as i, toolNamesForRun as it, renderSurfaceDiff as j, codeSurfaceIdentityMaterial as k, provenanceSpansPath as l, crowdingDistance as lt, isProposedCandidate as m, recoverTruncatedJson as mt, buildLoopProvenanceRecord as n, redTeamReport as nt, loopProvenanceArgsFromResult as o, HoldoutLockedError as ot, runEval as p, scalarScore as pt, campaignSplitDigest as q, campaignMeasurementDigest as r, scoreRedTeamOutput as rt, loopProvenanceSpans as s, hashScenarios as st, skillOptOptimizationMethod as t, redTeamDataset as tt, verifyLoopProvenanceRecord as u, dominates as ut, defaultProductionGate as v, summarizeAgentReceiptIntegrity as vt, compareOptimizationMethods as w, externalTextOptimizationMethod as x, runCanaries as y, summarizeBackendIntegrity as yt, parseReflectionResponse as z };
+export { REFERENCE_EQUIVALENCE_JUDGE_VERSION as $, codeSurfaceIdentityMaterial as A, parseReflectionResponse as B, combineComparisonCosts as C, decodeExternalTextCandidate as D, optimizationTokenUsageFromSummary as E, campaignBreakdown as F, readExternalOptimizerObservationArtifact as G, runCampaign as H, campaignMeanComposite as I, campaignScenarioIdentity as J, assertCampaignDesign as K, compareRankKeys as L, renderSurfaceDiff as M, surfaceContentHash as N, assertCodeSurfaceIdentity as O, surfaceHash as P, REFERENCE_EQUIVALENCE_INPUT_LIMITS as Q, DEFAULT_MUTATION_PRIMITIVES as R, assertOptimizationResult as S, JudgeParseError as St, costFromLedgerSummary as T, resolveRunDir as U, planCampaignRun as V, tangleTracesRoot as W, campaignSplitDigestFromIdentities as X, campaignSplitDigest as Y, openAutoPr as Z, heldOutGate as _, BackendIntegrityError as _t, emitLoopProvenance as a, scoreRedTeamOutput as at, composeGate as b, summarizeAgentReceiptIntegrity as bt, provenanceRecordPath as c, HoldoutLockedError as ct, runImprovementLoop as d, crowdingDistance as dt, createReferenceEquivalenceJudge as et, runOptimization as f, dominates as ft, gepaOptimizationMethod as g, recoverTruncatedJson as gt, labelTrustRank as h, scalarScore as ht, canonicalDigest as i, redTeamReport as it, componentSurfaceIdentityMaterial as j, assertComponentSurface as k, provenanceSpansPath as l, hashScenarios as lt, isProposedCandidate as m, paretoFrontierWithCrowding as mt, buildLoopProvenanceRecord as n, DEFAULT_RED_TEAM_CORPUS as nt, loopProvenanceArgsFromResult as o, toolNamesForRun as ot, runEval as p, paretoFrontier as pt, assertCampaignSplitIdentity as q, campaignMeasurementDigest as r, redTeamDataset as rt, loopProvenanceSpans as s, Dataset as st, skillOptOptimizationMethod as t, runReferenceEquivalenceJudge as tt, verifyLoopProvenanceRecord as u, llmJudge as ut, defaultProductionGate as v, assertRealAgentReceipts as vt, compareOptimizationMethods as w, externalTextOptimizationMethod as x, summarizeBackendIntegrity as xt, runCanaries as y, assertRealBackend as yt, buildReflectionPrompt as z };
 
-//# sourceMappingURL=skillopt-optimization-method-Dtzp7QpP.js.map
+//# sourceMappingURL=skillopt-optimization-method-D6Q4dLbh.js.map