@tangle-network/agent-runtime 0.103.1 → 0.105.0

package/dist/{chunk-LFM4JBRW.js → chunk-UHEZW5BU.js}

@@ -16,17 +16,16 @@ import {
   verifiedResourceTextByDigest,
   verifyAgentCandidateBundle,
   verifyCanonicalCandidateDocument
-} from "./chunk-SBTWKPVR.js";
+} from "./chunk-WSTRQZYQ.js";
 import {
   defaultStructuralRolloutPolicy,
   optimizerMethod
-} from "./chunk-QYCKIV6C.js";
+} from "./chunk-YJZA2BIK.js";
 import {
-  assertModelAllowed,
   harnessInvocation,
   runLocalHarness,
   runSettledCommand
-} from "./chunk-6WZZXQV5.js";
+} from "./chunk-HLKC4UYB.js";
 import {
   runAnalystLoop
 } from "./chunk-FD2MBMOH.js";
@@ -70,7 +69,7 @@ function agenticGenerator(opts = {}) {
     kind: `agentic:${harness}`,
     // The seed repo + (in rawTraceContext mode) the raw-trace filesystem context
     // are the change signal — an agentic coder proposes from them even when the
-    // distiller yielded zero findings. Without this, the improvementDriver's
+    // distiller yielded zero findings. Without this, the code candidate driver's
     // empty-findings guard short-circuits and generates ZERO candidates on the
     // first (and, for a single-generation run, only) proposal round.
     proposesWithoutFindings: true,
@@ -758,148 +757,63 @@ function toAnalystFindings(findings, opts = {}) {
   return out;
 }
 
-// src/improvement/improvement-driver.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import {
-  verifyCodeSurface
-} from "@tangle-network/agent-eval/campaign";
-
-// 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`);
+// src/improvement/rollout-policy.ts
+var ROLLOUT_POLICY_EXTENSION = "structural-rollout";
+var isBoundedInt = (v, min) => typeof v === "number" && Number.isInteger(v) && v >= min;
+function parseRolloutPolicy(surface) {
+  if (typeof surface !== "string" || surface.trim().length === 0) return void 0;
+  let raw;
+  try {
+    raw = JSON.parse(surface);
+  } catch {
+    return void 0;
   }
-  throw new AggregateError([cause, ...cleanupErrors], `${context}; cleanup failed`);
+  return normalizeRolloutPolicy(raw);
 }
-
-// src/improvement/improvement-driver.ts
-function improvementDriver(opts) {
-  const baseRef = opts.baseRef ?? "main";
-  const owned = /* @__PURE__ */ new Map();
+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 void 0;
+  }
   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) {
-          const failure = err instanceof Error ? err.message : String(err);
-          return rethrowAfterCleanup(
-            err,
-            async () => {
-              await opts.worktree.discard(wt);
-              owned.delete(wt.path);
-            },
-            `improvementDriver: ${failure}`
-          );
-        }
-      }
-      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");
-      }
-    }
+    k,
+    repairRounds,
+    testgen,
+    ...typeof bag.diverse === "boolean" ? { diverse: bag.diverse } : {},
+    ...typeof bag.temperature === "number" ? { temperature: bag.temperature } : {}
   };
 }
-function verifiedCodeIncumbent(surface) {
-  if (typeof surface !== "object" || surface.kind !== "code") return void 0;
-  verifyCodeSurface(surface);
-  return surface;
-}
-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 = spawnSync2("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 = spawnSync2("git", ["rev-parse", "--verify", "HEAD"], {
-    cwd: worktree.path,
-    encoding: "utf8"
+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 } : {}
   });
-  if (head.error || head.status !== 0 || head.stdout.trim() !== incumbent.candidateCommit) {
-    throw new Error("improvementDriver: candidate worktree did not reach the incumbent commit");
-  }
 }
-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" });
+function structuralRolloutPolicyFromProfile(profile) {
+  const bag = profile.extensions?.[ROLLOUT_POLICY_EXTENSION];
+  if (bag === void 0) return void 0;
+  return normalizeRolloutPolicy(bag);
+}
+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 }
+  };
 }
 
 // src/improvement/raw-trace-distiller.ts
