@tangle-network/agent-runtime 0.105.0 → 0.106.1

package/dist/chunk-UHEZW5BU.js

@@ -1,2918 +0,0 @@
-import {
-  agentCandidateProfileAsAgentProfile,
-  assertCandidateProfileBinding,
-  candidateMaterializerHarness,
-  canonicalCandidateBytes,
-  canonicalCandidateDigest,
-  canonicalCandidateDocument,
-  createAgentCandidateProfileActivation,
-  executePreparedAgentCandidate,
-  immutableCandidateValue,
-  omitTopLevelDigest,
-  omitUndefinedObjectFields,
-  parseAgentCandidateProfileActivation,
-  parseExactAgentProfile,
-  prepareAgentCandidateExecution,
-  verifiedResourceTextByDigest,
-  verifyAgentCandidateBundle,
-  verifyCanonicalCandidateDocument
-} from "./chunk-WSTRQZYQ.js";
-import {
-  defaultStructuralRolloutPolicy,
-  optimizerMethod
-} from "./chunk-YJZA2BIK.js";
-import {
-  harnessInvocation,
-  runLocalHarness,
-  runSettledCommand
-} from "./chunk-HLKC4UYB.js";
-import {
-  runAnalystLoop
-} from "./chunk-FD2MBMOH.js";
-import {
-  ConfigError
-} from "./chunk-YEJR7IXO.js";
-
-// src/improvement/agentic-generator.ts
-import { spawnSync } from "child_process";
-import { createHash } from "crypto";
-import { existsSync, readFileSync, rmSync } from "fs";
-import { join, resolve, sep } from "path";
-import {
-  applyWorkspacePlan,
-  materializeProfile
-} from "@tangle-network/agent-profile-materialize";
-var RAW_TRACE_ANALYST_ID = "raw-trace-distiller";
-var RAW_TRACE_AREA = "raw-trace-context";
-var RAW_TRACE_DIAGNOSIS_PATH = ".improve/raw-trace-diagnosis.md";
-var AGENTIC_PROFILE_RESOURCE_ROOT = ".agent-runtime-profile-resources";
-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}`,
-    // 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 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,
-    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}
-
-${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 (receipt2) => {
-                profileWorkspaceReceipt = receipt2;
-                const result2 = await run({
-                  harness,
-                  cwd: worktreePath,
-                  taskPrompt,
-                  ...invocation ? { invocation: { command: invocation.command, args: invocation.args } } : {},
-                  // The candidate worktree is isolated and must be editable without an
-                  // interactive permission prompt. Other runLocalHarness callers remain
-                  // permission-safe by default.
-                  dangerouslySkipPermissions: harness === "claude",
-                  ...opts.codexReproducible ? { codexReproducible: true } : {},
-                  ...readDeniedPaths ? { codexReadDeniedPaths: readDeniedPaths } : {},
-                  timeoutMs: opts.timeoutMs,
-                  signal: executionSignal
-                });
-                harnessResult = result2;
-                return result2;
-              }
-            );
-            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: (result2) => costReceiptFromHarness(result2, 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 {
-    const receipt = applyWorkspacePlan(plan, worktreePath);
-    value = await run(receipt);
-  } 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 new Error("agenticGenerator: author shot timed out");
-  }
-  if (result.aborted) {
-    return new Error("agenticGenerator: author shot was cancelled by the caller");
-  }
-  if (result.killedBySignal) {
-    return new Error(`agenticGenerator: author shot was killed by ${result.killedBySignal}`);
-  }
-  if (result.exitCode !== 0) {
-    return new Error(`agenticGenerator: author shot exited with code ${String(result.exitCode)}`);
-  }
-  if (!codexReproducible) return null;
-  if (!result.usage || !result.evidence) {
-    return new Error(
-      "agenticGenerator: reproducible Codex shot completed without usage or execution evidence"
-    );
-  }
-  const expectedPromptSha256 = sha256(exactPrompt).slice("sha256:".length);
-  if (result.evidence.requestedPromptSha256 !== expectedPromptSha256) {
-    return 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")}`;
-}
-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 \u2014 only a real lift promotes it.",
-    "",
-    optimizerMethod,
-    "",
-    "THE SURFACE \u2014 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 \u2014 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 \u2014 leave changes in the working tree.",
-    "",
-    "FINDINGS \u2014 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(`    \u2192 ${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");
-}
-var EMPTY_TREE_NOTE = "NOTE: your previous attempt left the working tree unchanged. Make the concrete file edits now.";
-function failureNote(feedback) {
-  const detail = feedback?.trim();
-  return [
-    "NOTE: your edits are in the working tree but verification FAILED.",
-    "Fix the problem in place \u2014 build on your existing edits, do not revert them.",
-    detail ? `Verifier output:
-${truncate(detail, 4e3)}` : "No verifier detail was captured."
-  ].join("\n");
-}
-function rawTraceEvidenceProblem(worktreePath, findings) {
-  const changedPaths = worktreeChangedPaths(worktreePath);
-  const substantive = changedPaths.filter((path) => path !== RAW_TRACE_DIAGNOSIS_PATH);
-  if (substantive.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)];
-}
-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();
-      const code = err.code;
-      if (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}` };
-  };
-}
-function summarizeFindings(findings) {
-  if (findings.length === 0) return "agentic improvement";
-  if (findings.length === 1) return `agentic: ${truncate(findings[0].claim, 64)}`;
-  return `agentic: ${findings.length} findings addressed`;
-}
-function acceptedCandidate(findings) {
-  const summary = summarizeFindings(findings);
-  return {
-    applied: true,
-    summary,
-    label: slugify(summary.split("\n", 1)[0] ?? summary),
-    rationale: boundedRationale(summary, findings)
-  };
-}
-function slugify(line) {
-  const slug = line.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return truncate(slug || "agentic-improvement", 48);
-}
-function boundedRationale(summary, findings) {
-  if (findings.length === 0) return summary;
-  return truncate(
-    findings.map((finding) => `(${finding.severity}) ${finding.claim}`).join("; "),
-    400
-  );
-}
-function truncate(s, n) {
-  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
-}
-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());
-}
-
-// src/improvement/findings.ts
-import { makeFinding } from "@tangle-network/agent-eval";
-var SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low", "info"]);
-var LIFTED_FINDING_ANALYST_ID = "lifted-seed";
-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);
-}
-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)}\u2026` : json;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function toAnalystFindings(findings, opts = {}) {
-  const analystId = opts.analystId ?? LIFTED_FINDING_ANALYST_ID;
-  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: 0.5,
-        claim,
-        evidence_refs: [],
-        ...f && typeof f === "object" ? { metadata: { raw: f } } : {}
-      })
-    );
-  }
-  return out;
-}
-
-// 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;
-  }
-  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 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
-import { existsSync as existsSync2, readdirSync } from "fs";
-import { basename, join as join2, resolve as resolve2 } from "path";
-import { makeFinding as makeFinding2 } from "@tangle-network/agent-eval";
-var ANALYST_ID = "raw-trace-distiller";
-var PASS_THRESHOLD = 0.999;
-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) => 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 [
-        makeFinding2({
-          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(
-      makeFinding2({
-        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} \u2014 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 \u2014 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: ${truncate2(c.error, 160)}` : ""}) \u2014 dir ${c.cellDir}`;
-        const files = c.files.map((f) => `    - ${f}`).join("\n");
-        const more = c.truncatedFiles ? `
-    - \u2026(ls ${c.cellDir} for the rest)` : "";
-        return c.files.length > 0 ? `${header}
-${files}${more}` : header;
-      }).join("\n");
-      findings.push(
-        makeFinding2({
-          analyst_id: ANALYST_ID,
-          severity: cand.composite < 0.5 ? "critical" : "high",
-          area: "raw-trace-context",
-          confidence: 1,
-          subject: cand.surfaceHash,
-          claim: `Candidate ${cand.surfaceHash} scored composite ${cand.composite.toFixed(3)} 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:
-${fileLines}
-Or 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;
-  };
-}
-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 = join2(campaignDir, sanitizeCellId(cell.cellId));
-    const artifactPaths = artifactPathsForCell(campaign.artifactsByPath, cell.cellId);
-    const discovered = durable ? listTraceFiles(cellDir) : [];
-    const canonical = [join2(cellDir, "spans.jsonl"), join2(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;
-}
-function artifactPathsForCell(artifactsByPath, cellId) {
-  if (!artifactsByPath) return [];
-  const prefix = `${cellId}/`;
-  return Object.entries(artifactsByPath).filter(([key]) => key.startsWith(prefix)).map(([, absPath]) => resolve2(absPath));
-}
-function listTraceFiles(dir) {
-  const out = [];
-  for (const entry of safeReadDir(dir)) {
-    const full = join2(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(join2(full, sub.name));
-      }
-    }
-  }
-  return out;
-}
-function safeReadDir(dir) {
-  try {
-    return readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-function sanitizeCellId(cellId) {
-  return cellId.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function isDurable(runDir) {
-  return !runDir.startsWith("mem://") && existsSync2(runDir);
-}
-function absoluteRunDir(runDir) {
-  return runDir.startsWith("mem://") ? runDir : resolve2(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 truncate2(s, n) {
-  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
-}
-
-// src/improvement/improve.ts
-import { agentProfileSchema as agentProfileSchema2 } from "@tangle-network/agent-interface";
-
-// src/improvement/code-execution.ts
-import { makeFinding as makeFinding3 } from "@tangle-network/agent-eval";
-import {
-  gitWorktreeAdapter
-} from "@tangle-network/agent-eval/campaign";
-import {
-  selfImprove
-} from "@tangle-network/agent-eval/contract";
-
-// 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 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 {
-        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;
-}
-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`
-    );
-  }
-}
-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 } };
-      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(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) {
-    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`
-    );
-  }
-}
-
-// 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);
-  }
-}
-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());
-  const candidate = immutableCandidateValue({
-    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 agentProfileSchema3,
-  defineAgentProfileDiff
-} from "@tangle-network/agent-interface";
-var changedSurfaceOrder = [
-  "prompt",
-  "skills",
-  "tools",
-  "mcp",
-  "hooks",
-  "subagents",
-  "agent-profile",
-  "memory",
-  "code",
-  "knowledge"
-];
-var 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(baseline[surface]) !== canonicalCandidateDigest(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) {
-  const expected = new Set(surfaces);
-  const actual = new Set(targets.map((target) => target.surface));
-  const sourceArm = intent === "activate-candidate" ? "baseline" : "candidate";
-  if (targets.some((target) => !target.identity.trim()) || targets.some(
-    (target) => target.expectedBaseDigest !== agentImprovementTargetDigest(experiment, sourceArm, target.surface)
-  ) || targets.length !== surfaces.length || expected.size !== actual.size || [...expected].some((surface) => !actual.has(surface))) {
-    throw new Error("candidate activation targets must cover exactly the changed surfaces");
-  }
-}
-function buildAgentImprovementActivationTargets(surfaces, experiment, intent, identities) {
-  const sourceArm = intent === "activate-candidate" ? "baseline" : "candidate";
-  const targets = identities.map((target) => ({
-    ...target,
-    expectedBaseDigest: agentImprovementTargetDigest(experiment, sourceArm, target.surface)
-  }));
-  assertAgentImprovementActivationTargets(surfaces, experiment, intent, targets);
-  return targets;
-}
-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(improvementSurfaceValues(experiment[arm])[surface]);
-}
-function agentImprovementTargetInput(bundle, surface) {
-  return improvementSurfaceValues(bundle)[surface];
-}
-function isAgentImprovementProfileSurface(surface) {
-  return AGENT_IMPROVEMENT_PROFILE_SURFACES.includes(surface);
-}
-function agentImprovementProfileSurfaceInput(profile, surface) {
-  const parsed = parseExactAgentProfile(
-    omitUndefinedObjectFields(profile, "agent improvement profile"),
-    "agent improvement profile"
-  );
-  return immutableCandidateValue(profileSurfaceInput(parsed, 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
-      };
-  }
-}
-function agentImprovementProfileSurfaceDigest(profile, surface) {
-  return canonicalCandidateDigest(agentImprovementProfileSurfaceInput(profile, surface));
-}
-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];
-  const replacement = agentProfileDiffSchema.parse(
-    defineAgentProfileDiff({
-      ...common,
-      id: `${options.id}:${target.surface}:set`,
-      title: `Activate measured ${target.surface}`,
-      set
-    })
-  );
-  return [reset, replacement];
-}
-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 agentProfileSchema3.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({ candidate: baseline.candidate, evaluation: baseline.evaluation }) !== canonicalCandidateDigest({ 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(baseline) === canonicalCandidateDigest(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(baselineRepository) !== canonicalCandidateDigest(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 } : {}
-  };
-}
-
-// 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 {
-  measuredComparisonFromCandidateExperiment,
-  runCandidateExperiment,
-  sealCandidateExperiment,
-  verifyCandidateExperiment,
-  verifyCandidateExperimentComparison
-} from "@tangle-network/agent-eval/contract";
-import {
-  agentCandidateMaterializationReceiptSchema,
-  agentCandidateRunReceiptSchema,
-  agentImprovementActivationSchema,
-  agentImprovementProposalSchema,
-  agentImprovementReviewSchema,
-  candidateExecutionEvidenceSchema
-} from "@tangle-network/agent-interface";
-import { materializeCandidateProfile } from "@tangle-network/agent-profile-materialize";
-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(", ")}`
-    );
-  }
-}
-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 });
-    }
-  });
-  const 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 } : {}
-  });
-  return { experiment, measurements, evaluation };
-}
-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)
-  });
-}
-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 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(experiment.baseline.profile) !== canonicalCandidateDigest(experiment.candidate.profile)) {
-    throw new Error("code improvement candidate changed the agent profile");
-  }
-}
-function createAgentImprovementProposal(options) {
-  const findings = assertNoJudgeVerdict(
-    [...options.findings],
-    "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");
-  }
-  if (options.runId !== evaluation.provenance.runId) {
-    throw new Error("proposal runId does not match its measured experiment");
-  }
-  const changedSurfaces = deriveChangedSurfaces(
-    evaluation.experiment.baseline,
-    evaluation.experiment.candidate
-  );
-  return agentImprovementProposalSchema.parse(
-    canonicalCandidateDocument({
-      kind: "agent-improvement-proposal",
-      runId: options.runId,
-      changedSurfaces,
-      proposedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
-      findings: [...findings],
-      evaluation
-    }).value
-  );
-}
-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
-  );
-}
-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,
-      candidateBundleDigest: experiment.candidate.digest,
-      intent: options.intent,
-      targets,
-      fundingOwner: options.fundingOwner,
-      authorizedBy: options.authorizedBy,
-      authorizedAt,
-      expiresAt: options.expiresAt
-    }).value
-  );
-}
-function verifyAgentImprovementProposal(input) {
-  const proposal = verifyCanonicalCandidateDocument(
-    agentImprovementProposalSchema.parse(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");
-  }
-  if (proposal.runId !== evaluation.provenance.runId) {
-    throw new Error("proposal runId does not match its measured experiment");
-  }
-  const changedSurfaces = deriveChangedSurfaces(
-    evaluation.experiment.baseline,
-    evaluation.experiment.candidate
-  );
-  if (!sameOrderedValues(proposal.changedSurfaces, changedSurfaces)) {
-    throw new Error("proposal changed surfaces do not match its exact experiment");
-  }
-  assertNoJudgeDerivedProposalFindings(proposal.findings);
-  return proposal;
-}
-function verifyAgentImprovementReview(input) {
-  return verifyCanonicalCandidateDocument(
-    agentImprovementReviewSchema.parse(input),
-    "agent improvement review"
-  );
-}
-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.candidateBundleDigest !== experiment.candidate.digest || 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;
-}
-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(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(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(", ")}]`
-  );
-}
-
-export {
-  AGENTIC_PROFILE_RESOURCE_ROOT,
-  agenticGenerator,
-  defaultBuildPrompt,
-  rawTraceEvidenceProblem,
-  requiresRawTraceEvidence,
-  commandVerifier,
-  summarizeFindings,
-  worktreeChangedPaths,
-  LIFTED_FINDING_ANALYST_ID,
-  isAnalystFinding,
-  toAnalystFindings,
-  ROLLOUT_POLICY_EXTENSION,
-  parseRolloutPolicy,
-  normalizeRolloutPolicy,
-  serializeRolloutPolicy,
-  structuralRolloutPolicyFromProfile,
-  applyRolloutPolicyToProfile,
-  rawTraceDistiller,
-  withMethodRuntimeControls,
-  improve,
-  AGENT_IMPROVEMENT_PROFILE_SURFACES,
-  buildAgentImprovementActivationTargets,
-  agentImprovementTargetDigest,
-  agentImprovementTargetInput,
-  isAgentImprovementProfileSurface,
-  agentImprovementProfileSurfaceInput,
-  agentImprovementProfileSurfaceDigest,
-  agentImprovementTargetProfileDiffs,
-  createOptimizationActivationReceipt,
-  optimizationActivationReceiptFromMetadata,
-  AgentCandidateExperimentCellExecutionError,
-  runAgentCandidateExperiment,
-  executeAgentCandidateExperimentCell,
-  createAgentImprovementMeasuredComparison,
-  proposeAgentImprovement,
-  createAgentImprovementProposal,
-  reviewAgentImprovementProposal,
-  createAgentImprovementActivation,
-  verifyAgentImprovementProposal,
-  verifyAgentImprovementReview,
-  verifyAgentImprovementActivation,
-  verifyCandidateExecutionEvidence
-};
-//# sourceMappingURL=chunk-UHEZW5BU.js.map