@tangle-network/agent-runtime 0.105.0 → 0.106.1

package/dist/improvement-cycle-C095kS_g.js

@@ -0,0 +1,2624 @@
+import { i as ConfigError } from "./errors-DEAvWQPy.js";
+import { $ as parseExactAgentProfile, G as agentCandidateProfileAsAgentProfile, J as candidateMaterializerHarness, Q as parseAgentCandidateProfileActivation, Y as createAgentCandidateProfileActivation, Z as omitUndefinedObjectFields, ct as omitTopLevelDigest, d as verifiedResourceTextByDigest, f as verifyAgentCandidateBundle, it as canonicalCandidateDocument, n as executePreparedAgentCandidate, nt as canonicalCandidateBytes, q as assertCandidateProfileBinding, rt as canonicalCandidateDigest$1, st as immutableCandidateValue, t as prepareAgentCandidateExecution, ut as verifyCanonicalCandidateDocument } from "./prepare-B53sPV7M.js";
+import { N as runLocalHarness, T as runSettledCommand, j as harnessInvocation } from "./supervisor-DTKhF-RV.js";
+import { E as optimizerMethod, a as defaultStructuralRolloutPolicy } from "./structural-rollout-IXUEplky.js";
+import { t as runAnalystLoop } from "./analyst-loop-DGdtVENg.js";
+import { canonicalJson, makeFinding } from "@tangle-network/agent-eval";
+import { campaignSplitDigest, compareOptimizationMethods, gitWorktreeAdapter, verifyCodeSurface } from "@tangle-network/agent-eval/campaign";
+import { agentCandidateMaterializationReceiptSchema, agentCandidateRunReceiptSchema, agentImprovementActivationSchema, agentImprovementProposalSchema, agentImprovementReviewSchema, agentProfileDiffSchema, agentProfileImprovementMeasuredComparisonSchema, agentProfileModelHintsSchema, agentProfileSchema, candidateExecutionEvidenceSchema, changedProfileImprovementSurfaces, defineAgentProfileDiff, sha256DigestSchema } from "@tangle-network/agent-interface";
+import { createHash, randomUUID } from "node:crypto";
+import { applyWorkspacePlan, materializeCandidateProfile, materializeProfile } from "@tangle-network/agent-profile-materialize";
+import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { basename, join, resolve, sep } from "node:path";
+import { spawnSync } from "node:child_process";
+import { measuredComparisonFromCandidateExperiment, runCandidateExperiment, sealCandidateExperiment, selfImprove, verifyCandidateExperiment, verifyCandidateExperimentComparison } from "@tangle-network/agent-eval/contract";
+import { assertNoJudgeVerdict } from "@tangle-network/agent-eval/analyst";
+//#region src/improvement/agentic-generator.ts
+/**
+*
+* `agenticGenerator` — the full-agentic `CandidateGenerator`. It runs a real
+* coding harness (claude / codex / opencode) inside the candidate worktree the
+* driver already created, letting the agent read the codebase + the research
+* report and make the change in place. The driver then commits the worktree
+* into a `CodeSurface`.
+*
+* Mechanism: identical to the proven Phase-2.8 in-process executor — spawn the
+* harness as a subprocess with `cwd` = the worktree, on the same filesystem,
+* so edits land in place (no sandbox-mount round-trip). `runLocalHarness` is
+* the verified primitive. The OUTER sandbox is the improvement loop's own
+* execution context; the generator does not nest a second sandbox per
+* candidate (which would reintroduce a host↔sandbox worktree-transport
+* problem that does not need solving here).
+*
+* `maxShots` is the DEPTH dial — a multi-shot verify-in-session loop, NOT the
+* kernel `runAgentRounds`. Each shot runs one full harness session in the (persistent)
+* worktree; between shots the loop refines based on what the last shot produced:
+*   - empty tree   → "you changed nothing, make the edits" → retry
+*   - dirty + `verify` fails → feed the verifier's failure into the next shot
+*       (the worktree persists, so the harness RESUMES atop its own failing
+*       edits with the error in hand — no `--resume` session plumbing needed,
+*       and harness-agnostic across claude/codex/opencode)
+*   - dirty + `verify` ok (or no verifier configured) → return the candidate
+* A candidate that never verifies within `maxShots` is discarded (`applied:
+* false`), never shipped — if you configured a verifier, a non-passing tree is
+* not a candidate. With no verifier the legacy behavior holds: first dirty shot
+* is the candidate.
+*
+* @experimental
+*/
+const RAW_TRACE_ANALYST_ID = "raw-trace-distiller";
+const RAW_TRACE_AREA = "raw-trace-context";
+const RAW_TRACE_DIAGNOSIS_PATH = ".improve/raw-trace-diagnosis.md";
+/** Dedicated ephemeral root for generic author-profile files. Every declared
+* file must live below this root so cleanup cannot alter candidate-owned files. */
+const AGENTIC_PROFILE_RESOURCE_ROOT = ".agent-runtime-profile-resources";
+/** Full-agentic `CandidateGenerator` (the `shots=N, sandbox=on` setting): run a real coding harness inside the candidate worktree so the agent makes the change in place. */
+function agenticGenerator(opts = {}) {
+	const harness = opts.harness ?? "claude";
+	if (opts.codexReproducible && harness !== "codex") throw new Error("agenticGenerator: codexReproducible requires harness 'codex'");
+	if (opts.codexReproducible && !opts.profile) throw new Error("agenticGenerator: codexReproducible requires an explicit author profile");
+	if (opts.codexReadDeniedPaths && !opts.codexReproducible) throw new Error("agenticGenerator: codexReadDeniedPaths requires codexReproducible");
+	if (opts.maximumCharge && !opts.codexReproducible) throw new Error("agenticGenerator: maximumCharge requires codexReproducible");
+	const profileResourcePlan = opts.codexReproducible ? authorProfileResourcePlan(opts.profile) : null;
+	const buildPrompt = opts.buildPrompt ?? defaultBuildPrompt;
+	const run = opts.runHarness ?? runLocalHarness;
+	const dirty = opts.isDirty ?? worktreeDirty;
+	const verify = opts.verify;
+	return {
+		kind: `agentic:${harness}`,
+		proposesWithoutFindings: true,
+		async generate({ worktreePath, report, findings, maxShots, signal, generation, candidateIndex, costLedger, costPhase }) {
+			signal.throwIfAborted();
+			let reproducibleCostLedger;
+			if (opts.codexReproducible) {
+				if (!costLedger) throw new Error("agenticGenerator: reproducible Codex requires the run-wide CostLedger supplied by agent-eval");
+				reproducibleCostLedger = costLedger;
+			}
+			const basePrompt = appendProfileResourcePaths(buildPrompt({
+				report,
+				findings
+			}), profileResourcePlan);
+			const needsRawTraceEvidence = requiresRawTraceEvidence(findings);
+			const shots = Math.max(1, maxShots);
+			let attemptNote = "";
+			for (let shot = 0; shot < shots; shot++) {
+				signal.throwIfAborted();
+				const taskPrompt = attemptNote ? `${basePrompt}\n\n${attemptNote}` : basePrompt;
+				const invocation = opts.profile ? harnessInvocation(harness, opts.profile, taskPrompt, {
+					dangerouslySkipPermissions: harness === "claude",
+					...opts.codexReproducible ? { codexReproducible: true } : {}
+				}) : void 0;
+				const exactPrompt = invocation?.prompt ?? taskPrompt;
+				const readDeniedPaths = typeof opts.codexReadDeniedPaths === "function" ? opts.codexReadDeniedPaths(worktreePath) : opts.codexReadDeniedPaths;
+				const startedAt = /* @__PURE__ */ new Date();
+				let harnessResult = null;
+				let profileWorkspaceReceipt = null;
+				let costReceipt = null;
+				let costCallId = null;
+				let shotError = null;
+				try {
+					const execute = async (executionSignal) => {
+						harnessResult = await withAuthorProfileResources(profileResourcePlan, worktreePath, async (receipt) => {
+							profileWorkspaceReceipt = receipt;
+							const result = await run({
+								harness,
+								cwd: worktreePath,
+								taskPrompt,
+								...invocation ? { invocation: {
+									command: invocation.command,
+									args: invocation.args
+								} } : {},
+								dangerouslySkipPermissions: harness === "claude",
+								...opts.codexReproducible ? { codexReproducible: true } : {},
+								...readDeniedPaths ? { codexReadDeniedPaths: readDeniedPaths } : {},
+								timeoutMs: opts.timeoutMs,
+								signal: executionSignal
+							});
+							harnessResult = result;
+							return result;
+						});
+						const failure = shotFailure(harnessResult, exactPrompt, opts.codexReproducible === true);
+						if (failure) throw failure;
+						return harnessResult;
+					};
+					if (reproducibleCostLedger) {
+						const model = opts.profile?.model?.default;
+						if (!model) throw new Error("agenticGenerator: reproducible Codex requires profile.model.default");
+						const paid = await reproducibleCostLedger.runPaidCall({
+							channel: "driver",
+							phase: costPhase ?? "search.proposal",
+							actor: `agentic-generator:${harness}`,
+							model,
+							tags: {
+								generation: String(generation ?? -1),
+								candidateIndex: String(candidateIndex ?? -1),
+								shot: String(shot + 1)
+							},
+							signal,
+							...opts.maximumCharge ? { maximumCharge: opts.maximumCharge } : {},
+							execute,
+							receipt: (result) => costReceiptFromHarness(result, model),
+							receiptFromError: () => harnessResult?.usage ? costReceiptFromHarness(harnessResult, model) : void 0
+						});
+						costCallId = paid.callId ?? null;
+						costReceipt = paid.receipt ?? null;
+						if (!paid.succeeded) throw paid.error;
+						harnessResult = paid.value;
+					} else harnessResult = await execute(signal);
+				} catch (cause) {
+					shotError = cause instanceof Error ? cause : new Error(String(cause));
+				}
+				const execution = shotExecutionSnapshot(harnessResult);
+				const receipt = shotReceipt({
+					generation,
+					candidateIndex,
+					shot,
+					maxShots: shots,
+					harness,
+					profile: opts.profile,
+					prompt: exactPrompt,
+					startedAt,
+					completedAt: /* @__PURE__ */ new Date(),
+					result: execution,
+					profileWorkspaceReceipt,
+					costCallId,
+					costReceipt,
+					error: shotError
+				});
+				await emitShotReceipt(opts.onShotCompleted, receipt, execution, shotError);
+				signal.throwIfAborted();
+				if (!execution) throw new Error("agenticGenerator: author shot completed without a harness result");
+				let worktreeChanged;
+				try {
+					worktreeChanged = dirty(worktreePath);
+				} catch (cause) {
+					signal.throwIfAborted();
+					return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "worktree-inspection", cause);
+				}
+				if (!worktreeChanged) {
+					signal.throwIfAborted();
+					await emitShotDisposition(opts.onShotDisposition, receipt, {
+						kind: "clean",
+						worktreePath
+					});
+					signal.throwIfAborted();
+					attemptNote = EMPTY_TREE_NOTE;
+					continue;
+				}
+				if (needsRawTraceEvidence) {
+					let problem;
+					try {
+						problem = rawTraceEvidenceProblem(worktreePath, findings);
+					} catch (cause) {
+						signal.throwIfAborted();
+						return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "raw-trace-evidence", cause);
+					}
+					if (problem) {
+						signal.throwIfAborted();
+						await emitShotDisposition(opts.onShotDisposition, receipt, {
+							kind: "rejected",
+							worktreePath,
+							stage: "raw-trace-evidence",
+							feedback: problem
+						});
+						signal.throwIfAborted();
+						attemptNote = problem;
+						continue;
+					}
+				}
+				if (!verify) {
+					signal.throwIfAborted();
+					await emitShotDisposition(opts.onShotDisposition, receipt, {
+						kind: "accepted",
+						worktreePath,
+						verified: false
+					});
+					signal.throwIfAborted();
+					return acceptedCandidate(findings);
+				}
+				let result;
+				try {
+					signal.throwIfAborted();
+					result = await verify(worktreePath, signal);
+					signal.throwIfAborted();
+				} catch (cause) {
+					signal.throwIfAborted();
+					return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "verification", cause);
+				}
+				if (result.ok) {
+					signal.throwIfAborted();
+					await emitShotDisposition(opts.onShotDisposition, receipt, {
+						kind: "accepted",
+						worktreePath,
+						verified: true
+					});
+					signal.throwIfAborted();
+					return acceptedCandidate(findings);
+				}
+				signal.throwIfAborted();
+				await emitShotDisposition(opts.onShotDisposition, receipt, {
+					kind: "rejected",
+					worktreePath,
+					stage: "verification",
+					feedback: result.feedback ?? null
+				});
+				signal.throwIfAborted();
+				attemptNote = failureNote(result.feedback);
+			}
+			return {
+				applied: false,
+				summary: ""
+			};
+		}
+	};
+}
+function authorProfileResourcePlan(profile) {
+	const resources = profile.resources;
+	if (!resources) return null;
+	const unsupportedKinds = [
+		resources.tools?.length ? "tools" : null,
+		resources.skills?.length ? "skills" : null,
+		resources.agents?.length ? "agents" : null
+	].filter((kind) => kind !== null);
+	if (unsupportedKinds.length > 0) throw new Error(`agenticGenerator: reproducible Codex author resources support files only; unsupported: ${unsupportedKinds.join(", ")}`);
+	if (!resources.files || resources.files.length === 0) return null;
+	const plan = materializeProfile({
+		name: profile.name,
+		resources: { files: resources.files }
+	}, "codex");
+	if (plan.unsupported.length > 0) throw new Error(`agenticGenerator: author profile files could not be materialized: ${plan.unsupported.map((item) => item.reason).join("; ")}`);
+	if (Object.keys(plan.env).length > 0 || plan.flags.length > 0) throw new Error("agenticGenerator: generic author profile files unexpectedly changed spawn values");
+	const virtualRoot = resolve("/", AGENTIC_PROFILE_RESOURCE_ROOT);
+	const seen = /* @__PURE__ */ new Set();
+	for (const file of plan.files) {
+		const target = resolve("/", file.relPath);
+		if (!target.startsWith(`${virtualRoot}${sep}`)) throw new Error(`agenticGenerator: author profile file must be below ${AGENTIC_PROFILE_RESOURCE_ROOT}: ${file.relPath}`);
+		if (seen.has(target)) throw new Error(`agenticGenerator: duplicate author profile file path: ${file.relPath}`);
+		seen.add(target);
+	}
+	return plan;
+}
+function appendProfileResourcePaths(prompt, plan) {
+	if (!plan) return prompt;
+	return [
+		prompt,
+		"",
+		"Profile resource files available for this shot:",
+		...plan.files.map((file) => `- ${file.relPath}`)
+	].join("\n");
+}
+async function withAuthorProfileResources(plan, worktreePath, run) {
+	if (!plan) return run(null);
+	const rootPath = resolve(worktreePath, AGENTIC_PROFILE_RESOURCE_ROOT);
+	if (existsSync(rootPath)) throw new Error(`agenticGenerator: ephemeral author profile root already exists: ${AGENTIC_PROFILE_RESOURCE_ROOT}`);
+	let value;
+	let primaryError;
+	try {
+		value = await run(applyWorkspacePlan(plan, worktreePath));
+	} catch (cause) {
+		primaryError = cause;
+	}
+	let cleanupError;
+	try {
+		rmSync(rootPath, {
+			recursive: true,
+			force: true
+		});
+		if (existsSync(rootPath)) throw new Error(`agenticGenerator: ephemeral author profile root survived cleanup: ${AGENTIC_PROFILE_RESOURCE_ROOT}`);
+	} catch (cause) {
+		cleanupError = cause;
+	}
+	if (primaryError !== void 0 && cleanupError !== void 0) throw new AggregateError([primaryError, cleanupError], "agenticGenerator: author shot and profile resource cleanup both failed");
+	if (primaryError !== void 0) throw primaryError;
+	if (cleanupError !== void 0) throw cleanupError;
+	return value;
+}
+async function emitShotReceipt(callback, receipt, execution, primaryError) {
+	try {
+		await callback?.(receipt, execution);
+	} catch (callbackError) {
+		if (primaryError !== null) throw new AggregateError([primaryError, callbackError], "agenticGenerator: author shot failed and its receipt could not be persisted");
+		throw callbackError;
+	}
+	if (primaryError !== null) throw primaryError;
+}
+async function emitShotDisposition(callback, receipt, disposition) {
+	await callback?.(receipt, disposition);
+}
+async function rethrowShotSetupError(callback, receipt, worktreePath, stage, cause) {
+	const error = cause instanceof Error ? cause : new Error(String(cause));
+	try {
+		await emitShotDisposition(callback, receipt, {
+			kind: "setup-error",
+			worktreePath,
+			stage,
+			error: {
+				name: error.name,
+				message: error.message
+			}
+		});
+	} catch (callbackError) {
+		throw new AggregateError([cause, callbackError], "agenticGenerator: shot processing failed and its worktree disposition could not be persisted");
+	}
+	throw cause;
+}
+function shotExecutionSnapshot(result) {
+	if (result === null) return null;
+	const usage = result.usage ? Object.freeze({ ...result.usage }) : void 0;
+	const evidence = result.evidence ? Object.freeze({
+		...result.evidence,
+		readDeniedPaths: Object.freeze([...result.evidence.readDeniedPaths]),
+		policy: Object.freeze({ ...result.evidence.policy })
+	}) : void 0;
+	return Object.freeze({
+		exitCode: result.exitCode,
+		stdout: result.stdout,
+		stderr: result.stderr,
+		killedBySignal: result.killedBySignal,
+		durationMs: result.durationMs,
+		timedOut: result.timedOut,
+		...result.aborted !== void 0 ? { aborted: result.aborted } : {},
+		...usage ? { usage } : {},
+		...evidence ? { evidence } : {}
+	});
+}
+function shotReceipt(input) {
+	const error = input.error ? {
+		name: input.error instanceof Error ? input.error.name : "Error",
+		message: input.error instanceof Error ? input.error.message : String(input.error)
+	} : null;
+	const result = input.result;
+	const costBasis = costBasisFor(input.costReceipt);
+	return {
+		generation: input.generation ?? null,
+		candidateIndex: input.candidateIndex ?? null,
+		shot: input.shot + 1,
+		maxShots: input.maxShots,
+		harness: input.harness,
+		model: input.profile?.model?.default ?? null,
+		reasoningEffort: input.profile?.model?.reasoningEffort ?? null,
+		promptSha256: sha256(input.prompt),
+		startedAt: input.startedAt.toISOString(),
+		completedAt: input.completedAt.toISOString(),
+		durationMs: result?.durationMs ?? input.completedAt.getTime() - input.startedAt.getTime(),
+		exitCode: result?.exitCode ?? null,
+		timedOut: result?.timedOut ?? false,
+		aborted: result?.aborted ?? false,
+		killedBySignal: result?.killedBySignal ?? null,
+		stdoutBytes: result ? Buffer.byteLength(result.stdout) : null,
+		stdoutSha256: result ? sha256(result.stdout) : null,
+		stderrBytes: result ? Buffer.byteLength(result.stderr) : null,
+		stderrSha256: result ? sha256(result.stderr) : null,
+		usage: result?.usage ? { ...result.usage } : null,
+		profileWorkspacePlanDigest: input.profileWorkspaceReceipt?.workspacePlanDigest ?? null,
+		profileWorkspaceFileCount: input.profileWorkspaceReceipt?.written.length ?? 0,
+		costCallId: input.costCallId,
+		costBasis,
+		costUsd: costBasis === "unknown" ? null : input.costReceipt?.costUsd ?? null,
+		costUsdKnown: costBasis === "provider-reported",
+		evidence: result?.evidence ? {
+			...result.evidence,
+			readDeniedPaths: [...result.evidence.readDeniedPaths],
+			policy: { ...result.evidence.policy }
+		} : null,
+		error
+	};
+}
+function costBasisFor(receipt) {
+	if (receipt === null || receipt.costUnknown) return "unknown";
+	return receipt.actualCostUsd === void 0 ? "estimated-pricing" : "provider-reported";
+}
+function shotFailure(result, exactPrompt, codexReproducible) {
+	if (result.timedOut) return /* @__PURE__ */ new Error("agenticGenerator: author shot timed out");
+	if (result.aborted) return /* @__PURE__ */ new Error("agenticGenerator: author shot was cancelled by the caller");
+	if (result.killedBySignal) return /* @__PURE__ */ new Error(`agenticGenerator: author shot was killed by ${result.killedBySignal}`);
+	if (result.exitCode !== 0) return /* @__PURE__ */ new Error(`agenticGenerator: author shot exited with code ${String(result.exitCode)}`);
+	if (!codexReproducible) return null;
+	if (!result.usage || !result.evidence) return /* @__PURE__ */ new Error("agenticGenerator: reproducible Codex shot completed without usage or execution evidence");
+	const expectedPromptSha256 = sha256(exactPrompt).slice(7);
+	if (result.evidence.requestedPromptSha256 !== expectedPromptSha256) return /* @__PURE__ */ new Error("agenticGenerator: reproducible Codex prompt evidence does not match the exact authored prompt");
+	return null;
+}
+function costReceiptFromHarness(result, model) {
+	if (!result.usage) throw new Error("agenticGenerator: author shot did not report terminal token usage");
+	return {
+		model,
+		inputTokens: result.usage.inputTokens - result.usage.cachedInputTokens,
+		outputTokens: result.usage.outputTokens,
+		...result.usage.cachedInputTokens > 0 ? { cachedTokens: result.usage.cachedInputTokens } : {}
+	};
+}
+function sha256(value) {
+	return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+/** Turn the analyst's findings (+ optional report) into a concrete coder task —
+*  the senior scientific-method framing shared with the tool/MCP build prompts. */
+function defaultBuildPrompt(args) {
+	const lines = [
+		"You are improving this codebase based on an evaluation analysis: real runs failed, an",
+		"analyst distilled the findings below, and your change will be measured on held-out tasks",
+		"against the unchanged baseline — only a real lift promotes it.",
+		"",
+		optimizerMethod,
+		"",
+		"THE SURFACE — what a deliverable change looks like here:",
+		"- edit this codebase in place: the smallest coherent change set that fully tests your",
+		"  hypothesis about the dominant failure mode (see the method above — no unrelated edits,",
+		"  they confound the measurement),",
+		"- keep the diff reviewable: a reviewer should be able to trace every hunk back to a finding,",
+		"- do not commit — leave changes in the working tree.",
+		"",
+		"FINDINGS — ranked evidence from real failed runs:"
+	];
+	for (const f of args.findings) {
+		const where = f.subject ? ` [${f.subject}]` : "";
+		lines.push(`- (${f.severity})${where} ${f.claim}`);
+		if (f.recommended_action) lines.push(`    → ${f.recommended_action}`);
+	}
+	if (requiresRawTraceEvidence(args.findings)) lines.push("", "Raw trace evidence requirement:", `- Inspect at least one raw trace path named above before editing.`, `- Write ${RAW_TRACE_DIAGNOSIS_PATH} in this worktree.`, "- Include the exact trace path(s) inspected, the failure mechanism, and the code change made.", "- A candidate without this file, or with only this file changed, is discarded.");
+	return lines.join("\n");
+}
+const EMPTY_TREE_NOTE = "NOTE: your previous attempt left the working tree unchanged. Make the concrete file edits now.";
+/** Next-shot feedback when the worktree is dirty but failed verification. The
+*  edits persist on disk, so the harness resumes atop them — tell it to fix in
+*  place, not start over. Verifier detail is truncated to keep the prompt bounded. */
+function failureNote(feedback) {
+	const detail = feedback?.trim();
+	return [
+		"NOTE: your edits are in the working tree but verification FAILED.",
+		"Fix the problem in place — build on your existing edits, do not revert them.",
+		detail ? `Verifier output:\n${truncate$1(detail, 4e3)}` : "No verifier detail was captured."
+	].join("\n");
+}
+function rawTraceEvidenceProblem(worktreePath, findings) {
+	if (worktreeChangedPaths(worktreePath).filter((path) => path !== RAW_TRACE_DIAGNOSIS_PATH).length === 0) return [`NOTE: raw-trace mode requires a real code/config edit in addition to ${RAW_TRACE_DIAGNOSIS_PATH}.`, "Your previous attempt only changed the diagnosis artifact. Inspect the cited traces and make the causal code change."].join("\n");
+	const diagnosisPath = join(worktreePath, RAW_TRACE_DIAGNOSIS_PATH);
+	if (!existsSync(diagnosisPath)) return [`NOTE: raw-trace mode requires ${RAW_TRACE_DIAGNOSIS_PATH}.`, "Before retrying, inspect at least one cited spans.jsonl/cached-result.json/artifact path, then write the diagnosis file with the exact path, failure mechanism, and code change."].join("\n");
+	const body = readFileSync(diagnosisPath, "utf8");
+	const evidencePaths = traceEvidencePaths(findings);
+	if (evidencePaths.length > 0 && !evidencePaths.some((path) => body.includes(path))) return [`${RAW_TRACE_DIAGNOSIS_PATH} exists, but it does not cite any exact raw trace path from the findings.`, `Cite at least one of these inspected paths exactly: ${evidencePaths.slice(0, 5).join(", ")}`].join("\n");
+	return null;
+}
+function requiresRawTraceEvidence(findings) {
+	return findings.some((finding) => {
+		const f = finding;
+		return f.analyst_id === RAW_TRACE_ANALYST_ID || f.area === RAW_TRACE_AREA;
+	});
+}
+function traceEvidencePaths(findings) {
+	const out = [];
+	for (const finding of findings) {
+		const refs = finding.evidence_refs;
+		if (!Array.isArray(refs)) continue;
+		for (const ref of refs) {
+			if (!ref || typeof ref !== "object") continue;
+			const uri = ref.uri;
+			if (typeof uri === "string" && uri.length > 0) out.push(uri);
+		}
+	}
+	return [...new Set(out)];
+}
+/** A `Verifier` that runs a command in the worktree: exit 0 ⇒ ok, any other
+*  exit ⇒ failed with stdout+stderr as feedback. The common case — verify by
+*  `tsc --noEmit`, `pnpm build`, or a test command. A timeout is treated as a
+*  FAILED candidate (a change that hangs the build is a bad change); a missing
+*  binary or spawn fault throws (a setup bug, not a failed candidate — no
+*  silent fallback). */
+function commandVerifier(command, args = [], timeoutMs = 3e5) {
+	return async (worktreePath, signal) => {
+		let result;
+		try {
+			result = await runSettledCommand({
+				command,
+				args,
+				cwd: worktreePath,
+				timeoutMs,
+				...signal ? { signal } : {}
+			});
+		} catch (err) {
+			signal?.throwIfAborted();
+			if (err.code === "ENOENT") throw new Error(`commandVerifier: '${command}' not found in PATH (setup bug, not a failed candidate)`);
+			const reason = err instanceof Error ? err.message : String(err);
+			throw new Error(`commandVerifier: '${command}' failed to spawn: ${reason}`);
+		}
+		if (result.timedOut || result.killedBySignal) return {
+			ok: false,
+			feedback: `verifier '${command}' ${result.killedBySignal ? `killed by ${result.killedBySignal}` : "timed out"} after ${timeoutMs}ms`
+		};
+		if (result.exitCode === 0) return { ok: true };
+		const out = `${result.stdout}${result.stderr}`.trim();
+		return {
+			ok: false,
+			feedback: out.length > 0 ? out : `exit ${result.exitCode}`
+		};
+	};
+}
+/** A one-line summary for the commit message, derived from the findings. */
+function summarizeFindings(findings) {
+	if (findings.length === 0) return "agentic improvement";
+	if (findings.length === 1) return `agentic: ${truncate$1(findings[0].claim, 64)}`;
+	return `agentic: ${findings.length} findings addressed`;
+}
+/**
+* The accepted-shot result: summary (commit message) + the attribution pair
+* the driver wraps into a `ProposedCandidate`, so the candidate stays
+* attributable through `GenerationRecord` and the emitted provenance instead
+* of landing as an anonymous surface.
+*/
+function acceptedCandidate(findings) {
+	const summary = summarizeFindings(findings);
+	return {
+		applied: true,
+		summary,
+		label: slugify(summary.split("\n", 1)[0] ?? summary),
+		rationale: boundedRationale(summary, findings)
+	};
+}
+/** Short slug from the summary's first line — the candidate's human label. */
+function slugify(line) {
+	return truncate$1(line.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agentic-improvement", 48);
+}
+/** Bounded "because Z" for the candidate: the findings it addressed, or the
+*  summary itself when the change was proposed from raw repo/trace context. */
+function boundedRationale(summary, findings) {
+	if (findings.length === 0) return summary;
+	return truncate$1(findings.map((finding) => `(${finding.severity}) ${finding.claim}`).join("; "), 400);
+}
+function truncate$1(s, n) {
+	return s.length <= n ? s : `${s.slice(0, n - 1)}…`;
+}
+/** Non-empty `git status --porcelain` ⇒ the harness changed the worktree.
+*  Fails loud: the worktree is a fresh checkout, so a git error here means
+*  something is genuinely broken (git missing, corrupt index, killed mid-run).
+*  Folding that into `false` would silently discard a candidate and mask the
+*  real failure — forbidden by the no-silent-fallbacks doctrine. */
+function worktreeDirty(worktreePath) {
+	return worktreeChangedPaths(worktreePath).length > 0;
+}
+function worktreeChangedPaths(worktreePath) {
+	const result = spawnSync("git", [
+		"status",
+		"--porcelain",
+		"--untracked-files=all"
+	], {
+		cwd: worktreePath,
+		encoding: "utf-8"
+	});
+	if (result.error) throw new Error(`agenticGenerator: git status failed to spawn in ${worktreePath}: ${result.error.message}`);
+	if (result.status !== 0) throw new Error(`agenticGenerator: git status exited ${result.status} in ${worktreePath}: ${result.stderr.trim()}`);
+	return result.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => line.slice(3).trim());
+}
+//#endregion
+//#region src/improvement/findings.ts
+/**
+* Typed-findings accessor — the one place `unknown[]` findings become
+* `AnalystFinding[]`.
+*
+* agent-eval's `ProposeContext.findings` is `TFindings[] = unknown[]` on the
+* wire: the loop threads whatever the previous `analyzeGeneration` producer (or
+* the caller's static seed) returned. Consumers that need the typed envelope
+* (`claim`/`severity`/`recommended_action`) were down-casting with a bare
+* `as AnalystFinding[]` — a lie at runtime whenever the seed was a raw string
+* or an ad-hoc digest, which then rendered `undefined` into build prompts.
+*
+* `toAnalystFindings` replaces that cast: real findings pass through
+* unchanged (structural guard, fail-closed), and non-conforming values are
+* LIFTED into a real `AnalystFinding` envelope via `makeFinding` — the most
+* actionable text becomes the claim, the original value rides in `metadata.raw`
+* — so everything downstream of the accessor handles exactly one shape.
+*/
+const SEVERITIES = /* @__PURE__ */ new Set([
+	"critical",
+	"high",
+	"medium",
+	"low",
+	"info"
+]);
+/** Analyst id stamped on findings lifted from untyped seed values. */
+const LIFTED_FINDING_ANALYST_ID = "lifted-seed";
+/** Structural guard for the schema-versioned `AnalystFinding` envelope.
+*  Strict on the identity fields `makeFinding` always populates — a partial
+*  look-alike is lifted (re-enveloped), not trusted. */
+function isAnalystFinding(value) {
+	if (!value || typeof value !== "object") return false;
+	const o = value;
+	return o.schema_version === "1.0.0" && typeof o.finding_id === "string" && typeof o.analyst_id === "string" && typeof o.severity === "string" && SEVERITIES.has(o.severity) && typeof o.area === "string" && typeof o.claim === "string" && typeof o.confidence === "number" && Array.isArray(o.evidence_refs);
+}
+/** The most actionable text of an untyped finding-ish value — mirrors the
+*  extraction order agent-eval's curator proposers use (`recommended_action` >
+*  `claim` > `lesson` > `notes` > `text` > `message`), so the two ends of the
+*  wire read the same field first. */
+function liftedClaim(value) {
+	if (typeof value === "string") return value.trim() || null;
+	if (value && typeof value === "object") {
+		const o = value;
+		for (const key of [
+			"recommended_action",
+			"claim",
+			"lesson",
+			"notes",
+			"text",
+			"message"
+		]) {
+			const v = o[key];
+			if (typeof v === "string" && v.trim()) return v.trim();
+		}
+		try {
+			const json = JSON.stringify(value);
+			if (json && json !== "{}" && json !== "[]") return json.length > 400 ? `${json.slice(0, 399)}…` : json;
+		} catch {}
+	}
+	return null;
+}
+/**
+* Normalize a mixed `unknown[]` findings array to `AnalystFinding[]`:
+* conforming findings pass through by reference; strings and finding-ish
+* objects are lifted into envelopes (claim = most actionable text, original
+* value under `metadata.raw`); values with no extractable text are dropped.
+* Never throws — a malformed seed must not kill a proposal round.
+*/
+function toAnalystFindings(findings, opts = {}) {
+	const analystId = opts.analystId ?? "lifted-seed";
+	const area = opts.area ?? "seed";
+	const out = [];
+	for (const f of findings) {
+		if (isAnalystFinding(f)) {
+			out.push(f);
+			continue;
+		}
+		const claim = liftedClaim(f);
+		if (!claim) continue;
+		out.push(makeFinding({
+			analyst_id: analystId,
+			severity: "info",
+			area,
+			confidence: .5,
+			claim,
+			evidence_refs: [],
+			...f && typeof f === "object" ? { metadata: { raw: f } } : {}
+		}));
+	}
+	return out;
+}
+//#endregion
+//#region src/improvement/cleanup.ts
+async function rethrowAfterCleanup(cause, cleanup, context) {
+	const cleanupErrors = [];
+	for (let attempt = 0; attempt < 2; attempt += 1) {
+		try {
+			await cleanup();
+		} catch (cleanupCause) {
+			cleanupErrors.push(cleanupCause);
+			continue;
+		}
+		if (cleanupErrors.length === 0) throw cause;
+		throw new AggregateError([cause, ...cleanupErrors], `${context}; cleanup retry succeeded`);
+	}
+	throw new AggregateError([cause, ...cleanupErrors], `${context}; cleanup failed`);
+}
+//#endregion
+//#region src/improvement/improve-result.ts
+function copyImproveCost(cost) {
+	return {
+		totalCostUsd: cost.totalCostUsd,
+		accountingComplete: cost.accountingComplete,
+		incompleteReasons: [...cost.incompleteReasons]
+	};
+}
+//#endregion
+//#region src/improvement/improvement-driver.ts
+/**
+* Code-only candidate driver for Runtime-owned git worktrees.
+*
+* A `CandidateGenerator` edits an isolated checkout. This driver finalizes each
+* accepted edit as a `CodeSurface` and disposes rejected worktrees.
+*
+* @experimental
+*/
+/** Build the code-only proposer used internally by `improve({ surface: 'code' })`. */
+function improvementDriver(opts) {
+	const baseRef = opts.baseRef ?? "main";
+	const owned = /* @__PURE__ */ new Map();
+	return {
+		kind: `improvement:${opts.generator.kind}`,
+		async propose(ctx) {
+			const findings = resolveFindings(ctx);
+			if (findings.length === 0 && ctx.report === void 0 && !opts.generator.proposesWithoutFindings) return [];
+			const surfaces = [];
+			const incumbent = verifiedCodeIncumbent(ctx.currentSurface);
+			const proposalBaseRef = incumbent?.baseCommit ?? baseRef;
+			for (let i = 0; i < ctx.populationSize; i++) {
+				if (ctx.signal.aborted) break;
+				const wt = await opts.worktree.create({
+					baseRef: proposalBaseRef,
+					label: `${opts.generator.kind}-gen${ctx.generation}-cand${i}`
+				});
+				owned.set(wt.path, wt);
+				try {
+					if (incumbent) advanceToIncumbent(wt, incumbent);
+					const { applied, summary, label, rationale } = await opts.generator.generate({
+						worktreePath: wt.path,
+						report: ctx.report,
+						findings,
+						dataset: ctx.dataset,
+						maxShots: ctx.maxImprovementShots ?? 1,
+						signal: ctx.signal,
+						generation: ctx.generation,
+						candidateIndex: i,
+						...ctx.costLedger ? { costLedger: ctx.costLedger } : {},
+						...ctx.costPhase ? { costPhase: ctx.costPhase } : {}
+					});
+					if (!applied) {
+						await opts.worktree.discard(wt);
+						owned.delete(wt.path);
+						continue;
+					}
+					const surface = await opts.worktree.finalize(wt, summary);
+					surfaces.push(label || rationale ? {
+						surface,
+						label: label ?? "",
+						rationale: rationale ?? ""
+					} : surface);
+					owned.delete(wt.path);
+					owned.set(surface.worktreeRef, wt);
+				} catch (err) {
+					return rethrowAfterCleanup(err, async () => {
+						await opts.worktree.discard(wt);
+						owned.delete(wt.path);
+					}, `improvementDriver: ${err instanceof Error ? err.message : String(err)}`);
+				}
+			}
+			return surfaces;
+		},
+		async cleanup(retainWorktreeRefs = []) {
+			const retained = new Set(retainWorktreeRefs);
+			const errors = [];
+			for (const [worktreeRef, worktree] of owned) {
+				if (retained.has(worktreeRef)) continue;
+				try {
+					await opts.worktree.discard(worktree);
+					owned.delete(worktreeRef);
+				} catch (cause) {
+					errors.push(cause);
+				}
+			}
+			if (errors.length > 0) throw new AggregateError(errors, "improvementDriver: failed to discard candidate worktrees");
+		}
+	};
+}
+/** A code incumbent must still match the immutable identity that was measured. */
+function verifiedCodeIncumbent(surface) {
+	if (typeof surface !== "object" || surface.kind !== "code") return void 0;
+	verifyCodeSurface(surface);
+	return surface;
+}
+/** Start at the root commit recorded by the incumbent, then fast-forward the
+*  fresh branch to the incumbent commit. The worktree stays clean for the
+*  generator while `finalize()` still emits one cumulative root-to-candidate
+*  patch that can be applied or rolled back independently of prior branches. */
+function advanceToIncumbent(worktree, incumbent) {
+	if (worktree.baseCommit !== incumbent.baseCommit || worktree.baseTree !== incumbent.baseTree) throw new Error("improvementDriver: candidate worktree does not match incumbent base identity");
+	if (worktree.baseCommit === incumbent.candidateCommit) return;
+	const merge = spawnSync("git", [
+		"merge",
+		"--ff-only",
+		incumbent.candidateCommit
+	], {
+		cwd: worktree.path,
+		encoding: "utf8"
+	});
+	if (merge.error) throw new Error(`improvementDriver: failed to start candidate from incumbent: ${merge.error.message}`);
+	if (merge.status !== 0) throw new Error(`improvementDriver: could not fast-forward candidate to incumbent ${incumbent.candidateCommit}: ${merge.stderr.trim()}`);
+	const head = spawnSync("git", [
+		"rev-parse",
+		"--verify",
+		"HEAD"
+	], {
+		cwd: worktree.path,
+		encoding: "utf8"
+	});
+	if (head.error || head.status !== 0 || head.stdout.trim() !== incumbent.candidateCommit) throw new Error("improvementDriver: candidate worktree did not reach the incumbent commit");
+}
+/** Phase-2 report carries `findings` when present; else fall back to the
+*  loop's `ctx.findings`. The report is opaque to the substrate, so probe it
+*  structurally. Both paths run through `toAnalystFindings` — the wire is
+*  `unknown[]` at runtime regardless of the generic (static seeds, legacy
+*  digests), and a bare cast here fed `undefined` claims into build prompts. */
+function resolveFindings(ctx) {
+	const report = ctx.report;
+	if (report && typeof report === "object" && "findings" in report) {
+		const f = report.findings;
+		if (Array.isArray(f) && f.length > 0) {
+			const lifted = toAnalystFindings(f, {
+				analystId: "report-findings",
+				area: "report"
+			});
+			if (lifted.length > 0) return lifted;
+		}
+	}
+	return toAnalystFindings(ctx.findings ?? [], {
+		analystId: "loop-context",
+		area: "seed"
+	});
+}
+//#endregion
+//#region src/improvement/rollout-policy.ts
+/** The profile extensions namespace the policy persists under. */
+const ROLLOUT_POLICY_EXTENSION = "structural-rollout";
+const isBoundedInt = (v, min) => typeof v === "number" && Number.isInteger(v) && v >= min;
+/** Parse a serialized policy surface. Returns `undefined` for non-strings,
+* malformed JSON, or values outside the policy invariants. Unknown fields are
+* dropped; supported optional fields are preserved. */
+function parseRolloutPolicy(surface) {
+	if (typeof surface !== "string" || surface.trim().length === 0) return void 0;
+	let raw;
+	try {
+		raw = JSON.parse(surface);
+	} catch {
+		return;
+	}
+	return normalizeRolloutPolicy(raw);
+}
+/** Normalize an untyped policy bag (a parsed surface or a profile extension) into
+*  a full `StructuralRolloutPolicy`, defaults merged. Returns `undefined` when any
+*  present dial violates the policy invariants (mirrors `resolvePolicy`: integer
+*  k ≥ 1, repairRounds ≥ 0, testgen ≥ 0) — a corrupt config must read as "not
+*  configured", never as a fabricated recipe. */
+function normalizeRolloutPolicy(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+	const bag = raw;
+	const k = bag.k ?? defaultStructuralRolloutPolicy.k;
+	const repairRounds = bag.repairRounds ?? defaultStructuralRolloutPolicy.repairRounds;
+	const testgen = bag.testgen ?? defaultStructuralRolloutPolicy.testgen;
+	if (!isBoundedInt(k, 1) || !isBoundedInt(repairRounds, 0) || !isBoundedInt(testgen, 0)) return;
+	return {
+		k,
+		repairRounds,
+		testgen,
+		...typeof bag.diverse === "boolean" ? { diverse: bag.diverse } : {},
+		...typeof bag.temperature === "number" ? { temperature: bag.temperature } : {}
+	};
+}
+/** Stable serialization with fixed field order. */
+function serializeRolloutPolicy(policy) {
+	return JSON.stringify({
+		k: policy.k,
+		repairRounds: policy.repairRounds,
+		testgen: policy.testgen,
+		...policy.diverse !== void 0 ? { diverse: policy.diverse } : {},
+		...policy.temperature !== void 0 ? { temperature: policy.temperature } : {}
+	});
+}
+/** Read the persisted policy off the profile. `undefined` when the profile does
+*  not opt into structural rollout. */
+function structuralRolloutPolicyFromProfile(profile) {
+	const bag = profile.extensions?.[ROLLOUT_POLICY_EXTENSION];
+	if (bag === void 0) return void 0;
+	return normalizeRolloutPolicy(bag);
+}
+/** Persist a detached policy under the profile extension without mutating the input. */
+function applyRolloutPolicyToProfile(profile, policy) {
+	const candidate = structuredClone(profile);
+	const bag = {
+		k: policy.k,
+		repairRounds: policy.repairRounds,
+		testgen: policy.testgen,
+		...policy.diverse !== void 0 ? { diverse: policy.diverse } : {},
+		...policy.temperature !== void 0 ? { temperature: policy.temperature } : {}
+	};
+	return {
+		...candidate,
+		extensions: {
+			...candidate.extensions,
+			[ROLLOUT_POLICY_EXTENSION]: bag
+		}
+	};
+}
+//#endregion
+//#region src/improvement/profile-surface.ts
+/** Extract the baseline optimized by a method and retain its structured value
+* so external optimizers can inspect it for private fields before serialization. */
+function prepareProfileSurface(profile, surface, skills, profileComponents) {
+	switch (surface) {
+		case "prompt": return {
+			surface: profile.prompt?.systemPrompt ?? "",
+			value: profile.prompt?.systemPrompt ?? ""
+		};
+		case "skills": {
+			const value = inlineSkill(profile, skills).content;
+			return {
+				surface: value,
+				value
+			};
+		}
+		case "tools": {
+			const value = profile.tools ?? {};
+			return {
+				surface: canonicalJson(value),
+				value
+			};
+		}
+		case "mcp": {
+			const value = profile.mcp ?? {};
+			return {
+				surface: canonicalJson(value),
+				value
+			};
+		}
+		case "hooks": {
+			const value = profile.hooks ?? {};
+			return {
+				surface: canonicalJson(value),
+				value
+			};
+		}
+		case "subagents": {
+			const value = profile.subagents ?? {};
+			return {
+				surface: canonicalJson(value),
+				value
+			};
+		}
+		case "agent-profile":
+			if (profileComponents) {
+				const value = profileComponents.read(profile);
+				return {
+					surface: componentSurface(value, "profileComponents.read"),
+					value
+				};
+			}
+			return {
+				surface: canonicalJson(profile),
+				value: profile
+			};
+		case "memory": {
+			const value = profileInstructions(profile);
+			return {
+				surface: value,
+				value
+			};
+		}
+		case "rollout-policy": {
+			const policy = structuralRolloutPolicyFromProfile(profile);
+			return {
+				surface: policy ? serializeRolloutPolicy(policy) : "",
+				value: policy ?? null
+			};
+		}
+		case "code": throw new ConfigError("improve(): code requires the isolated baseline created from opts.code.repoRoot");
+	}
+}
+function isCodeSurface(surface) {
+	return typeof surface === "object" && surface !== null && surface.kind === "code";
+}
+function isComponentSurface(surface) {
+	return typeof surface === "object" && surface !== null && surface.kind === "components";
+}
+function componentSurface(components, source) {
+	const entries = validateComponents(components, source);
+	return immutableCandidateValue({
+		kind: "components",
+		components: Object.fromEntries(entries)
+	});
+}
+function validateComponents(components, source) {
+	if (typeof components !== "object" || components === null || Array.isArray(components)) throw new ConfigError(`improve(): ${source} must return a component record`);
+	const entries = Object.entries(components);
+	if (entries.length === 0) throw new ConfigError(`improve(): ${source} must return at least one component`);
+	for (const [name, value] of entries) if (!name || name.trim() !== name || typeof value !== "string") throw new ConfigError(`improve(): ${source} must return trimmed component names with string values`);
+	return entries;
+}
+/** Parse a JSON winner surface with a typed, contextual error. */
+function parseWinnerJson(winner, surface) {
+	try {
+		return JSON.parse(winner);
+	} catch (cause) {
+		throw new ConfigError(`improve(): the '${surface}' candidate is not valid JSON, so it cannot form a profile candidate: ${cause.message}`);
+	}
+}
+function assertCandidateSurfaceKind(surface, baseline, winner) {
+	if (surface === "code") {
+		if (isCodeSurface(winner)) return;
+		throw new ConfigError(`improve(): the '${surface}' candidate returned an incompatible surface value`);
+	}
+	if (typeof baseline === "string") {
+		if (typeof winner === "string") return;
+		throw new ConfigError(`improve(): the '${surface}' candidate changed from a text surface to an incompatible surface value`);
+	}
+	if (!isComponentSurface(baseline) || !isComponentSurface(winner)) throw new ConfigError(`improve(): the '${surface}' candidate returned an incompatible surface value`);
+	validateComponents(winner.components, `the '${surface}' candidate`);
+	const baselineNames = Object.keys(baseline.components).sort();
+	const winnerNames = Object.keys(winner.components).sort();
+	if (baselineNames.length !== winnerNames.length || baselineNames.some((name, index) => name !== winnerNames[index])) throw new ConfigError(`improve(): the '${surface}' candidate must preserve the exact component names`);
+}
+/** Materialize a detached profile candidate without changing the baseline. */
+function materializeImprovementProfileCandidate(profile, surface, winner, skills, profileComponents) {
+	let candidate;
+	if (isComponentSurface(winner)) {
+		if (surface !== "agent-profile" || !profileComponents) throw new ConfigError(`improve(): the '${surface}' candidate has no profile component mapping`);
+		const winnerComponents = immutableCandidateValue({ ...winner.components });
+		const validated = validateProfileCandidate(profileComponents.apply(profile, winnerComponents), surface);
+		const materializedComponents = Object.fromEntries(validateComponents(profileComponents.read(validated), "profileComponents.read after apply"));
+		const names = Object.keys(winnerComponents);
+		if (names.length !== Object.keys(materializedComponents).length || names.some((name) => materializedComponents[name] !== winnerComponents[name])) throw new ConfigError("improve(): profileComponents.apply must round-trip every winning component exactly");
+		return validated;
+	}
+	if (typeof winner !== "string") throw new ConfigError(`improve(): the '${surface}' candidate cannot form an AgentProfile`);
+	switch (surface) {
+		case "prompt":
+			candidate = {
+				...profile,
+				prompt: {
+					...profile.prompt,
+					systemPrompt: winner
+				}
+			};
+			break;
+		case "skills": {
+			const selectedSkill = inlineSkill(profile, skills);
+			candidate = {
+				...profile,
+				resources: {
+					...profile.resources,
+					skills: profile.resources?.skills?.map((resource) => resource === selectedSkill ? {
+						...resource,
+						content: winner
+					} : resource)
+				}
+			};
+			break;
+		}
+		case "tools":
+			candidate = {
+				...profile,
+				tools: parseWinnerJson(winner, surface)
+			};
+			break;
+		case "mcp":
+			candidate = {
+				...profile,
+				mcp: parseWinnerJson(winner, surface)
+			};
+			break;
+		case "hooks":
+			candidate = {
+				...profile,
+				hooks: parseWinnerJson(winner, surface)
+			};
+			break;
+		case "subagents":
+			candidate = {
+				...profile,
+				subagents: parseWinnerJson(winner, surface)
+			};
+			break;
+		case "agent-profile":
+			candidate = parseWinnerJson(winner, surface);
+			break;
+		case "memory":
+			candidate = {
+				...profile,
+				resources: {
+					...profile.resources,
+					instructions: replaceProfileInstructions(profile, winner)
+				}
+			};
+			break;
+		case "rollout-policy": {
+			const policy = normalizeRolloutPolicy(parseWinnerJson(winner, surface));
+			if (!policy) throw new ConfigError(`improve(): the shipped 'rollout-policy' winner is not a valid StructuralRolloutPolicy (integer k >= 1, repairRounds >= 0, testgen >= 0), so it cannot be applied: ${winner}`);
+			candidate = applyRolloutPolicyToProfile(profile, policy);
+			break;
+		}
+	}
+	return validateProfileCandidate(candidate, surface);
+}
+function validateProfileCandidate(candidate, surface) {
+	const parsed = agentProfileSchema.safeParse(candidate);
+	if (!parsed.success) throw new ConfigError(`improve(): the '${surface}' candidate does not produce a valid AgentProfile: ${parsed.error.message}`);
+	return immutableCandidateValue(parsed.data);
+}
+function createProfileCandidateMaterializer(profile, surface, baselineSurface, skills, profileComponents) {
+	const baselineDigest = canonicalCandidateDigest$1(baselineSurface);
+	if (profileComponents) {
+		if (canonicalCandidateDigest$1(materializeImprovementProfileCandidate(profile, surface, baselineSurface, skills, profileComponents)) !== canonicalCandidateDigest$1(profile)) throw new ConfigError("improve(): profileComponents.apply(profile, profileComponents.read(profile)) must reproduce the complete baseline profile exactly");
+	}
+	const candidates = /* @__PURE__ */ new Map([[baselineDigest, profile]]);
+	return (candidateSurface) => {
+		assertCandidateSurfaceKind(surface, baselineSurface, candidateSurface);
+		const digest = canonicalCandidateDigest$1(candidateSurface);
+		const existing = candidates.get(digest);
+		if (existing) return existing;
+		const candidate = materializeImprovementProfileCandidate(profile, surface, immutableCandidateValue(candidateSurface), skills, profileComponents);
+		candidates.set(digest, candidate);
+		return candidate;
+	};
+}
+function inlineSkill(profile, options) {
+	const resourceName = options?.resourceName.trim();
+	if (!resourceName) throw new ConfigError("improve(): surface 'skills' requires opts.skills.resourceName for one inline profile skill");
+	assertFailClosedResources(profile, "skills");
+	const matches = (profile.resources?.skills ?? []).filter((resource) => resource.name === resourceName);
+	if (matches.length !== 1 || matches[0]?.kind !== "inline") throw new ConfigError(`improve(): skill '${resourceName}' must identify exactly one inline profile resource`);
+	return matches[0];
+}
+function profileInstructions(profile) {
+	assertFailClosedResources(profile, "memory");
+	const instructions = profile.resources?.instructions;
+	if (instructions === void 0) return "";
+	if (typeof instructions === "string") return instructions;
+	if (instructions.kind === "inline") return instructions.content;
+	throw new ConfigError("improve(): surface 'memory' requires inline profile instructions so candidate bytes are exact");
+}
+function replaceProfileInstructions(profile, content) {
+	const instructions = profile.resources?.instructions;
+	if (typeof instructions !== "object") return content;
+	if (instructions.kind !== "inline") throw new ConfigError("improve(): surface 'memory' requires inline profile instructions so candidate bytes are exact");
+	return {
+		...instructions,
+		content
+	};
+}
+function assertFailClosedResources(profile, surface) {
+	if (profile.resources?.failOnError !== true) throw new ConfigError(`improve(): surface '${surface}' requires profile.resources.failOnError: true`);
+}
+//#endregion
+//#region src/improvement/raw-trace-distiller.ts
+/**
+*
+* `rawTraceDistiller` — the meta-harness `analyzeGeneration` producer.
+*
+* The default `generationFailureDistiller` (in `improve.ts`) COMPRESSES each
+* generation's failing cells into ~1500-char structured findings before the next
+* proposal round. That is the ACE-style recipe: a small summary is the proposer's
+* whole view of what went wrong. This producer does the opposite — the
+* meta-harness recipe (yoonholee.com/meta-harness): it does NOT summarize. It
+* points the coding-agent proposer at the generation's RAW run traces already on
+* disk under `runDir` — the durable per-cell `spans.jsonl` event logs,
+* `cached-result.json` scores, and any artifacts the substrate persisted — and
+* instructs the agent to `grep`/`cat`/`ls` them to diagnose the failures itself
+* (up to the harness's full context, ~millions of tokens, vs a ~1500-char digest).
+*
+* It emits `AnalystFinding[]` so it drops into the SAME `opts.analyzeGeneration`
+* slot the default distiller uses, and renders through the same
+* `agenticGenerator` prompt path (`claim` + `recommended_action`). The findings
+* carry ABSOLUTE paths — the coding harness runs with `cwd` = a candidate
+* worktree, so a relative `runDir` would be uncattable from there.
+*
+* Runtime layout it reads (written by agent-eval's optimization loop):
+*
+*   <runDir>/gen-<N>/                     ← the generation dir (input.runDir)
+*     candidate-<i>/                      ← one candidate campaign (campaign.runDir)
+*       <sanitized cellId>/               ← one scenario×rep cell
+*         spans.jsonl                     ← the raw trace (event/span log)
+*         cached-result.json              ← the cell's score + artifact ref
+*         <artifacts…>                    ← whatever the dispatch wrote
+*
+* @experimental
+*/
+const ANALYST_ID = "raw-trace-distiller";
+/** A cell counts as "failing" below this mean composite (matches the default
+*  distiller's near-perfect threshold) or when it recorded an `error`. */
+const PASS_THRESHOLD = .999;
+/**
+* Build an `analyzeGeneration` producer that feeds the proposer RAW-TRACE
+* FILESYSTEM CONTEXT — paths into the prior generation's real run traces plus a
+* grep/cat-to-diagnose instruction — instead of a pre-summarized digest.
+*
+* Drop-in for `analyzeGeneration` on `improve({ surface: 'code' })`:
+*
+*   await improve({
+*     surface: 'code',
+*     findings: seedFindings,
+*     code: { repoRoot },
+*     runDir: '/abs/run',                 // MUST be a real path — the traces live here
+*     analyzeGeneration: rawTraceDistiller(),
+*     scenarios, judge, agent,
+*   })
+*/
+function rawTraceDistiller(options = {}) {
+	const maxCandidates = options.maxCandidates ?? 12;
+	const maxCellsPerCandidate = options.maxCellsPerCandidate ?? 8;
+	const maxFilesPerCell = options.maxFilesPerCell ?? 24;
+	return async (input) => {
+		const genRoot = absoluteRunDir(options.runDir ?? input.runDir);
+		const durable = isDurable(genRoot);
+		const ranked = [...input.candidates].map((c) => ({
+			surfaceHash: c.surfaceHash,
+			composite: c.composite,
+			campaignDir: absoluteRunDir(c.campaign.runDir),
+			cells: failingCells(c.campaign, maxCellsPerCandidate, maxFilesPerCell)
+		})).sort((a, b) => compareCandidateComposites(a.composite, b.composite)).slice(0, maxCandidates);
+		const totalFailingCells = ranked.reduce((n, c) => n + c.cells.length, 0);
+		if (totalFailingCells === 0) {
+			if (options.fallbackFindings && options.fallbackFindings.length > 0) return options.fallbackFindings;
+			return [makeFinding({
+				analyst_id: ANALYST_ID,
+				severity: "info",
+				area: "raw-trace-context",
+				confidence: 1,
+				claim: `Generation ${input.generation} had no failing cells. The full raw run traces are on disk under ${genRoot}.`,
+				recommended_action: `To keep improving, grep/cat the raw traces under ${genRoot} (per-cell spans.jsonl + cached-result.json) to find the weakest passing runs, then make a targeted harness-code edit.`,
+				evidence_refs: [{
+					kind: "artifact",
+					uri: genRoot
+				}],
+				metadata: {
+					generation: input.generation,
+					runDir: genRoot,
+					failingCells: 0
+				}
+			})];
+		}
+		const findings = [];
+		findings.push(makeFinding({
+			analyst_id: ANALYST_ID,
+			severity: "high",
+			area: "raw-trace-context",
+			confidence: 1,
+			claim: `Generation ${input.generation} produced ${totalFailingCells} failing/low-scoring cell(s) across ${ranked.length} candidate(s). Their FULL RAW run traces are on disk under ${genRoot} — the actual event logs (spans.jsonl), scores (cached-result.json), and artifacts, not a summary.${durable ? "" : " (WARNING: this run root does not exist on disk — it looks like an in-memory run; pass a real runDir to improve() to get raw-trace context.)"}`,
+			recommended_action: `Do NOT rely on a pre-summarized finding. Before editing, DIAGNOSE from the raw traces: run \`grep\`/\`cat\`/\`ls\` over the trace files and directories named in the following findings to see exactly what each failing run did and why it scored low, then make the smallest harness-code edit that fixes the dominant failure. Start with \`grep -rIn "error" ${genRoot}\` then \`cat\` the spans.jsonl of the worst cell.`,
+			evidence_refs: [{
+				kind: "artifact",
+				uri: genRoot
+			}],
+			metadata: {
+				generation: input.generation,
+				runDir: genRoot,
+				failingCells: totalFailingCells,
+				candidates: ranked.length
+			}
+		}));
+		for (const cand of ranked) {
+			if (cand.cells.length === 0) continue;
+			const scenarioList = cand.cells.map((c) => c.scenarioId).join(", ");
+			const fileLines = cand.cells.map((c) => {
+				const header = `  cell ${c.scenarioId} (composite ${c.composite.toFixed(3)}${c.error ? `, error: ${truncate(c.error, 160)}` : ""}) — dir ${c.cellDir}`;
+				const files = c.files.map((f) => `    - ${f}`).join("\n");
+				const more = c.truncatedFiles ? `\n    - …(ls ${c.cellDir} for the rest)` : "";
+				return c.files.length > 0 ? `${header}\n${files}${more}` : header;
+			}).join("\n");
+			findings.push(makeFinding({
+				analyst_id: ANALYST_ID,
+				severity: cand.composite !== null && cand.composite < .5 ? "critical" : "high",
+				area: "raw-trace-context",
+				confidence: 1,
+				subject: cand.surfaceHash,
+				claim: `Candidate ${cand.surfaceHash} ${candidateCompositeDescription(cand.composite)} with ${cand.cells.length} failing cell(s) [${scenarioList}]. Its raw traces are under ${cand.campaignDir}.`,
+				recommended_action: `grep/cat these raw trace files to diagnose WHY this candidate failed before editing:\n${fileLines}\nOr scan the whole candidate at once: \`grep -rIn . ${cand.campaignDir}\` and \`ls -R ${cand.campaignDir}\`.`,
+				evidence_refs: [{
+					kind: "artifact",
+					uri: cand.campaignDir
+				}, ...cand.cells.flatMap((c) => c.files.map((f) => ({
+					kind: "artifact",
+					uri: f
+				})))],
+				metadata: {
+					surfaceHash: cand.surfaceHash,
+					composite: cand.composite,
+					campaignDir: cand.campaignDir,
+					cells: cand.cells.map((c) => ({
+						scenarioId: c.scenarioId,
+						composite: c.composite,
+						cellDir: c.cellDir,
+						files: c.files,
+						...c.error ? { error: c.error } : {}
+					}))
+				}
+			}));
+		}
+		return findings;
+	};
+}
+/** Keep unscored candidates visible without inventing a numeric aggregate. */
+function compareCandidateComposites(left, right) {
+	if (left === null) return right === null ? 0 : 1;
+	if (right === null) return -1;
+	return left - right;
+}
+function candidateCompositeDescription(composite) {
+	return composite === null ? "has no aggregate score" : `scored composite ${composite.toFixed(3)}`;
+}
+/** The failing cells of a candidate campaign, each with its on-disk trace files.
+*  Mirrors the default distiller's per-cell composite (mean of judge composites,
+*  0 when a cell produced no judge score) and its failing predicate. */
+function failingCells(campaign, maxCells, maxFiles) {
+	const campaignDir = absoluteRunDir(campaign.runDir);
+	const durable = isDurable(campaignDir);
+	const out = [];
+	for (const cell of campaign.cells) {
+		const scores = Object.values(cell.judgeScores ?? {});
+		const composite = scores.length === 0 ? 0 : scores.reduce((sum, s) => sum + (s.composite ?? 0), 0) / scores.length;
+		if (!cell.error && composite >= PASS_THRESHOLD) continue;
+		const cellDir = join(campaignDir, sanitizeCellId(cell.cellId));
+		const artifactPaths = artifactPathsForCell(campaign.artifactsByPath, cell.cellId);
+		const discovered = durable ? listTraceFiles(cellDir) : [];
+		const canonical = [join(cellDir, "spans.jsonl"), join(cellDir, "cached-result.json")];
+		const files = dedupeSorted([
+			...discovered,
+			...artifactPaths,
+			...canonical
+		]);
+		out.push({
+			scenarioId: cell.scenarioId,
+			composite: Number(composite.toFixed(3)),
+			...cell.error ? { error: cell.error } : {},
+			cellDir,
+			files: files.slice(0, maxFiles),
+			truncatedFiles: files.length > maxFiles
+		});
+		if (out.length >= maxCells) break;
+	}
+	return out;
+}
+/** Absolute paths of artifacts the campaign recorded for a cell. `artifactsByPath`
+*  is keyed `${cellId}/${relPath}` → absolute path. */
+function artifactPathsForCell(artifactsByPath, cellId) {
+	if (!artifactsByPath) return [];
+	const prefix = `${cellId}/`;
+	return Object.entries(artifactsByPath).filter(([key]) => key.startsWith(prefix)).map(([, absPath]) => resolve(absPath));
+}
+/** Real files directly under `dir` and one level of sub-directories (artifacts
+*  are sometimes nested). Absolute paths, sorted. `[]` when the dir is absent,
+*  stale, unreadable, or contains symlinked dirs — trace context is advisory and
+*  the canonical anchors below still tell the proposer where to inspect. */
+function listTraceFiles(dir) {
+	const out = [];
+	for (const entry of safeReadDir(dir)) {
+		const full = join(dir, entry.name);
+		if (entry.isFile()) out.push(full);
+		else if (!entry.isSymbolicLink() && entry.isDirectory()) {
+			for (const sub of safeReadDir(full)) if (sub.isFile()) out.push(join(full, sub.name));
+		}
+	}
+	return out;
+}
+function safeReadDir(dir) {
+	try {
+		return readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+/** Substrate cell-dir sanitization — must match agent-eval's
+*  `cellId.replace(/[^a-zA-Z0-9_-]/g, '_')` so the computed dir matches disk. */
+function sanitizeCellId(cellId) {
+	return cellId.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+/** A run root is durable (has real files) when it is not an in-memory sentinel
+*  and exists on disk. `mem://` runs keep everything in-process — no traces. */
+function isDurable(runDir) {
+	return !runDir.startsWith("mem://") && existsSync(runDir);
+}
+/** Resolve a run dir to absolute (the coding harness runs from a worktree cwd, so
+*  relative paths are uncattable there). `mem://` sentinels pass through untouched. */
+function absoluteRunDir(runDir) {
+	return runDir.startsWith("mem://") ? runDir : resolve(runDir);
+}
+function dedupeSorted(paths) {
+	return [...new Set(paths)].sort((a, b) => {
+		const da = a.slice(0, a.length - basename(a).length);
+		const db = b.slice(0, b.length - basename(b).length);
+		return da === db ? basename(a).localeCompare(basename(b)) : da.localeCompare(db);
+	});
+}
+function truncate(s, n) {
+	return s.length <= n ? s : `${s.slice(0, n - 1)}…`;
+}
+//#endregion
+//#region src/improvement/code-execution.ts
+/** Slice bound for distilled judge notes: wide enough that a real traceback or
+* failing assertion survives intact. */
+const distilledNotesMaxChars = 1500;
+/** Slice bound for a cell's error string. Full text remains on the raw cell. */
+const distilledErrorMaxChars = 500;
+/** Distill failing cells into typed findings for the next proposal round. */
+function generationFailureDistiller(staticFindings) {
+	const CAP = 12;
+	return async (input) => {
+		const failures = [];
+		for (const candidate of input.candidates) for (const rawCell of candidate.campaign.cells) {
+			const cell = rawCell;
+			const scenario = String(cell.scenarioId ?? "unknown");
+			const error = typeof cell.error === "string" ? cell.error : void 0;
+			const judgeScores = cell.judgeScores && typeof cell.judgeScores === "object" ? Object.values(cell.judgeScores) : [];
+			const composite = judgeScores.length === 0 ? 0 : judgeScores.reduce((sum, judge) => sum + (judge.composite ?? 0), 0) / judgeScores.length;
+			if (!error && composite >= .999) continue;
+			const notes = judgeScores.map((judge) => judge.notes).filter((note) => typeof note === "string" && note.length > 0).join("; ").slice(0, distilledNotesMaxChars);
+			const claim = notes || (error ? `Scenario ${scenario} failed: ${error.slice(0, distilledErrorMaxChars)}` : "");
+			failures.push({
+				scenario,
+				composite: Number(composite.toFixed(3)),
+				notes,
+				...claim ? { claim } : {},
+				...error ? { error: error.slice(0, distilledErrorMaxChars) } : {}
+			});
+		}
+		if (failures.length === 0) return staticFindings;
+		failures.sort((left, right) => left.composite - right.composite);
+		return failures.slice(0, CAP).map((failure) => makeFinding({
+			analyst_id: "generation-failure-distiller",
+			severity: failure.error !== void 0 || failure.composite < .5 ? "high" : "medium",
+			area: "generation-failure",
+			confidence: 1,
+			subject: failure.scenario,
+			claim: `Scenario ${failure.scenario} scored composite ${failure.composite}${failure.notes ? `: ${failure.notes}` : ""}${failure.error ? ` (error: ${failure.error})` : ""}`,
+			evidence_refs: [],
+			metadata: {
+				scenario: failure.scenario,
+				composite: failure.composite,
+				...failure.notes ? { notes: failure.notes } : {},
+				...failure.error !== void 0 ? { error: failure.error } : {}
+			}
+		}));
+	};
+}
+/** Default code-run analysis: raw trace paths for durable runs, otherwise a
+* bounded digest of failed cells. */
+function defaultDistillerFor(opts, findings) {
+	const durableRun = opts.runDir !== void 0 && !opts.runDir.startsWith("mem://");
+	if (opts.rawTraceContext ?? durableRun) return rawTraceDistiller({ fallbackFindings: findings });
+	return generationFailureDistiller(findings);
+}
+async function discardPreparedBaseline(worktree, baselineWorktree, cause) {
+	return rethrowAfterCleanup(cause, () => worktree.discard(baselineWorktree), "improve(): code preparation failed");
+}
+/** Create a clean incumbent checkout and the candidate producer for a code run. */
+async function prepareCodeRun(code) {
+	const baseRef = code.baseRef ?? "main";
+	const worktree = code.worktree ?? gitWorktreeAdapter({
+		repoRoot: code.repoRoot,
+		...code.worktreeDir ? { worktreeDir: code.worktreeDir } : {}
+	});
+	const baselineWorktree = await worktree.create({
+		baseRef,
+		label: "incumbent-baseline"
+	});
+	try {
+		const baseline = await worktree.finalize(baselineWorktree, "Incumbent code checkout");
+		let baselineDiscarded = false;
+		const managed = improvementDriver({
+			worktree,
+			generator: code.generator ?? agenticGenerator({
+				...code.harness ? { harness: code.harness } : {},
+				...code.verify ? { verify: code.verify } : {},
+				...code.timeoutMs ? { timeoutMs: code.timeoutMs } : {}
+			}),
+			baseRef
+		});
+		return {
+			baseline,
+			proposer: managed,
+			async cleanup(retainedWinner) {
+				const errors = [];
+				const retainedWorktreeRef = isCodeSurface(retainedWinner) ? retainedWinner.worktreeRef : void 0;
+				try {
+					await managed?.cleanup(retainedWorktreeRef ? [retainedWorktreeRef] : []);
+				} catch (cause) {
+					errors.push(cause);
+				}
+				if (!baselineDiscarded && retainedWorktreeRef !== baseline.worktreeRef) try {
+					await worktree.discard(baselineWorktree);
+					baselineDiscarded = true;
+				} catch (cause) {
+					errors.push(cause);
+				}
+				if (errors.length > 0) throw new AggregateError(errors, "improve(): failed to clean code improvement worktrees");
+			}
+		};
+	} catch (cause) {
+		return discardPreparedBaseline(worktree, baselineWorktree, cause);
+	}
+}
+function idempotentDispose(dispose) {
+	let disposed = false;
+	let inFlight;
+	return async () => {
+		if (disposed) return;
+		if (inFlight) return inFlight;
+		inFlight = (async () => {
+			await dispose();
+			disposed = true;
+		})();
+		try {
+			await inFlight;
+		} finally {
+			inFlight = void 0;
+		}
+	};
+}
+async function runCodeImprovement(opts) {
+	const { gate = "holdout", findings: inputFindings = [], rawTraceContext: _rawTraceContext, code, promotionGate, analyzeGeneration, surface: _surface, ...sharedOptions } = opts;
+	const findings = [...inputFindings];
+	const preparedCode = await prepareCodeRun(code);
+	const budget = gate === "none" ? {
+		...sharedOptions.budget,
+		generations: 0
+	} : { ...sharedOptions.budget };
+	let raw;
+	try {
+		raw = await selfImprove({
+			...sharedOptions,
+			baselineSurface: preparedCode.baseline,
+			proposer: preparedCode.proposer,
+			budget,
+			findings,
+			...promotionGate !== void 0 ? { gate: promotionGate } : {},
+			...analyzeGeneration === null ? {} : { analyzeGeneration: analyzeGeneration ?? defaultDistillerFor(opts, findings) }
+		});
+	} catch (cause) {
+		return rethrowAfterCleanup(cause, () => preparedCode.cleanup(), "improve(): code improvement failed");
+	}
+	const winnerSurface = raw.winner.surface;
+	assertCandidateSurfaceKind("code", preparedCode.baseline, winnerSurface);
+	try {
+		await preparedCode.cleanup(winnerSurface);
+	} catch (cleanupCause) {
+		try {
+			await preparedCode.cleanup();
+		} catch (finalCleanupCause) {
+			throw new AggregateError([cleanupCause, finalCleanupCause], "improve(): code result cleanup failed, including the final all-worktree retry");
+		}
+		throw new AggregateError([cleanupCause], "improve(): code result cleanup failed; the final all-worktree retry succeeded");
+	}
+	const dispose = idempotentDispose(async () => preparedCode.cleanup());
+	return {
+		mode: "code",
+		candidate: immutableCandidateValue({
+			surface: "code",
+			value: winnerSurface
+		}),
+		decision: raw.gateDecision,
+		...raw.lift !== void 0 ? { lift: raw.lift } : {},
+		cost: copyImproveCost(raw.cost),
+		durationMs: raw.durationMs,
+		lineage: Object.freeze({
+			invocationId: raw.provenance.runId,
+			runId: raw.provenance.runId,
+			developmentSplitDigest: raw.provenance.evidence.search.splitDigest
+		}),
+		generationsExplored: raw.generationsExplored,
+		raw,
+		dispose
+	};
+}
+//#endregion
+//#region src/improvement/method-controls.ts
+const methodRuntimeControls = Symbol("agent-runtime.improvement.method-runtime-controls");
+function withMethodRuntimeControls(method, controls) {
+	return Object.freeze({
+		...method,
+		[methodRuntimeControls]: Object.freeze({ ...controls })
+	});
+}
+function methodRuntimeControlsOf(method) {
+	return method[methodRuntimeControls];
+}
+//#endregion
+//#region src/improvement/method-cost.ts
+const EVALUATION_TAG = "runtimeEvaluationRef";
+const INVOCATION_TAG = "runtimeInvocationId";
+function methodInputWithScopedCost(input, scope, costAttribution = "invocation") {
+	return Object.freeze({
+		...input,
+		costLedger: scopedCostLedger(input.costLedger, scope, costAttribution)
+	});
+}
+function methodInvocationCostLedger(ledger, scope) {
+	return scopedCostLedger(ledger, scope, "invocation");
+}
+function assertMethodCostRecorded(methodName, result, compatibleLedger, invocationLedger, costCeiling, costAttribution = "invocation") {
+	const { cost } = result;
+	const observed = costAttribution === "optimizer-run" && result.provenance?.runId ? compatibleLedger.summary({ tags: { optimizerRun: result.provenance.runId } }) : invocationLedger.summary();
+	if (costCeiling !== void 0 && !cost.accountingComplete) throw new ConfigError(`improve(): method '${methodName}' returned incomplete cost accounting under costCeiling; refusing final scoring`);
+	if (costCeiling !== void 0 && exceeds(cost.totalCostUsd, costCeiling)) throw new ConfigError(`improve(): method '${methodName}' reported cost $${cost.totalCostUsd} above costCeiling $${costCeiling}; refusing final scoring`);
+	if (cost.accountingComplete && !observed.accountingComplete) throw new ConfigError(`improve(): method '${methodName}' reported complete cost accounting but its shared cost receipts are incomplete`);
+	if (cost.accountingComplete && !approximatelyEqual$1(cost.totalCostUsd, observed.totalCostUsd)) throw new ConfigError(`improve(): method '${methodName}' reported $${cost.totalCostUsd} but recorded $${observed.totalCostUsd} through input.costLedger`);
+}
+function scopedCostLedger(parent, scope, costAttribution) {
+	const evaluationTags = { [EVALUATION_TAG]: scope.evaluationRef };
+	const invocationTags = {
+		...evaluationTags,
+		[INVOCATION_TAG]: scope.invocationId
+	};
+	const readTags = (filter) => costAttribution === "optimizer-run" && hasOptimizerRunFilter(filter) ? evaluationTags : invocationTags;
+	return {
+		costCeilingUsd: parent.costCeilingUsd,
+		runPaidCall: (input) => parent.runPaidCall({
+			...input,
+			tags: {
+				...input.tags ?? {},
+				...invocationTags
+			}
+		}),
+		reconcile: (...args) => parent.reconcile(...args),
+		list: (filter) => parent.list(withTags(filter, readTags(filter))),
+		listPending: (filter) => parent.listPending?.(withTags(filter, readTags(filter))) ?? [],
+		summary: (filter) => parent.summary(withTags(filter, readTags(filter))),
+		waitForIdle: (options = {}) => parent.waitForIdle?.({
+			...options,
+			filter: withTags(options.filter, readTags(options.filter))
+		}) ?? Promise.resolve(parent.summary(withTags(options.filter, readTags(options.filter))).pendingCalls === 0),
+		markCompleted: (count) => parent.markCompleted(count),
+		costPerCompletedTask: () => parent.costPerCompletedTask()
+	};
+}
+function hasOptimizerRunFilter(filter) {
+	return typeof filter?.tags?.optimizerRun === "string" && filter.tags.optimizerRun.length > 0;
+}
+function withTags(filter, tags) {
+	return {
+		...filter ?? {},
+		tags: {
+			...filter?.tags ?? {},
+			...tags
+		}
+	};
+}
+function approximatelyEqual$1(left, right) {
+	const tolerance = Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right)) * 8;
+	return Math.abs(left - right) <= tolerance;
+}
+function exceeds(value, limit) {
+	const tolerance = Number.EPSILON * Math.max(1, Math.abs(value), Math.abs(limit)) * 8;
+	return value - limit > tolerance;
+}
+//#endregion
+//#region src/improvement/method-identity.ts
+function buildMethodEvaluationIdentity(input) {
+	const optimizationReps = input.optimizationRunOptions?.reps ?? 1;
+	const developmentSplitDigest = canonicalCandidateDigest$1({
+		train: campaignSplitDigest(input.trainScenarios, optimizationReps),
+		selection: campaignSplitDigest(input.selectionScenarios, optimizationReps)
+	});
+	const judgeDescriptors = input.judges.map(judgeDescriptor);
+	return {
+		evaluationRef: canonicalCandidateDigest$1({
+			executionRef: input.executionRef,
+			baselineProfileDigest: input.baselineProfileDigest,
+			coordinate: profileCoordinate(input.surface, input.baselineSurface, input.skills),
+			candidateValidation: input.validateCandidate ? Function.prototype.toString.call(input.validateCandidate) : null,
+			developmentSplitDigest,
+			findings: input.findings,
+			judges: judgeDescriptors,
+			run: {
+				seed: input.seed ?? 42,
+				finalReps: input.reps ?? 1,
+				optimizationReps,
+				costCeiling: input.costCeiling ?? null,
+				resumable: input.optimizationRunOptions?.resumable ?? true,
+				maxConcurrency: input.optimizationRunOptions?.maxConcurrency ?? 2,
+				abortOnCellError: input.optimizationRunOptions?.abortOnCellError ?? false,
+				dispatchTimeoutMs: input.optimizationRunOptions?.dispatchTimeoutMs ?? null,
+				dispatchShutdownTimeoutMs: input.optimizationRunOptions?.dispatchShutdownTimeoutMs ?? 5e3,
+				tracing: input.optimizationRunOptions?.tracing ?? "on",
+				expectUsage: input.optimizationRunOptions?.expectUsage ?? "warn",
+				captureSource: input.optimizationRunOptions?.captureSource ?? null,
+				captureSourceVersionHash: input.optimizationRunOptions?.captureSourceVersionHash ?? null
+			}
+		}),
+		developmentSplitDigest,
+		judgeDescriptors
+	};
+}
+function profileCoordinate(surface, baselineSurface, skills) {
+	return {
+		surface,
+		resourceName: surface === "skills" ? skills?.resourceName.trim() ?? null : null,
+		componentNames: typeof baselineSurface === "object" && baselineSurface !== null && baselineSurface.kind === "components" ? Object.keys(baselineSurface.components).sort() : []
+	};
+}
+function judgeDescriptor(judge) {
+	return {
+		name: judge.name,
+		dimensions: judge.dimensions.map((dimension) => ({ ...dimension })),
+		declaredVersion: judge.judgeVersion ?? null,
+		scoreImplementation: Function.prototype.toString.call(judge.score),
+		appliesToImplementation: judge.appliesTo ? Function.prototype.toString.call(judge.appliesTo) : null
+	};
+}
+//#endregion
+//#region src/improvement/method-execution.ts
+function resolveOptimizationMethod(source, context) {
+	const method = typeof source === "function" ? source(context) : source;
+	if (!method || typeof method !== "object" || typeof method.name !== "string" || method.name.trim() !== method.name || method.name.length === 0 || typeof method.optimize !== "function") throw new ConfigError("improve(): method must be a complete OptimizationMethod with a trimmed name and optimize(input)");
+	return method;
+}
+function copyProvenance(provenance) {
+	return immutableCandidateValue(provenance);
+}
+function validateExecutionRef(value) {
+	const parsed = sha256DigestSchema.safeParse(value);
+	if (!parsed.success) throw new ConfigError("improve(): executionRef must be a lowercase sha256:<64 hex> digest");
+	return parsed.data;
+}
+async function runMethodImprovement(profile, opts) {
+	const { surface = "prompt", executionRef: inputExecutionRef, method: methodSource, agent, validateCandidate, findings: inputFindings = [], skills, profileComponents, optimizationRunOptions, minimumLift = 0, ...comparisonOptions } = opts;
+	if (!Number.isFinite(minimumLift) || minimumLift < 0) throw new ConfigError("improve(): minimumLift must be a finite number greater than or equal to 0");
+	if (profileComponents && surface !== "agent-profile") throw new ConfigError("improve(): profileComponents is valid only with surface 'agent-profile'");
+	const executionRef = validateExecutionRef(inputExecutionRef);
+	const findings = [...inputFindings];
+	const preparedSurface = prepareProfileSurface(profile, surface, skills, profileComponents);
+	const baselineSurface = preparedSurface.surface;
+	const baselineValue = immutableCandidateValue(preparedSurface.value);
+	const baselineProfileDigest = canonicalCandidateDigest$1(profile);
+	const identity = buildMethodEvaluationIdentity({
+		executionRef,
+		baselineProfileDigest,
+		baselineSurface,
+		surface,
+		skills,
+		validateCandidate,
+		findings,
+		trainScenarios: comparisonOptions.trainScenarios,
+		selectionScenarios: comparisonOptions.selectionScenarios,
+		judges: comparisonOptions.judges,
+		seed: comparisonOptions.seed,
+		reps: comparisonOptions.reps,
+		costCeiling: comparisonOptions.costCeiling,
+		optimizationRunOptions
+	});
+	const { evaluationRef, developmentSplitDigest } = identity;
+	const dispatchRef = `improve:${evaluationRef}`;
+	const identifiedJudges = comparisonOptions.judges.map((judge, index) => Object.freeze({
+		...judge,
+		judgeVersion: canonicalCandidateDigest$1({
+			evaluationRef,
+			descriptor: identity.judgeDescriptors[index]
+		})
+	}));
+	const rawMaterializeProfile = createProfileCandidateMaterializer(profile, surface, baselineSurface, skills, profileComponents);
+	const runtimeInvocationId = `runtime-optimization:${randomUUID()}`;
+	const method = resolveOptimizationMethod(methodSource, {
+		profile,
+		evaluationRef,
+		surface,
+		baselineSurface,
+		baselineValue,
+		findings
+	});
+	const methodControls = methodRuntimeControlsOf(method);
+	const baselineSurfaceDigest = canonicalCandidateDigest$1(baselineSurface);
+	const validatedCandidates = /* @__PURE__ */ new Set();
+	const materializeProfile = (candidateSurface) => {
+		const candidate = rawMaterializeProfile(candidateSurface);
+		const candidateDigest = canonicalCandidateDigest$1(candidateSurface);
+		if (!validatedCandidates.has(candidateDigest)) {
+			const prepared = prepareProfileSurface(candidate, surface, skills, profileComponents);
+			const validationInput = Object.freeze({
+				profile: candidate,
+				surface,
+				candidateSurface: immutableCandidateValue(candidateSurface),
+				value: immutableCandidateValue(prepared.value),
+				isBaseline: candidateDigest === baselineSurfaceDigest
+			});
+			methodControls?.validateCandidate(validationInput);
+			validateCandidate?.(validationInput);
+			validatedCandidates.add(candidateDigest);
+		}
+		return candidate;
+	};
+	materializeProfile(baselineSurface);
+	const measuredMethod = {
+		...method,
+		async optimize(input) {
+			const costScope = {
+				evaluationRef,
+				invocationId: runtimeInvocationId
+			};
+			const scopedInput = methodInputWithScopedCost(input, costScope, methodControls?.costAttribution);
+			const invocationLedger = methodInvocationCostLedger(input.costLedger, costScope);
+			const result = await method.optimize(scopedInput);
+			assertMethodCostRecorded(method.name, result, scopedInput.costLedger, invocationLedger, comparisonOptions.costCeiling, methodControls?.costAttribution);
+			materializeProfile(result.winnerSurface);
+			return result;
+		}
+	};
+	const startedAt = Date.now();
+	const raw = await compareOptimizationMethods({
+		...comparisonOptions,
+		judges: identifiedJudges,
+		dispatchRef,
+		optimizationRunOptions: {
+			...optimizationRunOptions ?? {},
+			dispatchRef
+		},
+		methods: [measuredMethod],
+		baselineSurface,
+		dispatchWithSurface: (candidateSurface, scenario, ctx) => agent(materializeProfile(candidateSurface), scenario, ctx)
+	});
+	if (comparisonOptions.costCeiling !== void 0 && raw.totalCost.totalCostUsd > comparisonOptions.costCeiling) throw new ConfigError(`improve(): reported total cost $${raw.totalCost.totalCostUsd} exceeds costCeiling $${comparisonOptions.costCeiling}`);
+	const score = raw.best;
+	const winnerSurface = immutableCandidateValue(score.winnerSurface);
+	assertCandidateSurfaceKind(surface, baselineSurface, winnerSurface);
+	const candidateProfile = materializeProfile(winnerSurface);
+	const candidate = Object.freeze({
+		surface,
+		value: winnerSurface,
+		profile: candidateProfile
+	});
+	const cost = copyImproveCost(raw.totalCost);
+	return {
+		mode: "method",
+		method: method.name,
+		...score.provenance ? { provenance: copyProvenance(score.provenance) } : {},
+		candidate,
+		decision: cost.accountingComplete && score.liftCi.low > minimumLift ? "ship" : "hold",
+		lift: score.lift,
+		liftInterval: { ...score.liftCi },
+		cost,
+		durationMs: Date.now() - startedAt,
+		lineage: Object.freeze({
+			invocationId: runtimeInvocationId,
+			runId: score.provenance?.runId ?? runtimeInvocationId,
+			developmentSplitDigest,
+			executionRef,
+			baselineProfileDigest
+		}),
+		raw,
+		async dispose() {}
+	};
+}
+//#endregion
+//#region src/improvement/improve.ts
+async function improve(profileOrCode, opts) {
+	if (opts === void 0) {
+		const code = profileOrCode;
+		if (code?.surface !== "code") throw new ConfigError("improve(): the one-argument form requires { surface: 'code', ... }");
+		return runCodeImprovement(code);
+	}
+	if (opts.surface === "code") throw new ConfigError("improve(): code takes one argument: improve({ surface: 'code', ... })");
+	const parsedProfile = agentProfileSchema.safeParse(profileOrCode);
+	if (!parsedProfile.success) throw new ConfigError(`improve(): input is not a valid AgentProfile: ${parsedProfile.error.message}`);
+	return runMethodImprovement(immutableCandidateValue(parsedProfile.data), opts);
+}
+//#endregion
+//#region src/intelligence/improvement-surfaces.ts
+const changedSurfaceOrder = [
+	"prompt",
+	"skills",
+	"tools",
+	"mcp",
+	"hooks",
+	"subagents",
+	"agent-profile",
+	"memory",
+	"code",
+	"knowledge"
+];
+/** Agent improvement surfaces delivered as exact `AgentProfileDiff` replacements. */
+const AGENT_IMPROVEMENT_PROFILE_SURFACES = [
+	"prompt",
+	"skills",
+	"tools",
+	"mcp",
+	"hooks",
+	"subagents"
+];
+function deriveChangedSurfaces(baselineBundle, candidateBundle) {
+	if (baselineBundle.knowledge || candidateBundle.knowledge) assertKnowledgeCandidatePair(baselineBundle, candidateBundle);
+	assertCodeCandidatePair(baselineBundle, candidateBundle);
+	const baseline = improvementSurfaceValues(baselineBundle);
+	const candidate = improvementSurfaceValues(candidateBundle);
+	const changed = changedSurfaceOrder.filter((surface) => canonicalCandidateDigest$1(baseline[surface]) !== canonicalCandidateDigest$1(candidate[surface]));
+	if (changed.length === 0) throw new Error("candidate experiment does not change an agent surface");
+	return changed;
+}
+function assertAgentImprovementActivationTargets(surfaces, experiment, intent, targets) {
+	if (isProfileImprovementExperiment(experiment)) assertProfileImprovementTargetsShareIdentity(targets);
+	const expected = new Set(surfaces);
+	const actual = new Set(targets.map((target) => target.surface));
+	const sourceArm = intent === "activate-candidate" ? "baseline" : "candidate";
+	if (!(isProfileImprovementExperiment(experiment) ? sameAgentImprovementSurfaceSet(surfaces, activationExperimentChangedSurfaces(experiment)) : sameOrderedSurfaces(surfaces, activationExperimentChangedSurfaces(experiment))) || targets.some((target) => !target.identity.trim()) || targets.some((target) => target.expectedBaseDigest !== activationTargetDigest(experiment, sourceArm, target.surface)) || targets.length !== surfaces.length || expected.size !== actual.size || [...expected].some((surface) => !actual.has(surface))) throw new Error("agent improvement activation targets must cover exactly the changed surfaces");
+}
+/** One opaque profile-state transition can change only one complete profile record. */
+function assertProfileImprovementTargetsShareIdentity(targets) {
+	if (new Set(targets.map((target) => target.identity)).size !== 1) throw new Error("profile improvement activation targets must name one profile identity");
+}
+/** Bind caller-owned target identities to the exact source state Runtime measured. */
+function buildAgentImprovementActivationTargets(surfaces, experiment, intent, identities) {
+	const sourceArm = intent === "activate-candidate" ? "baseline" : "candidate";
+	const targets = identities.map((target) => ({
+		...target,
+		expectedBaseDigest: activationTargetDigest(experiment, sourceArm, target.surface)
+	}));
+	assertAgentImprovementActivationTargets(surfaces, experiment, intent, targets);
+	return targets;
+}
+/** Exact host-owned profile state for every changed profile surface. */
+function agentProfileImprovementStateDigest(experiment, arm) {
+	return experiment[arm].stateDigest;
+}
+/** Map Interface's current profile-improvement contract to Runtime-deliverable surfaces. */
+function profileImprovementChangedSurfaces(change) {
+	const surfaces = changedProfileImprovementSurfaces(change);
+	if (surfaces.length === 0 || !surfaces.every((surface) => surface === "prompt" || surface === "skills")) throw new Error("profile improvement experiment does not change a supported surface");
+	return surfaces;
+}
+function agentImprovementTargetDigest(experiment, arm, surface) {
+	if (surface === "knowledge") {
+		const knowledge = assertKnowledgeCandidatePair(experiment.baseline, experiment.candidate);
+		return arm === "baseline" ? knowledge.candidate.baseHash : knowledge.candidate.candidateHash;
+	}
+	if (surface === "code") assertCodeCandidatePair(experiment.baseline, experiment.candidate);
+	return canonicalCandidateDigest$1(improvementSurfaceValues(experiment[arm])[surface]);
+}
+function agentImprovementTargetInput(bundle, surface) {
+	return improvementSurfaceValues(bundle)[surface];
+}
+function activationTargetDigest(experiment, arm, surface) {
+	if (isProfileImprovementExperiment(experiment)) {
+		if (!activationExperimentChangedSurfaces(experiment).includes(surface)) throw new Error("profile improvement activation targets an unchanged surface");
+		return agentProfileImprovementStateDigest(experiment, arm);
+	}
+	return agentImprovementTargetDigest(experiment, arm, surface);
+}
+function activationExperimentChangedSurfaces(experiment) {
+	if (!isProfileImprovementExperiment(experiment)) return deriveChangedSurfaces(experiment.baseline, experiment.candidate);
+	return profileImprovementChangedSurfaces(experiment.change);
+}
+function isProfileImprovementExperiment(experiment) {
+	return experiment.kind === "agent-profile-improvement-experiment";
+}
+function sameOrderedSurfaces(left, right) {
+	return left.length === right.length && left.every((surface, index) => surface === right[index]);
+}
+/** Profile-change surface order is presentation only; its measured contract is set-based. */
+function sameAgentImprovementSurfaceSet(left, right) {
+	return left.length === right.length && left.every((surface) => right.includes(surface));
+}
+/** Return whether a measured surface can be delivered through an agent profile. */
+function isAgentImprovementProfileSurface(surface) {
+	return AGENT_IMPROVEMENT_PROFILE_SURFACES.includes(surface);
+}
+/**
+* Return the canonical current-state input for one profile-deliverable improvement target.
+* Missing slots become `null`; tools and subagents include both their direct and resource slots.
+* Unrelated profile fields are excluded. The result matches `agentImprovementTargetInput` for the
+* same profile inside a candidate bundle.
+*/
+function agentImprovementProfileSurfaceInput(profile, surface) {
+	return immutableCandidateValue(profileSurfaceInput(parseExactAgentProfile(omitUndefinedObjectFields(profile, "agent improvement profile"), "agent improvement profile"), surface));
+}
+function profileSurfaceInput(profile, surface) {
+	switch (surface) {
+		case "prompt": return { prompt: profile.prompt ?? null };
+		case "skills": return profile.resources?.skills ?? null;
+		case "tools": return {
+			tools: profile.tools ?? null,
+			resources: profile.resources?.tools ?? null
+		};
+		case "mcp": return profile.mcp ?? null;
+		case "hooks": return profile.hooks ?? null;
+		case "subagents": return {
+			subagents: profile.subagents ?? null,
+			resources: profile.resources?.agents ?? null
+		};
+	}
+}
+/** Return the `Sha256Digest` of one profile surface using Runtime's canonical candidate digest. */
+function agentImprovementProfileSurfaceDigest(profile, surface) {
+	return canonicalCandidateDigest$1(agentImprovementProfileSurfaceInput(profile, surface));
+}
+/**
+* Replace one measured profile surface exactly, including array-valued resources.
+* Apply the returned diffs in order: a diff applies its set before its removal,
+* so exact replacement requires a reset record followed by a set record.
+*/
+function agentImprovementTargetProfileDiffs(target, options) {
+	const { remove, set } = improvementSurfaceReplacement(target);
+	const common = {
+		kind: "agent-profile-diff",
+		...options.source ? { source: options.source } : {},
+		metadata: {
+			...options.metadata ?? {},
+			surface: target.surface
+		}
+	};
+	const reset = agentProfileDiffSchema.parse(defineAgentProfileDiff({
+		...common,
+		id: `${options.id}:${target.surface}:reset`,
+		title: `Replace active ${target.surface}`,
+		remove
+	}));
+	if (!set) return [reset];
+	return [reset, agentProfileDiffSchema.parse(defineAgentProfileDiff({
+		...common,
+		id: `${options.id}:${target.surface}:set`,
+		title: `Activate measured ${target.surface}`,
+		set
+	}))];
+}
+function improvementSurfaceReplacement(target) {
+	const value = target.desiredInput;
+	switch (target.surface) {
+		case "prompt": {
+			const prompt = exactObject(value, ["prompt"], "prompt activation input").prompt;
+			assertDefined(prompt, "prompt activation input.prompt");
+			return {
+				remove: { prompt: true },
+				...prompt === null ? {} : { set: parseProfileSet({ prompt }) }
+			};
+		}
+		case "skills":
+			assertDefined(value, "skills activation input");
+			return {
+				remove: { resources: { skills: true } },
+				...value === null ? {} : { set: parseProfileSet({ resources: { skills: value } }) }
+			};
+		case "tools": {
+			const parsed = exactObject(value, ["tools", "resources"], "tools activation input");
+			assertDefined(parsed.tools, "tools activation input.tools");
+			assertDefined(parsed.resources, "tools activation input.resources");
+			const set = {
+				...parsed.tools === null ? {} : { tools: parsed.tools },
+				...parsed.resources === null ? {} : { resources: { tools: parsed.resources } }
+			};
+			return {
+				remove: {
+					tools: true,
+					resources: { tools: true }
+				},
+				...Object.keys(set).length === 0 ? {} : { set: parseProfileSet(set) }
+			};
+		}
+		case "mcp":
+			assertDefined(value, "mcp activation input");
+			return {
+				remove: { mcp: true },
+				...value === null ? {} : { set: parseProfileSet({ mcp: value }) }
+			};
+		case "hooks":
+			assertDefined(value, "hooks activation input");
+			return {
+				remove: { hooks: true },
+				...value === null ? {} : { set: parseProfileSet({ hooks: value }) }
+			};
+		case "subagents": {
+			const parsed = exactObject(value, ["subagents", "resources"], "subagents activation input");
+			assertDefined(parsed.subagents, "subagents activation input.subagents");
+			assertDefined(parsed.resources, "subagents activation input.resources");
+			const set = {
+				...parsed.subagents === null ? {} : { subagents: parsed.subagents },
+				...parsed.resources === null ? {} : { resources: { agents: parsed.resources } }
+			};
+			return {
+				remove: {
+					subagents: true,
+					resources: { agents: true }
+				},
+				...Object.keys(set).length === 0 ? {} : { set: parseProfileSet(set) }
+			};
+		}
+	}
+}
+function assertDefined(value, label) {
+	if (value === void 0) throw new Error(`${label} must not be undefined`);
+}
+function exactObject(value, keys, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+	const record = value;
+	const actual = Object.keys(record).sort();
+	const expected = [...keys].sort();
+	if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) throw new Error(`${label} must contain exactly: ${expected.join(", ")}`);
+	return record;
+}
+function parseProfileSet(value) {
+	return agentProfileSchema.parse(value);
+}
+function assertKnowledgeCandidatePair(baselineBundle, candidateBundle) {
+	const baseline = baselineBundle.knowledge;
+	const candidate = candidateBundle.knowledge;
+	if (!baseline && !candidate) throw new Error("knowledge candidate pair is not present");
+	if (!baseline || !candidate || canonicalCandidateDigest$1({
+		candidate: baseline.candidate,
+		evaluation: baseline.evaluation
+	}) !== canonicalCandidateDigest$1({
+		candidate: candidate.candidate,
+		evaluation: candidate.evaluation
+	})) throw new Error("knowledge experiment arms must share one measured candidate and evaluation identity");
+	return candidate;
+}
+function assertCodeCandidatePair(baselineBundle, candidateBundle) {
+	const baseline = baselineBundle.code;
+	const candidate = candidateBundle.code;
+	if (canonicalCandidateDigest$1(baseline) === canonicalCandidateDigest$1(candidate) || candidate.kind !== "git-patch") return;
+	const baselineTree = baseline.kind === "no-op" ? baseline.baseTree : baseline.kind === "git-patch" ? baseline.candidateTree : void 0;
+	const baselineRepository = baseline.kind === "disabled" ? void 0 : baseline.repository;
+	if (baselineTree !== candidate.baseTree || !baselineRepository || canonicalCandidateDigest$1(baselineRepository) !== canonicalCandidateDigest$1(candidate.repository)) throw new Error("code candidate must be based on the exact repository tree measured by the baseline arm");
+}
+function improvementSurfaceValues(bundle) {
+	const profile = agentCandidateProfileAsAgentProfile(bundle.profile);
+	return {
+		prompt: agentImprovementProfileSurfaceInput(profile, "prompt"),
+		skills: agentImprovementProfileSurfaceInput(profile, "skills"),
+		tools: agentImprovementProfileSurfaceInput(profile, "tools"),
+		mcp: agentImprovementProfileSurfaceInput(profile, "mcp"),
+		hooks: agentImprovementProfileSurfaceInput(profile, "hooks"),
+		subagents: agentImprovementProfileSurfaceInput(profile, "subagents"),
+		"agent-profile": {
+			profile: opaqueProfileSlice(profile),
+			execution: bundle.execution
+		},
+		memory: {
+			instructions: profile.resources?.instructions ?? null,
+			executionPolicy: bundle.memory
+		},
+		code: bundle.code,
+		knowledge: bundle.knowledge ?? null
+	};
+}
+function opaqueProfileSlice(profile) {
+	const { prompt: _prompt, tools: _tools, mcp: _mcp, hooks: _hooks, subagents: _subagents, resources, ...opaqueProfile } = profile;
+	const { instructions: _instructions, skills: _skills, tools: _resourceTools, agents: _agents, ...opaqueResources } = resources ?? {};
+	return {
+		...opaqueProfile,
+		...Object.keys(opaqueResources).length > 0 ? { resources: opaqueResources } : {}
+	};
+}
+//#endregion
+//#region src/intelligence/optimization-receipt.ts
+const optimizationReceiptMetadataKey = "optimizationReceipt";
+/** Build a detached receipt only for methods backed by an identified external optimizer. */
+function createOptimizationActivationReceipt(improvement) {
+	const provenance = improvement.provenance;
+	if (!provenance) return void 0;
+	const optimizerModel = provenance.optimizerModel;
+	const candidateModel = improvement.candidate.profile.model;
+	return canonicalCandidateDocument({
+		kind: "optimization-activation-receipt",
+		method: improvement.method,
+		source: provenance.source,
+		...provenance.bridge ? { bridge: provenance.bridge } : {},
+		...provenance.modules ? { modules: provenance.modules } : {},
+		...provenance.python ? { python: provenance.python } : {},
+		...candidateModel || optimizerModel ? { models: {
+			...candidateModel ? { candidate: candidateModel } : {},
+			...optimizerModel ? { optimizer: optimizerModel } : {}
+		} } : {},
+		usage: {
+			optimizerEvaluations: provenance.evaluationCount,
+			...provenance.tokenUsage ? { optimizerTokens: provenance.tokenUsage } : {}
+		},
+		cost: {
+			optimization: receiptCost(improvement.raw.optimizationCost),
+			finalTest: receiptCost(improvement.raw.testCost),
+			total: receiptCost(improvement.raw.totalCost)
+		},
+		invocation: {
+			runtimeInvocationId: improvement.lineage.invocationId,
+			optimizerRunId: provenance.runId,
+			...provenance.compatibleRunId ? { compatibleOptimizerRunId: provenance.compatibleRunId } : {},
+			resumed: provenance.resumed,
+			artifactDir: provenance.artifactDir
+		},
+		developmentDataDigest: improvement.lineage.developmentSplitDigest
+	}).value;
+}
+/** Add Runtime-owned optimizer evidence without aliasing caller metadata. */
+function attachOptimizationActivationReceipt(metadata, receipt) {
+	assertNoCallerOptimizationReceipt(metadata);
+	return immutableCandidateValue({
+		...metadata ?? {},
+		[optimizationReceiptMetadataKey]: receipt
+	});
+}
+function assertNoCallerOptimizationReceipt(metadata) {
+	if (metadata && Object.hasOwn(metadata, "optimizationReceipt")) throw new Error(`candidate metadata reserves '${optimizationReceiptMetadataKey}' for Runtime`);
+}
+/** Read and verify the optimizer evidence carried by a measured proposal. */
+function optimizationActivationReceiptFromMetadata(metadata) {
+	const value = metadata?.[optimizationReceiptMetadataKey];
+	if (value === void 0) return void 0;
+	return immutableCandidateValue(parseOptimizationActivationReceipt(value));
+}
+function parseOptimizationActivationReceipt(value) {
+	if (!isRecord(value) || value.kind !== "optimization-activation-receipt") throw new Error("optimization receipt must be an optimization-activation-receipt");
+	if (!isNonEmptyString(value.method) || !isPackageSource(value.source) || value.bridge !== void 0 && !isPackageSource(value.bridge) || !isModules(value.modules) || !isPythonRuntime(value.python) || !isModels(value.models) || !isUsage(value.usage) || !isCost(value.cost) || !isInvocation(value.invocation) || !isSha256Digest(value.developmentDataDigest) || !isSha256Digest(value.digest)) throw new Error("optimization receipt contains invalid evidence");
+	const receipt = value;
+	if (canonicalCandidateDigest$1(omitTopLevelDigest(receipt)) !== receipt.digest) throw new Error("optimization receipt digest does not match its evidence");
+	return receipt;
+}
+function isPackageSource(value) {
+	if (!isRecord(value) || value.kind !== "package" || value.evidence !== "observed" && value.evidence !== "declared" || !isNonEmptyString(value.package) || !isNonEmptyString(value.version)) return false;
+	return isOptionalNonEmptyString(value.sourceUrl) && isOptionalNonEmptyString(value.revision) && (value.sourceSha256 === void 0 || typeof value.sourceSha256 === "string" && /^[0-9a-f]{64}$/.test(value.sourceSha256));
+}
+function isModules(value) {
+	return value === void 0 || Array.isArray(value) && value.every((module) => isRecord(module) && isNonEmptyString(module.module) && typeof module.sourceSha256 === "string" && /^[0-9a-f]{64}$/.test(module.sourceSha256));
+}
+function isPythonRuntime(value) {
+	return value === void 0 || isRecord(value) && isNonEmptyString(value.implementation) && isNonEmptyString(value.version);
+}
+function isModels(value) {
+	return value === void 0 || isRecord(value) && (value.candidate === void 0 || agentProfileModelHintsSchema.safeParse(value.candidate).success) && isOptionalNonEmptyString(value.optimizer) && (value.candidate !== void 0 || value.optimizer !== void 0);
+}
+function isUsage(value) {
+	if (!isRecord(value) || !isNonNegativeInteger(value.optimizerEvaluations)) return false;
+	if (value.optimizerTokens === void 0) return true;
+	const tokens = value.optimizerTokens;
+	if (!isRecord(tokens)) return false;
+	const inputTokens = tokens.inputTokens;
+	const outputTokens = tokens.outputTokens;
+	const totalTokens = tokens.totalTokens;
+	const calls = tokens.calls;
+	if (!isNonNegativeInteger(inputTokens) || !isNonNegativeInteger(outputTokens) || !isNonNegativeInteger(totalTokens) || !isNonNegativeInteger(calls)) return false;
+	if (!isOptionalNonNegativeInteger(tokens.cachedInputTokens) || !isOptionalNonNegativeInteger(tokens.cacheWriteInputTokens) || !isOptionalNonNegativeInteger(tokens.reasoningTokens)) return false;
+	const cachedInputTokens = typeof tokens.cachedInputTokens === "number" ? tokens.cachedInputTokens : 0;
+	const cacheWriteInputTokens = typeof tokens.cacheWriteInputTokens === "number" ? tokens.cacheWriteInputTokens : 0;
+	const reasoningTokens = typeof tokens.reasoningTokens === "number" ? tokens.reasoningTokens : 0;
+	return totalTokens === inputTokens + outputTokens && cachedInputTokens + cacheWriteInputTokens <= inputTokens && reasoningTokens <= outputTokens && (totalTokens === 0 || calls > 0);
+}
+function isCost(value) {
+	if (!isRecord(value) || !isCostPart(value.optimization) || !isCostPart(value.finalTest) || !isCostPart(value.total)) return false;
+	const optimization = value.optimization;
+	const finalTest = value.finalTest;
+	const total = value.total;
+	return approximatelyEqual(total.totalUsd, optimization.totalUsd + finalTest.totalUsd) && total.accountingComplete === (optimization.accountingComplete && finalTest.accountingComplete);
+}
+function isCostPart(value) {
+	return isRecord(value) && typeof value.totalUsd === "number" && Number.isFinite(value.totalUsd) && value.totalUsd >= 0 && typeof value.accountingComplete === "boolean" && Array.isArray(value.incompleteReasons) && value.incompleteReasons.every((reason) => typeof reason === "string");
+}
+function receiptCost(value) {
+	return {
+		totalUsd: value.totalCostUsd,
+		accountingComplete: value.accountingComplete,
+		incompleteReasons: [...value.incompleteReasons]
+	};
+}
+function approximatelyEqual(left, right) {
+	const tolerance = Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right)) * 8;
+	return Math.abs(left - right) <= tolerance;
+}
+function isInvocation(value) {
+	return isRecord(value) && isNonEmptyString(value.runtimeInvocationId) && isNonEmptyString(value.optimizerRunId) && isOptionalNonEmptyString(value.compatibleOptimizerRunId) && typeof value.resumed === "boolean" && isNonEmptyString(value.artifactDir);
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isOptionalNonEmptyString(value) {
+	return value === void 0 || isNonEmptyString(value);
+}
+function isNonNegativeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isOptionalNonNegativeInteger(value) {
+	return value === void 0 || isNonNegativeInteger(value);
+}
+function isSha256Digest(value) {
+	return typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value);
+}
+//#endregion
+//#region src/intelligence/improvement-cycle.ts
+/** A failed baseline or candidate cell with its complete Runtime failure result. */
+var AgentCandidateExperimentCellExecutionError = class extends Error {
+	finalization;
+	constructor(finalization) {
+		super(`candidate experiment cell failed: ${finalization.reason}`);
+		this.name = "AgentCandidateExperimentCellExecutionError";
+		this.finalization = finalization;
+	}
+};
+function sealAgentImprovementExperiment(material, improvement) {
+	assertRuntimeOwnedExperimentFieldsAbsent(material);
+	const candidateLineage = {
+		source: "optimizer",
+		parentDigests: [material.baseline.digest],
+		runIds: [improvement.lineage.runId],
+		developmentSplitDigest: improvement.lineage.developmentSplitDigest
+	};
+	return sealCandidateExperiment({
+		...material,
+		candidateLineage
+	});
+}
+function assertRuntimeOwnedExperimentFieldsAbsent(material) {
+	if (material === null || typeof material !== "object" || Array.isArray(material)) throw new Error("agent improvement experiment material must be an object");
+	const supplied = ["candidateLineage", "digest"].filter((field) => Object.hasOwn(material, field));
+	if (supplied.length > 0) throw new Error(`agent improvement experiment material must not supply Runtime-owned fields: ${supplied.join(", ")}`);
+}
+/** Execute both arms of one immutable experiment and derive its paired result. */
+async function runAgentCandidateExperiment(options) {
+	const experiment = verifyCandidateExperiment(options.experiment);
+	const measurements = await runCandidateExperiment({
+		experiment,
+		...options.maxConcurrency === void 0 ? {} : { maxConcurrency: options.maxConcurrency },
+		...options.signal ? { signal: options.signal } : {},
+		execute: async (input) => {
+			const placement = await options.placeCell(input);
+			return await executeAgentCandidateExperimentCell({
+				...input,
+				...placement
+			});
+		}
+	});
+	return {
+		experiment,
+		measurements,
+		evaluation: createAgentImprovementMeasuredComparison({
+			experiment,
+			measurements,
+			runId: options.runId,
+			...options.candidate ? { candidate: options.candidate } : {},
+			...options.generationsExplored === void 0 ? {} : { generationsExplored: options.generationsExplored },
+			...options.searchDurationMs === void 0 ? {} : { searchDurationMs: options.searchDurationMs },
+			...options.searchCostUsd === void 0 ? {} : { searchCostUsd: options.searchCostUsd },
+			...options.metadata ? { metadata: options.metadata } : {}
+		})
+	};
+}
+/** Execute one exact arm, task, repetition, seed, and attempt through Runtime. */
+async function executeAgentCandidateExperimentCell(options) {
+	const experiment = verifyCandidateExperiment(options.experiment);
+	const bundle = experiment[options.arm];
+	assertExactExperimentInput(options, experiment, bundle);
+	const attempt = options.attempt ?? 1;
+	if (attempt > options.task.attempt.maxAttempts) throw new Error("candidate experiment attempt exceeds the signed task policy");
+	const runCell = canonicalCandidateDocument({
+		kind: "agent-candidate-run-cell",
+		experimentDigest: experiment.digest,
+		arm: options.arm,
+		bundleDigest: bundle.digest,
+		suiteDigest: options.benchmarkCell.suiteDigest,
+		taskDigest: options.task.digest,
+		taskIndex: options.benchmarkCell.taskIndex,
+		repetition: options.benchmarkCell.repetition,
+		seed: options.seed,
+		attempt
+	}).value;
+	const verified = await verifyAgentCandidateBundle(bundle, options.ports);
+	const prepared = await prepareAgentCandidateExecution(verified, {
+		executionId: options.executionId,
+		runCell,
+		benchmarkSuite: experiment.benchmark.suite,
+		task: options.task,
+		executionRoots: options.executionRoots,
+		stagingRoots: options.stagingRoots
+	}, options.ports, options.preparation);
+	const finalization = await executePreparedAgentCandidate(prepared, options.execution);
+	if (!finalization.succeeded) throw new AgentCandidateExperimentCellExecutionError(finalization);
+	const evidence = canonicalCandidateDocument({
+		kind: "agent-candidate-execution-evidence",
+		materializationReceipt: prepared.materializationReceipt.value,
+		receipt: finalization.receipt.value
+	}).value;
+	return verifyCandidateExecutionEvidence(evidence, {
+		experiment,
+		arm: options.arm,
+		benchmarkCell: options.benchmarkCell,
+		seed: options.seed,
+		attempt,
+		resolvedResources: verifiedResourceTextByDigest(verified)
+	});
+}
+/** Delegate all statistics and promotion checks to agent-eval's receipt-based comparison. */
+function createAgentImprovementMeasuredComparison(options) {
+	return verifyCandidateExperimentComparison(measuredComparisonFromCandidateExperiment(options));
+}
+/** Analyze, search, then remeasure the resulting exact candidate before proposing it. */
+async function proposeAgentImprovement(options) {
+	assertNoCallerOptimizationReceipt(options.metadata);
+	const analysis = await runAnalystLoop({
+		...options.analysis,
+		runId: options.runId
+	});
+	const findings = assertNoJudgeVerdict(analysis.analystResult.findings, "proposeAgentImprovement findings");
+	const improvementInput = {
+		...options.improvement,
+		findings: [...options.improvement.findings ?? [], ...findings]
+	};
+	const improvement = improvementInput.surface === "code" ? await improve(improvementInput) : await improve(options.profile, improvementInput);
+	try {
+		if (improvement.decision !== "ship") throw new Error("agent improvement search did not produce a promotable candidate");
+		const optimizationReceipt = improvement.mode === "method" ? createOptimizationActivationReceipt(improvement) : void 0;
+		const experiment = sealAgentImprovementExperiment(await options.buildExperiment({
+			analysis,
+			improvement
+		}), improvement);
+		assertCandidateProfileBinding(options.profile, experiment.baseline.profile);
+		assertImprovementCandidateBinding(improvement, experiment);
+		const measured = await runAgentCandidateExperiment({
+			experiment,
+			runId: options.runId,
+			placeCell: options.placeCell,
+			...options.maxConcurrency === void 0 ? {} : { maxConcurrency: options.maxConcurrency },
+			...options.signal ? { signal: options.signal } : {},
+			...options.candidate ? { candidate: options.candidate } : {},
+			...optimizationReceipt ? { metadata: attachOptimizationActivationReceipt(options.metadata, optimizationReceipt) } : options.metadata ? { metadata: options.metadata } : {},
+			...improvement.generationsExplored === void 0 ? {} : { generationsExplored: improvement.generationsExplored },
+			searchDurationMs: improvement.durationMs,
+			searchCostUsd: improvement.cost.totalCostUsd
+		});
+		const proposal = createAgentImprovementProposal({
+			runId: options.runId,
+			findings,
+			evaluation: measured.evaluation,
+			...options.now ? { now: options.now } : {}
+		});
+		return {
+			analysis,
+			improvement,
+			experiment,
+			measurements: measured.measurements,
+			proposal
+		};
+	} catch (cause) {
+		return rethrowAfterCleanup(cause, () => improvement.dispose(), "proposeAgentImprovement failed");
+	}
+}
+function assertImprovementCandidateBinding(improvement, experiment) {
+	const candidate = improvement.candidate;
+	if (candidate.surface !== "code") {
+		try {
+			assertCandidateProfileBinding(candidate.profile, experiment.candidate.profile);
+		} catch (cause) {
+			throw new Error("candidate experiment does not contain the improvement winner", { cause });
+		}
+		return;
+	}
+	const surface = candidate.value;
+	const code = experiment.candidate.code;
+	if (typeof surface !== "object" || surface === null || surface.kind !== "code" || code.kind !== "git-patch" || code.baseCommit !== surface.baseCommit || code.baseTree !== surface.baseTree || code.candidateTree !== surface.candidateTree || code.patch.artifact.sha256 !== surface.patch.sha256 || code.patch.artifact.byteLength !== surface.patch.byteLength) throw new Error("candidate experiment does not contain the improvement winner");
+	if (canonicalCandidateDigest$1(experiment.baseline.profile) !== canonicalCandidateDigest$1(experiment.candidate.profile)) throw new Error("code improvement candidate changed the agent profile");
+}
+/** Create the reviewable record only from a complete, recomputable experiment result. */
+function createAgentImprovementProposal(options) {
+	const findings = assertNoJudgeVerdict([...options.findings], "createAgentImprovementProposal findings");
+	const { evaluation, changedSurfaces } = validateShippableAgentImprovementEvaluation(options.evaluation, options.runId, "agent improvement proposal");
+	return agentImprovementProposalSchema.parse(canonicalCandidateDocument({
+		kind: "agent-improvement-proposal",
+		runId: options.runId,
+		changedSurfaces,
+		proposedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+		findings: [...findings],
+		evaluation
+	}).value);
+}
+/** Persist a human or tenant-policy decision bound to one exact proposal. */
+function reviewAgentImprovementProposal(inputProposal, input) {
+	const proposal = verifyAgentImprovementProposal(inputProposal);
+	if (!input.reviewedBy.trim()) throw new Error("candidate review requires reviewedBy");
+	if (!input.reason.trim()) throw new Error("candidate review requires a reason");
+	if (input.decision === "approve" && proposal.evaluation.decision.outcome !== "ship") throw new Error("candidate cannot be approved without a passing experiment");
+	const reviewedAt = (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+	if (Date.parse(reviewedAt) < Date.parse(proposal.proposedAt)) throw new Error("candidate review cannot predate its proposal");
+	return agentImprovementReviewSchema.parse(canonicalCandidateDocument({
+		kind: "agent-improvement-review",
+		proposalDigest: proposal.digest,
+		decision: input.decision,
+		reviewedBy: input.reviewedBy,
+		reviewedAt,
+		reason: input.reason,
+		...input.feedback === void 0 ? {} : { feedback: input.feedback }
+	}).value);
+}
+/** Authorize product-owned writes only after the exact candidate was measured and approved. */
+function createAgentImprovementActivation(inputProposal, inputReview, options) {
+	const proposal = verifyAgentImprovementProposal(inputProposal);
+	const review = verifyAgentImprovementReview(inputReview);
+	if (review.decision !== "approve" || review.proposalDigest !== proposal.digest) throw new Error("candidate activation requires an approval for the exact proposal");
+	if (!options.fundingOwner.trim() || !options.authorizedBy.trim()) throw new Error("candidate activation authority must be non-empty");
+	const experiment = proposal.evaluation.experiment;
+	const authorizedAt = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+	if (Date.parse(authorizedAt) < Date.parse(review.reviewedAt)) throw new Error("candidate activation cannot predate its approval");
+	const targets = buildAgentImprovementActivationTargets(proposal.changedSurfaces, experiment, options.intent, options.targets);
+	return agentImprovementActivationSchema.parse(canonicalCandidateDocument({
+		kind: "agent-improvement-activation",
+		proposalDigest: proposal.digest,
+		reviewDigest: review.digest,
+		experimentDigest: experiment.digest,
+		candidateDigest: measuredCandidateDigest(proposal),
+		intent: options.intent,
+		targets,
+		fundingOwner: options.fundingOwner,
+		authorizedBy: options.authorizedBy,
+		authorizedAt,
+		expiresAt: options.expiresAt
+	}).value);
+}
+/** Validate a proposal and recompute every binding to its measured experiment. */
+function verifyAgentImprovementProposal(input) {
+	const proposal = verifyCanonicalCandidateDocument(agentImprovementProposalSchema.parse(input), "agent improvement proposal");
+	const { changedSurfaces } = validateShippableAgentImprovementEvaluation(proposal.evaluation, proposal.runId, "agent improvement proposal");
+	if (!(proposal.evaluation.kind === "agent-profile-improvement-measured-comparison" ? sameAgentImprovementSurfaceSet(proposal.changedSurfaces, changedSurfaces) : sameOrderedValues(proposal.changedSurfaces, changedSurfaces))) throw new Error("proposal changed surfaces do not match its exact experiment");
+	assertNoJudgeDerivedProposalFindings(proposal.findings);
+	return proposal;
+}
+/** Return a sealed bundle experiment; ordinary profile changes need a product-owned executor. */
+function requireSealedCandidateExperiment(proposal) {
+	if (proposal.evaluation.kind !== "agent-improvement-measured-comparison") throw new Error("agent profile improvement activation requires a product profile-diff executor, not a sealed candidate bundle");
+	return proposal.evaluation.experiment;
+}
+function measuredCandidateDigest(proposal) {
+	return proposal.evaluation.kind === "agent-profile-improvement-measured-comparison" ? proposal.evaluation.experiment.candidate.stateDigest : proposal.evaluation.experiment.candidate.digest;
+}
+function validateShippableAgentImprovementEvaluation(input, runId, subject) {
+	const evaluation = verifyAgentImprovementEvaluation(input);
+	if (evaluation.decision.outcome !== "ship") throw new Error(`${subject} requires a passing experiment`);
+	if (runId !== evaluation.provenance.runId) throw new Error("proposal runId does not match its measured experiment");
+	return {
+		evaluation,
+		changedSurfaces: evaluation.kind === "agent-profile-improvement-measured-comparison" ? profileImprovementChangedSurfaces(evaluation.experiment.change) : deriveChangedSurfaces(evaluation.experiment.baseline, evaluation.experiment.candidate)
+	};
+}
+/** Use each owning package's complete measurement validator before a proposal is persisted. */
+function verifyAgentImprovementEvaluation(input) {
+	if (typeof input === "object" && input !== null && "kind" in input && input.kind === "agent-profile-improvement-measured-comparison") {
+		const evaluation = agentProfileImprovementMeasuredComparisonSchema.parse(input);
+		optimizationActivationReceiptFromMetadata(evaluation.metadata);
+		return evaluation;
+	}
+	const evaluation = verifyCandidateExperimentComparison(input);
+	optimizationActivationReceiptFromMetadata(evaluation.metadata);
+	return evaluation;
+}
+/** Validate the canonical identity and wire shape of an improvement review. */
+function verifyAgentImprovementReview(input) {
+	return verifyCanonicalCandidateDocument(agentImprovementReviewSchema.parse(input), "agent improvement review");
+}
+/** Validate activation authority against the exact proposal, review, experiment, and base state. */
+function verifyAgentImprovementActivation(input) {
+	const proposal = verifyAgentImprovementProposal(input.proposal);
+	const review = verifyAgentImprovementReview(input.review);
+	const activation = verifyCanonicalCandidateDocument(agentImprovementActivationSchema.parse(input.activation), "agent improvement activation");
+	const experiment = proposal.evaluation.experiment;
+	if (review.decision !== "approve" || review.proposalDigest !== proposal.digest || activation.proposalDigest !== proposal.digest || activation.reviewDigest !== review.digest || activation.experimentDigest !== experiment.digest || activation.candidateDigest !== measuredCandidateDigest(proposal) || Date.parse(review.reviewedAt) < Date.parse(proposal.proposedAt) || Date.parse(activation.authorizedAt) < Date.parse(review.reviewedAt)) throw new Error("candidate activation does not bind the measured and approved candidate");
+	assertAgentImprovementActivationTargets(proposal.changedSurfaces, experiment, activation.intent, activation.targets);
+	return activation;
+}
+/** Recheck one Runtime receipt against its exact signed experiment cell. */
+function verifyCandidateExecutionEvidence(input, options) {
+	const experiment = verifyCandidateExperiment(options.experiment);
+	const bundle = experiment[options.arm];
+	const task = experiment.benchmark.tasks[options.benchmarkCell.taskIndex];
+	const index = options.benchmarkCell.taskIndex * experiment.benchmark.suite.reps + options.benchmarkCell.repetition;
+	if (!task || options.benchmarkCell.suiteDigest !== experiment.benchmark.suite.digest || options.seed !== experiment.benchmark.suite.seeds[index]) throw new Error("candidate execution evidence points outside its signed experiment");
+	const evidence = verifyCanonicalCandidateDocument(candidateExecutionEvidenceSchema.parse(input), "candidate execution evidence");
+	const materialization = verifyCanonicalCandidateDocument(agentCandidateMaterializationReceiptSchema.parse(evidence.materializationReceipt), "candidate materialization receipt");
+	const receipt = verifyCanonicalCandidateDocument(agentCandidateRunReceiptSchema.parse(evidence.receipt), "candidate run receipt");
+	const plan = materialization.executionPlan;
+	const cell = plan.material.runCell;
+	const attempt = options.attempt ?? 1;
+	if (cell.experimentDigest !== experiment.digest || cell.arm !== options.arm || cell.bundleDigest !== bundle.digest || cell.suiteDigest !== experiment.benchmark.suite.digest || cell.taskDigest !== task.digest || cell.taskIndex !== options.benchmarkCell.taskIndex || cell.repetition !== options.benchmarkCell.repetition || cell.seed !== options.seed || cell.attempt !== attempt || canonicalCandidateDigest$1(omitTopLevelDigest(cell)) !== cell.digest) throw new Error("candidate execution receipt substituted its signed experiment cell");
+	assertCapturedInput(materialization.benchmark.suite, experiment.benchmark.suite, "benchmark suite");
+	assertCapturedInput(materialization.benchmark.task, task, "benchmark task");
+	assertEvidenceMaterialDigest(plan, "candidate execution plan");
+	assertEvidenceMaterialDigest(materialization.profileActivation.profilePlan, "candidate profile plan");
+	const expectedProfilePlan = materializeCandidateProfile(bundle.profile, candidateMaterializerHarness(materialization.harness), { resolvedResources: options.resolvedResources });
+	const activation = parseAgentCandidateProfileActivation(materialization.profileActivation, materialization.profileActivation.profilePlan.digest);
+	const regeneratedActivation = createAgentCandidateProfileActivation(expectedProfilePlan, materialization.profileActivation.profilePlan);
+	if (activation.digest !== regeneratedActivation.digest) throw new Error("candidate profile activation does not match the experiment bundle");
+	if (materialization.bundleDigest !== bundle.digest || receipt.bundleDigest !== bundle.digest || receipt.runCellDigest !== cell.digest || receipt.materializationReceiptDigest !== materialization.digest || receipt.executionPlanDigest !== plan.digest) throw new Error("candidate execution evidence does not bind one exact Runtime run");
+	assertEvidenceMaterialDigest(receipt.modelSettlement, "candidate model settlement");
+	assertEvidenceMaterialDigest(receipt.taskOutcome, "candidate task outcome");
+	assertEvidenceMaterialDigest(receipt.benchmarkResult, "candidate benchmark result");
+	return immutableCandidateValue(evidence);
+}
+function assertExactExperimentInput(input, experiment, bundle) {
+	const task = experiment.benchmark.tasks[input.benchmarkCell.taskIndex];
+	const index = input.benchmarkCell.taskIndex * experiment.benchmark.suite.reps + input.benchmarkCell.repetition;
+	if (input.experiment.digest !== experiment.digest || input.bundle.digest !== bundle.digest || !task || input.task.digest !== task.digest || input.benchmarkCell.suiteDigest !== experiment.benchmark.suite.digest || input.seed !== experiment.benchmark.suite.seeds[index]) throw new Error("Runtime received a substituted candidate experiment cell");
+}
+function assertCapturedInput(captured, expected, label) {
+	const bytes = canonicalCandidateBytes(omitTopLevelDigest(expected));
+	if (captured.digest !== expected.digest || captured.material.sha256 !== expected.digest || captured.material.byteLength !== bytes.byteLength) throw new Error(`candidate materialization substituted its ${label}`);
+}
+function assertEvidenceMaterialDigest(evidence, label) {
+	const bytes = canonicalCandidateBytes(evidence.material);
+	if (canonicalCandidateDigest$1(evidence.material) !== evidence.digest || evidence.artifact.sha256 !== evidence.digest || evidence.artifact.byteLength !== bytes.byteLength) throw new Error(`${label} digest does not match its canonical material`);
+}
+function sameOrderedValues(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function assertNoJudgeDerivedProposalFindings(findings) {
+	const leaked = findings.filter((finding) => finding.derived_from_judge === true);
+	if (leaked.length === 0) return;
+	const identifiers = leaked.map((finding) => typeof finding.finding_id === "string" ? finding.finding_id : "<unknown>");
+	throw new Error(`agent improvement proposal findings: judge-derived findings cannot steer an improvement: [${identifiers.join(", ")}]`);
+}
+//#endregion
+export { applyRolloutPolicyToProfile as A, commandVerifier as B, assertProfileImprovementTargetsShareIdentity as C, withMethodRuntimeControls as D, improve as E, LIFTED_FINDING_ANALYST_ID as F, worktreeChangedPaths as G, rawTraceEvidenceProblem as H, isAnalystFinding as I, toAnalystFindings as L, parseRolloutPolicy as M, serializeRolloutPolicy as N, rawTraceDistiller as O, structuralRolloutPolicyFromProfile as P, AGENTIC_PROFILE_RESOURCE_ROOT as R, agentProfileImprovementStateDigest as S, isAgentImprovementProfileSurface as T, requiresRawTraceEvidence as U, defaultBuildPrompt as V, summarizeFindings as W, agentImprovementProfileSurfaceDigest as _, executeAgentCandidateExperimentCell as a, agentImprovementTargetInput as b, reviewAgentImprovementProposal as c, verifyAgentImprovementProposal as d, verifyAgentImprovementReview as f, AGENT_IMPROVEMENT_PROFILE_SURFACES as g, optimizationActivationReceiptFromMetadata as h, createAgentImprovementProposal as i, normalizeRolloutPolicy as j, ROLLOUT_POLICY_EXTENSION as k, runAgentCandidateExperiment as l, createOptimizationActivationReceipt as m, createAgentImprovementActivation as n, proposeAgentImprovement as o, verifyCandidateExecutionEvidence as p, createAgentImprovementMeasuredComparison as r, requireSealedCandidateExperiment as s, AgentCandidateExperimentCellExecutionError as t, verifyAgentImprovementActivation as u, agentImprovementProfileSurfaceInput as v, buildAgentImprovementActivationTargets as w, agentImprovementTargetProfileDiffs as x, agentImprovementTargetDigest as y, agenticGenerator as z };
+
+//# sourceMappingURL=improvement-cycle-C095kS_g.js.map