@@ -1074,175 +988,221 @@ function truncate2(s, n) {
   return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
 }
 
-// src/improvement/rollout-policy.ts
-var ROLLOUT_POLICY_EXTENSION = "structural-rollout";
-var ROLLOUT_POLICY_BOUNDS = {
-  k: { min: 1, max: 10, step: 2 },
-  repairRounds: { min: 0, max: 3, step: 1 },
-  testgen: { min: 0, max: 10, step: 3 }
-};
-var MAX_CANDIDATES_PER_GENERATION = 4;
-var clamp = (v, min, max) => Math.min(max, Math.max(min, v));
-var isBoundedInt = (v, min) => typeof v === "number" && Number.isInteger(v) && v >= min;
-function parseRolloutPolicy(surface) {
-  if (typeof surface !== "string" || surface.trim().length === 0) return void 0;
-  let raw;
-  try {
-    raw = JSON.parse(surface);
-  } catch {
-    return void 0;
-  }
-  return normalizeRolloutPolicy(raw);
-}
-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 void 0;
-  }
-  return {
-    k,
-    repairRounds,
-    testgen,
-    ...typeof bag.diverse === "boolean" ? { diverse: bag.diverse } : {},
-    ...typeof bag.temperature === "number" ? { temperature: bag.temperature } : {}
-  };
-}
-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 } : {}
-  });
-}
-function structuralRolloutPolicyFromProfile(profile) {
-  const bag = profile.extensions?.[ROLLOUT_POLICY_EXTENSION];
-  if (bag === void 0) return void 0;
-  return normalizeRolloutPolicy(bag);
-}
-function applyRolloutPolicyToProfile(profile, policy) {
-  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 {
-    ...profile,
-    extensions: { ...profile.extensions, [ROLLOUT_POLICY_EXTENSION]: bag }
-  };
-}
-function enumerateNeighborPolicies(policy) {
-  const moves = [
-    { dial: "k", delta: 1 },
-    { dial: "k", delta: -1 },
-    { dial: "repairRounds", delta: 1 },
-    { dial: "repairRounds", delta: -1 },
-    { dial: "testgen", delta: 1 },
-    { dial: "testgen", delta: -1 }
-  ];
-  const seen = /* @__PURE__ */ new Set([serializeRolloutPolicy(policy)]);
-  const neighbors = [];
-  for (const move of moves) {
-    const bounds = ROLLOUT_POLICY_BOUNDS[move.dial];
-    const next = clamp(policy[move.dial] + move.delta * bounds.step, bounds.min, bounds.max);
-    const candidate = { ...policy, [move.dial]: next };
-    const key = serializeRolloutPolicy(candidate);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    neighbors.push(candidate);
-  }
-  return neighbors;
-}
-function candidateLabel(base, next) {
-  for (const dial of ["k", "repairRounds", "testgen"]) {
-    if (next[dial] !== base[dial]) return `${dial} ${base[dial]}\u2192${next[dial]}`;
-  }
-  return "unchanged";
-}
-function rolloutPolicyProposer() {
-  return {
-    kind: "rollout-policy",
-    async propose(ctx) {
-      const policy = parseRolloutPolicy(ctx.currentSurface);
-      if (!policy) return [];
-      const neighbors = enumerateNeighborPolicies(policy);
-      if (neighbors.length === 0) return [];
-      const cap = Math.max(1, Math.min(ctx.populationSize, MAX_CANDIDATES_PER_GENERATION));
-      const start = ctx.generation * cap % neighbors.length;
-      const window = [];
-      for (let i = 0; i < Math.min(cap, neighbors.length); i += 1) {
-        window.push(neighbors[(start + i) % neighbors.length]);
-      }
-      return window.map((candidate) => ({
-        surface: serializeRolloutPolicy(candidate),
-        label: candidateLabel(policy, candidate),
-        rationale: "bounded single-dial neighbor of the current structuralRollout policy; the held-out gate decides (deterministic enumeration \u2014 the dial space is tiny and prompt-style reflective proposals are a measured zero here)"
-      }));
-    }
-  };
-}
-
 // src/improvement/improve.ts
-import { canonicalJson, makeFinding as makeFinding3 } from "@tangle-network/agent-eval";
+import { agentProfileSchema as agentProfileSchema2 } from "@tangle-network/agent-interface";
+
+// src/improvement/code-execution.ts
+import { makeFinding as makeFinding3 } from "@tangle-network/agent-eval";
 import {
-  gepaProposer,
-  gitWorktreeAdapter,
-  memoryCurationProposer,
-  skillOptProposer
+  gitWorktreeAdapter
 } from "@tangle-network/agent-eval/campaign";
 import {
   selfImprove
 } from "@tangle-network/agent-eval/contract";
-import {
-  agentProfileSchema
-} from "@tangle-network/agent-interface";
-var defaultReflectionModel = "deepseek-v4-flash";
-function llmClientOptions(llm) {
-  return { baseUrl: llm?.baseUrl, apiKey: llm?.apiKey };
-}
-function defaultGeneratorFor(surface, llm) {
-  const model = llm?.model ?? defaultReflectionModel;
-  switch (surface) {
-    case "prompt":
-      return gepaProposer({ llm: llmClientOptions(llm), model, target: "agent system prompt" });
-    case "skills":
-      return skillOptProposer({ llm: llmClientOptions(llm), model, target: "agent skill document" });
-    case "memory":
-      return memoryCurationProposer();
-    case "rollout-policy":
-      return rolloutPolicyProposer();
-    default:
-      return void 0;
-  }
+
+// 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`);
+}
+
+// src/improvement/improve-result.ts
+function copyImproveCost(cost) {
+  return {
+    totalCostUsd: cost.totalCostUsd,
+    accountingComplete: cost.accountingComplete,
+    incompleteReasons: [...cost.incompleteReasons]
+  };
+}
+
+// src/improvement/improvement-driver.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import {
+  verifyCodeSurface
+} from "@tangle-network/agent-eval/campaign";
+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) {
+          const failure = err instanceof Error ? err.message : String(err);
+          return rethrowAfterCleanup(
+            err,
+            async () => {
+              await opts.worktree.discard(wt);
+              owned.delete(wt.path);
+            },
+            `improvementDriver: ${failure}`
+          );
+        }
+      }
+      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");
+      }
+    }
+  };
+}
+function verifiedCodeIncumbent(surface) {
+  if (typeof surface !== "object" || surface.kind !== "code") return void 0;
+  verifyCodeSurface(surface);
+  return surface;
 }
-function baselineSurfaceFor(profile, surface, skills) {
+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 = spawnSync2("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 = spawnSync2("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");
+  }
+}
+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" });
+}
+
+// src/improvement/profile-surface.ts
+import { canonicalJson } from "@tangle-network/agent-eval";
+import {
+  agentProfileSchema
+} from "@tangle-network/agent-interface";
+function prepareProfileSurface(profile, surface, skills, profileComponents) {
   switch (surface) {
     case "prompt":
-      return profile.prompt?.systemPrompt ?? "";
-    case "skills":
-      return inlineSkill(profile, skills).content;
-    case "tools":
-      return JSON.stringify(profile.tools ?? {});
-    case "mcp":
-      return JSON.stringify(profile.mcp ?? {});
-    case "hooks":
-      return JSON.stringify(profile.hooks ?? {});
-    case "subagents":
-      return JSON.stringify(profile.subagents ?? {});
-    case "agent-profile":
-      return canonicalJson(profile);
-    case "memory":
-      return profileInstructions(profile);
+      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 policy ? serializeRolloutPolicy(policy) : "";
+      return {
+        surface: policy ? serializeRolloutPolicy(policy) : "",
+        value: policy ?? null
+      };
     }
     case "code":
       throw new ConfigError(
@@ -1250,139 +1210,35 @@ function baselineSurfaceFor(profile, surface, skills) {
       );
   }
 }
-var DISTILLED_NOTES_MAX_CHARS = 1500;
-var DISTILLED_ERROR_MAX_CHARS = 500;
-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, j) => sum + (j.composite ?? 0), 0) / judgeScores.length;
-        if (!error && composite >= 0.999) continue;
-        const notes = judgeScores.map((j) => j.notes).filter((n) => typeof n === "string" && n.length > 0).join("; ").slice(0, DISTILLED_NOTES_MAX_CHARS);
-        const claim = notes || (error ? `Scenario ${scenario} failed: ${error.slice(0, DISTILLED_ERROR_MAX_CHARS)}` : "");
-        failures.push({
-          scenario,
-          composite: Number(composite.toFixed(3)),
-          notes,
-          ...claim ? { claim } : {},
-          ...error ? { error: error.slice(0, DISTILLED_ERROR_MAX_CHARS) } : {}
-        });
-      }
-    }
-    if (failures.length === 0) return staticFindings;
-    failures.sort((a, b) => a.composite - b.composite);
-    return failures.slice(0, CAP).map(
-      (f) => makeFinding3({
-        analyst_id: "generation-failure-distiller",
-        severity: f.error !== void 0 || f.composite < 0.5 ? "high" : "medium",
-        area: "generation-failure",
-        confidence: 1,
-        subject: f.scenario,
-        claim: `Scenario ${f.scenario} scored composite ${f.composite}${f.notes ? `: ${f.notes}` : ""}${f.error ? ` (error: ${f.error})` : ""}`,
-        evidence_refs: [],
-        metadata: {
-          scenario: f.scenario,
-          composite: f.composite,
-          ...f.notes ? { notes: f.notes } : {},
-          ...f.error !== void 0 ? { error: f.error } : {}
-        }
-      })
-    );
-  };
-}
-function memoryGenerationDistiller(staticFindings) {
-  const distillFailures = generationFailureDistiller(staticFindings);
-  return async (input) => {
-    const fresh = await distillFailures(input);
-    return fresh === staticFindings ? staticFindings : [...staticFindings, ...fresh];
-  };
-}
-function defaultDistillerFor(opts, findings) {
-  const surface = opts.surface ?? "prompt";
-  const durableRun = opts.runDir !== void 0 && !opts.runDir.startsWith("mem://");
-  const useRawTraces = opts.rawTraceContext ?? (surface === "memory" ? false : durableRun);
-  if (useRawTraces) return rawTraceDistiller({ fallbackFindings: findings });
-  if (surface === "memory") return memoryGenerationDistiller(findings);
-  return generationFailureDistiller(findings);
-}
-async function discardPreparedBaseline(worktree, baselineWorktree, cause) {
-  return rethrowAfterCleanup(
-    cause,
-    () => worktree.discard(baselineWorktree),
-    "improve(): code preparation failed"
-  );
-}
 function isCodeSurface(surface) {
   return typeof surface === "object" && surface !== null && surface.kind === "code";
 }
-async function prepareCodeRun(code) {
-  const baseRef = code.baseRef ?? "main";
-  const worktree = code.worktree ?? gitWorktreeAdapter({
-    repoRoot: code.repoRoot,
-    ...code.worktreeDir ? { worktreeDir: code.worktreeDir } : {}
+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)
   });
-  const baselineWorktree = await worktree.create({ baseRef, label: "incumbent-baseline" });
-  try {
-    const baseline = await worktree.finalize(baselineWorktree, "Incumbent code checkout");
-    let baselineDiscarded = false;
-    const generator = code.generator ?? agenticGenerator({
-      ...code.harness ? { harness: code.harness } : {},
-      ...code.verify ? { verify: code.verify } : {},
-      ...code.timeoutMs ? { timeoutMs: code.timeoutMs } : {}
-    });
-    const managed = improvementDriver({ worktree, generator, 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;
+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;
 }
 function parseWinnerJson(winner, surface) {
   try {
@@ -1393,16 +1249,58 @@ function parseWinnerJson(winner, surface) {
     );
   }
 }
-function assertCandidateSurfaceKind(surface, winner) {
-  if (surface === "code" ? typeof winner === "string" : typeof winner !== "string") {
+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`
+    );
+  }
 }
-function materializeImprovementProfileCandidate(profile, surface, winner, skills) {
-  if (typeof winner !== "string") return void 0;
+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 applied = profileComponents.apply(profile, winnerComponents);
+    const validated = validateProfileCandidate(applied, 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 } };
@@ -1445,7 +1343,6 @@ function materializeImprovementProfileCandidate(profile, surface, winner, skills
       };
       break;
     case "rollout-policy": {
-      if (winner === "") return void 0;
       const policy = normalizeRolloutPolicy(parseWinnerJson(winner, surface));
       if (!policy) {
         throw new ConfigError(
@@ -1455,9 +1352,10 @@ function materializeImprovementProfileCandidate(profile, surface, winner, skills
       candidate = applyRolloutPolicyToProfile(profile, policy);
       break;
     }
-    case "code":
-      return void 0;
   }
+  return validateProfileCandidate(candidate, surface);
+}
+function validateProfileCandidate(candidate, surface) {
   const parsed = agentProfileSchema.safeParse(candidate);
   if (!parsed.success) {
     throw new ConfigError(
@@ -1466,6 +1364,39 @@ function materializeImprovementProfileCandidate(profile, surface, winner, skills
   }
   return immutableCandidateValue(parsed.data);
 }
+function createProfileCandidateMaterializer(profile, surface, baselineSurface, skills, profileComponents) {
+  const baselineDigest = canonicalCandidateDigest(baselineSurface);
+  if (profileComponents) {
+    const reappliedBaseline = materializeImprovementProfileCandidate(
+      profile,
+      surface,
+      baselineSurface,
+      skills,
+      profileComponents
+    );
+    if (canonicalCandidateDigest(reappliedBaseline) !== canonicalCandidateDigest(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(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) {
@@ -1494,73 +1425,167 @@ function profileInstructions(profile) {
     "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"
-    );
+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`
+    );
+  }
+}
+
+// src/improvement/code-execution.ts
+var distilledNotesMaxChars = 1500;
+var distilledErrorMaxChars = 500;
+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 >= 0.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) => makeFinding3({
+        analyst_id: "generation-failure-distiller",
+        severity: failure.error !== void 0 || failure.composite < 0.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 } : {}
+        }
+      })
+    );
+  };
+}
+function defaultDistillerFor(opts, findings) {
+  const durableRun = opts.runDir !== void 0 && !opts.runDir.startsWith("mem://");
+  const useRawTraces = opts.rawTraceContext ?? durableRun;
+  if (useRawTraces) return rawTraceDistiller({ fallbackFindings: findings });
+  return generationFailureDistiller(findings);
+}
+async function discardPreparedBaseline(worktree, baselineWorktree, cause) {
+  return rethrowAfterCleanup(
+    cause,
+    () => worktree.discard(baselineWorktree),
+    "improve(): code preparation failed"
+  );
+}
+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 generator = code.generator ?? agenticGenerator({
+      ...code.harness ? { harness: code.harness } : {},
+      ...code.verify ? { verify: code.verify } : {},
+      ...code.timeoutMs ? { timeoutMs: code.timeoutMs } : {}
+    });
+    const managed = improvementDriver({ worktree, generator, 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);
   }
-  return { ...instructions, content };
 }
-function assertFailClosedResources(profile, surface) {
-  if (profile.resources?.failOnError !== true) {
-    throw new ConfigError(
-      `improve(): surface '${surface}' requires profile.resources.failOnError: true`
-    );
-  }
+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 improve(profile, findings, opts) {
+async function runCodeImprovement(opts) {
   const {
-    surface = "prompt",
     gate = "holdout",
-    generator,
-    allowedModels,
-    rawTraceContext,
+    findings: inputFindings = [],
+    rawTraceContext: _rawTraceContext,
     code,
-    skills,
     promotionGate,
     analyzeGeneration,
+    surface: _surface,
     ...sharedOptions
   } = opts;
-  const parsedProfile = agentProfileSchema.safeParse(profile);
-  if (!parsedProfile.success) {
-    throw new ConfigError(
-      `improve(): input is not a valid AgentProfile: ${parsedProfile.error.message}`
-    );
-  }
-  if (surface === "code" && generator) {
-    throw new ConfigError(
-      "improve(): surface 'code' forbids opts.generator because an external SurfaceProposer cannot transfer checkout ownership; pass opts.code.generator instead"
-    );
-  }
-  const usesReflectionModel = !generator && (surface === "prompt" || surface === "skills");
-  if (usesReflectionModel) {
-    assertModelAllowed(sharedOptions.llm?.model ?? defaultReflectionModel, allowedModels);
-  }
-  let preparedCode;
-  if (surface === "code") {
-    if (!code) {
-      throw new ConfigError(
-        "improve(): surface 'code' requires opts.code.repoRoot so the incumbent can run from an isolated checkout"
-      );
-    }
-    preparedCode = await prepareCodeRun(code);
-  }
-  const proposer = preparedCode?.proposer ?? generator ?? defaultGeneratorFor(surface, sharedOptions.llm);
-  if (!proposer) {
-    throw new ConfigError(
-      `improve(): surface '${surface}' has no default generator \u2014 pass opts.generator (a SurfaceProposer) explicitly`
-    );
-  }
+  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 ?? baselineSurfaceFor(parsedProfile.data, surface, skills),
-      proposer,
+      baselineSurface: preparedCode.baseline,
+      proposer: preparedCode.proposer,
       budget,
       findings,
       ...promotionGate !== void 0 ? { gate: promotionGate } : {},
@@ -1569,7 +1594,6 @@ async function improve(profile, findings, opts) {
       }
     });
   } catch (cause) {
-    if (!preparedCode) throw cause;
     return rethrowAfterCleanup(
       cause,
       () => preparedCode.cleanup(),
@@ -1577,50 +1601,423 @@ async function improve(profile, findings, opts) {
     );
   }
   const winnerSurface = raw.winner.surface;
-  assertCandidateSurfaceKind(surface, winnerSurface);
-  if (preparedCode) {
+  assertCandidateSurfaceKind("code", preparedCode.baseline, winnerSurface);
+  try {
+    await preparedCode.cleanup(winnerSurface);
+  } catch (cleanupCause) {
     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"
-        );
-      }
+      await preparedCode.cleanup();
+    } catch (finalCleanupCause) {
       throw new AggregateError(
-        [cleanupCause],
-        "improve(): code result cleanup failed; the final all-worktree retry succeeded"
+        [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());
-  const candidateProfile = materializeImprovementProfileCandidate(
-    parsedProfile.data,
-    surface,
-    winnerSurface,
-    skills
-  );
+  const dispose = idempotentDispose(async () => preparedCode.cleanup());
   const candidate = immutableCandidateValue({
-    surface,
-    value: winnerSurface,
-    ...candidateProfile ? { profile: candidateProfile } : {}
+    surface: "code",
+    value: winnerSurface
   });
   return {
+    mode: "code",
     candidate,
     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
   };
 }
 
+// src/improvement/method-execution.ts
+import { randomUUID } from "crypto";
+import {
+  compareOptimizationMethods
+} from "@tangle-network/agent-eval/campaign";
+import {
+  sha256DigestSchema
+} from "@tangle-network/agent-interface";
+
+// src/improvement/method-controls.ts
+var methodRuntimeControls = /* @__PURE__ */ 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];
+}
+
+// src/improvement/method-cost.ts
+var EVALUATION_TAG = "runtimeEvaluationRef";
+var 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(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(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;
+}
+
+// src/improvement/method-identity.ts
+import {
+  campaignSplitDigest
+} from "@tangle-network/agent-eval/campaign";
+function buildMethodEvaluationIdentity(input) {
+  const optimizationReps = input.optimizationRunOptions?.reps ?? 1;
+  const developmentSplitDigest = canonicalCandidateDigest({
+    train: campaignSplitDigest(input.trainScenarios, optimizationReps),
+    selection: campaignSplitDigest(input.selectionScenarios, optimizationReps)
+  });
+  const judgeDescriptors = input.judges.map(judgeDescriptor);
+  const evaluationRef = canonicalCandidateDigest({
+    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
+    }
+  });
+  return {
+    evaluationRef,
+    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
+  };
+}
+
+// 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(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({
+        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(baselineSurface);
+  const validatedCandidates = /* @__PURE__ */ new Set();
+  const materializeProfile2 = (candidateSurface) => {
+    const candidate2 = rawMaterializeProfile(candidateSurface);
+    const candidateDigest = canonicalCandidateDigest(candidateSurface);
+    if (!validatedCandidates.has(candidateDigest)) {
+      const prepared = prepareProfileSurface(candidate2, surface, skills, profileComponents);
+      const validationInput = Object.freeze({
+        profile: candidate2,
+        surface,
+        candidateSurface: immutableCandidateValue(candidateSurface),
+        value: immutableCandidateValue(prepared.value),
+        isBaseline: candidateDigest === baselineSurfaceDigest
+      });
+      methodControls?.validateCandidate(validationInput);
+      validateCandidate?.(validationInput);
+      validatedCandidates.add(candidateDigest);
+    }
+    return candidate2;
+  };
+  materializeProfile2(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
+      );
+      materializeProfile2(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(materializeProfile2(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 = materializeProfile2(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() {
+    }
+  };
+}
+
+// src/improvement/improve.ts
+async function improve(profileOrCode, opts) {
+  if (opts === void 0) {
+    const code = profileOrCode;
+    if (!code || 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 = agentProfileSchema2.safeParse(profileOrCode);
+  if (!parsedProfile.success) {
+    throw new ConfigError(
+      `improve(): input is not a valid AgentProfile: ${parsedProfile.error.message}`
+    );
+  }
+  return runMethodImprovement(immutableCandidateValue(parsedProfile.data), opts);
+}
+
 // src/intelligence/improvement-surfaces.ts
 import {
   agentProfileDiffSchema,
-  agentProfileSchema as agentProfileSchema2,
+  agentProfileSchema as agentProfileSchema3,
   defineAgentProfileDiff
 } from "@tangle-network/agent-interface";
 var changedSurfaceOrder = [
@@ -1823,7 +2220,7 @@ function exactObject(value, keys, label) {
   return record;
 }
 function parseProfileSet(value) {
-  return agentProfileSchema2.parse(value);
+  return agentProfileSchema3.parse(value);
 }
 function assertKnowledgeCandidatePair(baselineBundle, candidateBundle) {
   const baseline = baselineBundle.knowledge;
@@ -1893,6 +2290,160 @@ function opaqueProfileSlice(profile) {
   };
 }
 
+// src/intelligence/optimization-receipt.ts
+import {
+  agentProfileModelHintsSchema
+} from "@tangle-network/agent-interface";
+var optimizationReceiptMetadataKey = "optimizationReceipt";
+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;
+}
+function attachOptimizationActivationReceipt(metadata, receipt) {
+  assertNoCallerOptimizationReceipt(metadata);
+  return immutableCandidateValue({
+    ...metadata ?? {},
+    [optimizationReceiptMetadataKey]: receipt
+  });
+}
+function assertNoCallerOptimizationReceipt(metadata) {
+  if (metadata && Object.hasOwn(metadata, optimizationReceiptMetadataKey)) {
+    throw new Error(`candidate metadata reserves '${optimizationReceiptMetadataKey}' for Runtime`);
+  }
+}
+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(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 approximatelyEqual2(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 approximatelyEqual2(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);
+}
+
 // src/intelligence/improvement-cycle.ts
 import { assertNoJudgeVerdict } from "@tangle-network/agent-eval/analyst";
 import {
@@ -1924,8 +2475,8 @@ function sealAgentImprovementExperiment(material, improvement) {
   const candidateLineage = {
     source: "optimizer",
     parentDigests: [material.baseline.digest],
-    runIds: [improvement.raw.provenance.runId],
-    developmentSplitDigest: improvement.raw.provenance.evidence.search.splitDigest
+    runIds: [improvement.lineage.runId],
+    developmentSplitDigest: improvement.lineage.developmentSplitDigest
   };
   return sealCandidateExperiment({ ...material, candidateLineage });
 }
@@ -2019,16 +2570,22 @@ function createAgentImprovementMeasuredComparison(options) {
   return verifyCandidateExperimentComparison(measuredComparisonFromCandidateExperiment(options));
 }
 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 improvement = await improve(options.profile, [...findings], options.improvement);
+  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
@@ -2042,10 +2599,12 @@ async function proposeAgentImprovement(options) {
       ...options.maxConcurrency === void 0 ? {} : { maxConcurrency: options.maxConcurrency },
       ...options.signal ? { signal: options.signal } : {},
       ...options.candidate ? { candidate: options.candidate } : {},
-      ...options.metadata ? { metadata: options.metadata } : {},
-      generationsExplored: improvement.raw.generationsExplored,
-      searchDurationMs: improvement.raw.durationMs,
-      searchCostUsd: improvement.raw.totalCostUsd
+      ...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,
@@ -2067,9 +2626,6 @@ async function proposeAgentImprovement(options) {
 function assertImprovementCandidateBinding(improvement, experiment) {
   const candidate = improvement.candidate;
   if (candidate.surface !== "code") {
-    if (!candidate.profile) {
-      throw new Error(`improvement surface '${candidate.surface}' did not produce an exact profile`);
-    }
     try {
       assertCandidateProfileBinding(candidate.profile, experiment.candidate.profile);
     } catch (cause) {
@@ -2092,6 +2648,7 @@ function createAgentImprovementProposal(options) {
     "createAgentImprovementProposal findings"
   );
   const evaluation = verifyCandidateExperimentComparison(options.evaluation);
+  optimizationActivationReceiptFromMetadata(evaluation.metadata);
   if (evaluation.decision.outcome !== "ship") {
     throw new Error("agent improvement proposal requires a passing experiment");
   }
@@ -2178,6 +2735,7 @@ function verifyAgentImprovementProposal(input) {
     "agent improvement proposal"
   );
   const evaluation = verifyCandidateExperimentComparison(proposal.evaluation);
+  optimizationActivationReceiptFromMetadata(evaluation.metadata);
   if (evaluation.decision.outcome !== "ship") {
     throw new Error("agent improvement proposal does not contain a passing experiment");
   }
@@ -2325,17 +2883,14 @@ export {
   LIFTED_FINDING_ANALYST_ID,
   isAnalystFinding,
   toAnalystFindings,
-  improvementDriver,
-  rawTraceDistiller,
   ROLLOUT_POLICY_EXTENSION,
-  ROLLOUT_POLICY_BOUNDS,
   parseRolloutPolicy,
   normalizeRolloutPolicy,
   serializeRolloutPolicy,
   structuralRolloutPolicyFromProfile,
   applyRolloutPolicyToProfile,
-  enumerateNeighborPolicies,
-  rolloutPolicyProposer,
+  rawTraceDistiller,
+  withMethodRuntimeControls,
   improve,
   AGENT_IMPROVEMENT_PROFILE_SURFACES,
   buildAgentImprovementActivationTargets,
@@ -2345,6 +2900,8 @@ export {
   agentImprovementProfileSurfaceInput,
   agentImprovementProfileSurfaceDigest,
   agentImprovementTargetProfileDiffs,
+  createOptimizationActivationReceipt,
+  optimizationActivationReceiptFromMetadata,
   AgentCandidateExperimentCellExecutionError,
   runAgentCandidateExperiment,
   executeAgentCandidateExperimentCell,
@@ -2358,4 +2915,4 @@ export {
   verifyAgentImprovementActivation,
   verifyCandidateExecutionEvidence
 };
-//# sourceMappingURL=chunk-LFM4JBRW.js.map
+//# sourceMappingURL=chunk-UHEZW5BU.js.map