@tangle-network/agent-runtime 0.95.0 → 0.97.0

package/dist/chunk-PSOCBNM3.js

@@ -0,0 +1,2069 @@
+import {
+  agentCandidateProfileAsAgentProfile,
+  assertCandidateProfileBinding,
+  candidateMaterializerHarness,
+  canonicalCandidateBytes,
+  canonicalCandidateDigest,
+  canonicalCandidateDocument,
+  createAgentCandidateProfileActivation,
+  executePreparedAgentCandidate,
+  immutableCandidateValue,
+  omitTopLevelDigest,
+  parseAgentCandidateProfileActivation,
+  prepareAgentCandidateExecution,
+  verifiedResourceTextByDigest,
+  verifyAgentCandidateBundle,
+  verifyCanonicalCandidateDocument
+} from "./chunk-YOLKCWRV.js";
+import {
+  assertModelAllowed,
+  harnessInvocation,
+  runLocalHarness
+} from "./chunk-HZDEXTSL.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 improvementDriver'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
+    }) {
+      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++) {
+        if (signal.aborted) break;
+        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);
+        if (!execution) {
+          throw new Error("agenticGenerator: author shot completed without a harness result");
+        }
+        let worktreeChanged;
+        try {
+          worktreeChanged = dirty(worktreePath);
+        } catch (cause) {
+          return rethrowShotSetupError(
+            opts.onShotDisposition,
+            receipt,
+            worktreePath,
+            "worktree-inspection",
+            cause
+          );
+        }
+        if (!worktreeChanged) {
+          await emitShotDisposition(opts.onShotDisposition, receipt, {
+            kind: "clean",
+            worktreePath
+          });
+          attemptNote = EMPTY_TREE_NOTE;
+          continue;
+        }
+        if (needsRawTraceEvidence) {
+          let problem;
+          try {
+            problem = rawTraceEvidenceProblem(worktreePath, findings);
+          } catch (cause) {
+            return rethrowShotSetupError(
+              opts.onShotDisposition,
+              receipt,
+              worktreePath,
+              "raw-trace-evidence",
+              cause
+            );
+          }
+          if (problem) {
+            await emitShotDisposition(opts.onShotDisposition, receipt, {
+              kind: "rejected",
+              worktreePath,
+              stage: "raw-trace-evidence",
+              feedback: problem
+            });
+            attemptNote = problem;
+            continue;
+          }
+        }
+        if (!verify) {
+          await emitShotDisposition(opts.onShotDisposition, receipt, {
+            kind: "accepted",
+            worktreePath,
+            verified: false
+          });
+          return { applied: true, summary: summarize(findings) };
+        }
+        let result;
+        try {
+          result = await verify(worktreePath);
+        } catch (cause) {
+          return rethrowShotSetupError(
+            opts.onShotDisposition,
+            receipt,
+            worktreePath,
+            "verification",
+            cause
+          );
+        }
+        if (result.ok) {
+          await emitShotDisposition(opts.onShotDisposition, receipt, {
+            kind: "accepted",
+            worktreePath,
+            verified: true
+          });
+          return { applied: true, summary: summarize(findings) };
+        }
+        await emitShotDisposition(opts.onShotDisposition, receipt, {
+          kind: "rejected",
+          worktreePath,
+          stage: "verification",
+          feedback: result.feedback ?? null
+        });
+        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,
+    ...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,
+    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.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.",
+    "Make the smallest set of edits that addresses the findings below, then stop.",
+    "Do not change unrelated code. Do not commit \u2014 leave changes in the working tree.",
+    "",
+    "Findings:"
+  ];
+  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 (worktreePath) => {
+    const result = spawnSync(command, args, {
+      cwd: worktreePath,
+      encoding: "utf-8",
+      timeout: timeoutMs
+    });
+    if (result.signal) {
+      return {
+        ok: false,
+        feedback: `verifier '${command}' killed by ${result.signal} (likely timeout after ${timeoutMs}ms)`
+      };
+    }
+    if (result.error) {
+      const code = result.error.code;
+      if (code === "ENOENT") {
+        throw new Error(
+          `commandVerifier: '${command}' not found in PATH (setup bug, not a failed candidate)`
+        );
+      }
+      throw new Error(`commandVerifier: '${command}' failed to spawn: ${result.error.message}`);
+    }
+    if (result.status === 0) return { ok: true };
+    const out = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+    return { ok: false, feedback: out.length > 0 ? out : `exit ${result.status}` };
+  };
+}
+function summarize(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 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/improvement-driver.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import {
+  verifyCodeSurface
+} from "@tangle-network/agent-eval/campaign";
+
+// src/improvement/cleanup.ts
+async function rethrowAfterCleanup(cause, cleanup, context) {
+  const cleanupErrors = [];
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await cleanup();
+    } catch (cleanupCause) {
+      cleanupErrors.push(cleanupCause);
+      continue;
+    }
+    if (cleanupErrors.length === 0) throw cause;
+    throw new AggregateError([cause, ...cleanupErrors], `${context}; cleanup retry succeeded`);
+  }
+  throw new AggregateError([cause, ...cleanupErrors], `${context}; cleanup failed`);
+}
+
+// src/improvement/improvement-driver.ts
+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 } = 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(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) return f;
+  }
+  return ctx.findings;
+}
+
+// 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 } 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 [
+        makeFinding({
+          analyst_id: ANALYST_ID,
+          severity: "info",
+          area: "raw-trace-context",
+          confidence: 1,
+          claim: `Generation ${input.generation} had no failing cells. The full raw run traces are on disk under ${genRoot}.`,
+          recommended_action: `To keep improving, grep/cat the raw traces under ${genRoot} (per-cell spans.jsonl + cached-result.json) to find the weakest passing runs, then make a targeted harness-code edit.`,
+          evidence_refs: [{ kind: "artifact", uri: genRoot }],
+          metadata: { generation: input.generation, runDir: genRoot, failingCells: 0 }
+        })
+      ];
+    }
+    const findings = [];
+    findings.push(
+      makeFinding({
+        analyst_id: ANALYST_ID,
+        severity: "high",
+        area: "raw-trace-context",
+        confidence: 1,
+        claim: `Generation ${input.generation} produced ${totalFailingCells} failing/low-scoring cell(s) across ${ranked.length} candidate(s). Their FULL RAW run traces are on disk under ${genRoot} \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(
+        makeFinding({
+          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 { canonicalJson } from "@tangle-network/agent-eval";
+import {
+  gepaProposer,
+  gitWorktreeAdapter,
+  memoryCurationProposer,
+  skillOptProposer
+} from "@tangle-network/agent-eval/campaign";
+import {
+  selfImprove
+} from "@tangle-network/agent-eval/contract";
+import {
+  agentProfileSchema
+} from "@tangle-network/agent-interface";
+var defaultReflectionModel = "deepseek-v4-flash";
+function llmClientOptions(llm) {
+  return { baseUrl: llm?.baseUrl, apiKey: llm?.apiKey };
+}
+function defaultGeneratorFor(surface, llm) {
+  const model = llm?.model ?? defaultReflectionModel;
+  switch (surface) {
+    case "prompt":
+      return gepaProposer({ llm: llmClientOptions(llm), model, target: "agent system prompt" });
+    case "skills":
+      return skillOptProposer({ llm: llmClientOptions(llm), model, target: "agent skill document" });
+    case "memory":
+      return memoryCurationProposer();
+    default:
+      return void 0;
+  }
+}
+function baselineSurfaceFor(profile, surface, skills) {
+  switch (surface) {
+    case "prompt":
+      return profile.prompt?.systemPrompt ?? "";
+    case "skills":
+      return inlineSkill(profile, skills).content;
+    case "tools":
+      return JSON.stringify(profile.tools ?? {});
+    case "mcp":
+      return JSON.stringify(profile.mcp ?? {});
+    case "hooks":
+      return JSON.stringify(profile.hooks ?? {});
+    case "subagents":
+      return JSON.stringify(profile.subagents ?? {});
+    case "agent-profile":
+      return canonicalJson(profile);
+    case "memory":
+      return profileInstructions(profile);
+    case "code":
+      throw new ConfigError(
+        "improve(): code requires the isolated baseline created from opts.code.repoRoot"
+      );
+  }
+}
+var DISTILLED_NOTES_MAX_CHARS = 1500;
+var DISTILLED_ERROR_MAX_CHARS = 500;
+function generationFailureDistiller(staticFindings) {
+  const CAP = 12;
+  return async (input) => {
+    const failures = [];
+    for (const candidate of input.candidates) {
+      for (const rawCell of candidate.campaign.cells) {
+        const cell = rawCell;
+        const scenario = String(cell.scenarioId ?? "unknown");
+        const error = typeof cell.error === "string" ? cell.error : void 0;
+        const judgeScores = cell.judgeScores && typeof cell.judgeScores === "object" ? Object.values(
+          cell.judgeScores
+        ) : [];
+        const composite = judgeScores.length === 0 ? 0 : judgeScores.reduce((sum, j) => sum + (j.composite ?? 0), 0) / judgeScores.length;
+        if (!error && composite >= 0.999) continue;
+        const notes = judgeScores.map((j) => j.notes).filter((n) => typeof n === "string" && n.length > 0).join("; ").slice(0, DISTILLED_NOTES_MAX_CHARS);
+        const claim = notes || (error ? `Scenario ${scenario} failed: ${error.slice(0, DISTILLED_ERROR_MAX_CHARS)}` : "");
+        failures.push({
+          scenario,
+          composite: Number(composite.toFixed(3)),
+          notes,
+          ...claim ? { claim } : {},
+          ...error ? { error: error.slice(0, DISTILLED_ERROR_MAX_CHARS) } : {}
+        });
+      }
+    }
+    if (failures.length === 0) return staticFindings;
+    failures.sort((a, b) => a.composite - b.composite);
+    return failures.slice(0, CAP);
+  };
+}
+function memoryGenerationDistiller(staticFindings) {
+  const distillFailures = generationFailureDistiller(staticFindings);
+  return async (input) => {
+    const fresh = await distillFailures(input);
+    return fresh === staticFindings ? staticFindings : [...staticFindings, ...fresh];
+  };
+}
+async function discardPreparedBaseline(worktree, baselineWorktree, cause) {
+  return rethrowAfterCleanup(
+    cause,
+    () => worktree.discard(baselineWorktree),
+    "improve(): code preparation failed"
+  );
+}
+function isCodeSurface(surface) {
+  return typeof surface === "object" && surface !== null && surface.kind === "code";
+}
+async function prepareCodeRun(code) {
+  const baseRef = code.baseRef ?? "main";
+  const worktree = code.worktree ?? gitWorktreeAdapter({
+    repoRoot: code.repoRoot,
+    ...code.worktreeDir ? { worktreeDir: code.worktreeDir } : {}
+  });
+  const baselineWorktree = await worktree.create({ baseRef, label: "incumbent-baseline" });
+  try {
+    const baseline = await worktree.finalize(baselineWorktree, "Incumbent code checkout");
+    let baselineDiscarded = false;
+    const generator = code.generator ?? agenticGenerator({
+      ...code.harness ? { harness: code.harness } : {},
+      ...code.verify ? { verify: code.verify } : {},
+      ...code.timeoutMs ? { timeoutMs: code.timeoutMs } : {}
+    });
+    const managed = improvementDriver({ worktree, generator, baseRef });
+    return {
+      baseline,
+      proposer: managed,
+      async cleanup(retainedWinner) {
+        const errors = [];
+        const retainedWorktreeRef = isCodeSurface(retainedWinner) ? retainedWinner.worktreeRef : void 0;
+        try {
+          await managed?.cleanup(retainedWorktreeRef ? [retainedWorktreeRef] : []);
+        } catch (cause) {
+          errors.push(cause);
+        }
+        if (!baselineDiscarded && retainedWorktreeRef !== baseline.worktreeRef) {
+          try {
+            await worktree.discard(baselineWorktree);
+            baselineDiscarded = true;
+          } catch (cause) {
+            errors.push(cause);
+          }
+        }
+        if (errors.length > 0) {
+          throw new AggregateError(errors, "improve(): failed to clean code improvement worktrees");
+        }
+      }
+    };
+  } catch (cause) {
+    return discardPreparedBaseline(worktree, baselineWorktree, cause);
+  }
+}
+function idempotentDispose(dispose) {
+  let disposed = false;
+  let inFlight;
+  return async () => {
+    if (disposed) return;
+    if (inFlight) return inFlight;
+    inFlight = (async () => {
+      await dispose();
+      disposed = true;
+    })();
+    try {
+      await inFlight;
+    } finally {
+      inFlight = void 0;
+    }
+  };
+}
+function 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, winner) {
+  if (surface === "code" ? typeof winner === "string" : typeof winner !== "string") {
+    throw new ConfigError(
+      `improve(): the '${surface}' candidate returned an incompatible surface value`
+    );
+  }
+}
+function materializeImprovementProfileCandidate(profile, surface, winner, skills) {
+  if (typeof winner !== "string") return void 0;
+  let candidate;
+  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 "code":
+      return void 0;
+  }
+  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 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`
+    );
+  }
+}
+async function improve(profile, findings, opts) {
+  const {
+    surface = "prompt",
+    gate = "holdout",
+    generator,
+    allowedModels,
+    rawTraceContext,
+    code,
+    skills,
+    promotionGate,
+    analyzeGeneration,
+    ...sharedOptions
+  } = opts;
+  const parsedProfile = agentProfileSchema.safeParse(profile);
+  if (!parsedProfile.success) {
+    throw new ConfigError(
+      `improve(): input is not a valid AgentProfile: ${parsedProfile.error.message}`
+    );
+  }
+  if (surface === "code" && generator) {
+    throw new ConfigError(
+      "improve(): surface 'code' forbids opts.generator because an external SurfaceProposer cannot transfer checkout ownership; pass opts.code.generator instead"
+    );
+  }
+  const usesReflectionModel = !generator && (surface === "prompt" || surface === "skills");
+  if (usesReflectionModel) {
+    assertModelAllowed(sharedOptions.llm?.model ?? defaultReflectionModel, allowedModels);
+  }
+  let preparedCode;
+  if (surface === "code") {
+    if (!code) {
+      throw new ConfigError(
+        "improve(): surface 'code' requires opts.code.repoRoot so the incumbent can run from an isolated checkout"
+      );
+    }
+    preparedCode = await prepareCodeRun(code);
+  }
+  const proposer = preparedCode?.proposer ?? generator ?? defaultGeneratorFor(surface, sharedOptions.llm);
+  if (!proposer) {
+    throw new ConfigError(
+      `improve(): surface '${surface}' has no default generator \u2014 pass opts.generator (a SurfaceProposer) explicitly`
+    );
+  }
+  const budget = gate === "none" ? { ...sharedOptions.budget, generations: 0 } : { ...sharedOptions.budget };
+  let raw;
+  try {
+    raw = await selfImprove({
+      ...sharedOptions,
+      baselineSurface: preparedCode?.baseline ?? baselineSurfaceFor(parsedProfile.data, surface, skills),
+      proposer,
+      budget,
+      findings,
+      ...promotionGate !== void 0 ? { gate: promotionGate } : {},
+      ...analyzeGeneration === null ? {} : {
+        analyzeGeneration: analyzeGeneration ?? (rawTraceContext ? rawTraceDistiller({ fallbackFindings: findings }) : surface === "memory" ? memoryGenerationDistiller(findings) : generationFailureDistiller(findings))
+      }
+    });
+  } catch (cause) {
+    if (!preparedCode) throw cause;
+    return rethrowAfterCleanup(
+      cause,
+      () => preparedCode.cleanup(),
+      "improve(): code improvement failed"
+    );
+  }
+  const winnerSurface = raw.winner.surface;
+  assertCandidateSurfaceKind(surface, winnerSurface);
+  if (preparedCode) {
+    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 candidateProfile = materializeImprovementProfileCandidate(
+    parsedProfile.data,
+    surface,
+    winnerSurface,
+    skills
+  );
+  const candidate = immutableCandidateValue({
+    surface,
+    value: winnerSurface,
+    ...candidateProfile ? { profile: candidateProfile } : {}
+  });
+  return {
+    candidate,
+    decision: raw.gateDecision,
+    lift: raw.lift,
+    raw,
+    dispose
+  };
+}
+
+// src/intelligence/improvement-surfaces.ts
+var changedSurfaceOrder = [
+  "prompt",
+  "skills",
+  "tools",
+  "mcp",
+  "hooks",
+  "subagents",
+  "agent-profile",
+  "memory",
+  "code",
+  "knowledge"
+];
+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 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: {
+      prompt: profile.prompt ?? null
+    },
+    skills: profile.resources?.skills ?? null,
+    tools: {
+      tools: profile.tools ?? null,
+      resources: profile.resources?.tools ?? null
+    },
+    mcp: profile.mcp ?? null,
+    hooks: profile.hooks ?? null,
+    subagents: {
+      subagents: profile.subagents ?? null,
+      resources: profile.resources?.agents ?? null
+    },
+    "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/improvement-cycle.ts
+import { assertNoJudgeVerdict } from "@tangle-network/agent-eval/analyst";
+import {
+  measuredComparisonFromCandidateExperiment,
+  runCandidateExperiment,
+  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;
+  }
+};
+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) {
+  const analysis = await runAnalystLoop({ ...options.analysis, runId: options.runId });
+  const findings = assertNoJudgeVerdict(
+    analysis.analystResult.findings,
+    "proposeAgentImprovement findings"
+  );
+  const improvement = await improve(options.profile, [...findings], options.improvement);
+  try {
+    if (improvement.decision !== "ship") {
+      throw new Error("agent improvement search did not produce a promotable candidate");
+    }
+    const experiment = verifyCandidateExperiment(
+      await options.buildExperiment({ analysis, 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 } : {},
+      ...options.metadata ? { metadata: options.metadata } : {},
+      generationsExplored: improvement.raw.generationsExplored,
+      searchDurationMs: improvement.raw.durationMs,
+      searchCostUsd: improvement.raw.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") {
+    if (!candidate.profile) {
+      throw new Error(`improvement surface '${candidate.surface}' did not produce an exact profile`);
+    }
+    try {
+      assertCandidateProfileBinding(candidate.profile, experiment.candidate.profile);
+    } catch (cause) {
+      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);
+  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);
+  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(", ")}]`
+  );
+}
+
+// src/intelligence/activation.ts
+import {
+  agentImprovementActivationResultSchema,
+  agentImprovementActivationSchema as agentImprovementActivationSchema2
+} from "@tangle-network/agent-interface";
+function createAgentImprovementActivationResult(transition, options) {
+  const activation = verifyCanonicalCandidateDocument(
+    agentImprovementActivationSchema2.parse(transition.activation),
+    "agent improvement activation"
+  );
+  assertTransitionInput(activation, transition);
+  const result = agentImprovementActivationResultSchema.parse(
+    canonicalCandidateDocument({
+      kind: "agent-improvement-activation-result",
+      idempotencyKey: activation.digest,
+      attemptedAt: transition.attemptedAt,
+      completedAt: options.completedAt,
+      outcome: options.outcome
+    }).value
+  );
+  assertResultAgainstActivation(activation, result);
+  assertOutcomeDesiredState(
+    activation,
+    result,
+    new Map(transition.targets.map((target) => [targetIdentity(target), target.desiredDigest]))
+  );
+  return immutableCandidateValue(result);
+}
+function verifyAgentImprovementActivationResult(input) {
+  const proposal = verifyAgentImprovementProposal(input.proposal);
+  const activation = verifyAgentImprovementActivation(input);
+  const result = verifyCanonicalCandidateDocument(
+    agentImprovementActivationResultSchema.parse(input.result),
+    "agent improvement activation result"
+  );
+  assertResultAgainstActivation(activation, result);
+  assertResultDesiredState(proposal, activation, result);
+  return result;
+}
+async function executeAgentImprovementActivation(input, options) {
+  const proposal = verifyAgentImprovementProposal(input.proposal);
+  const activation = verifyAgentImprovementActivation(input);
+  const experiment = proposal.evaluation.experiment;
+  const targetArm = activation.intent === "activate-candidate" ? "candidate" : "baseline";
+  const observedAt = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  const attemptedAt = Date.parse(observedAt) < Date.parse(activation.authorizedAt) ? activation.authorizedAt : observedAt;
+  const transition = immutableCandidateValue({
+    activation,
+    candidateBundle: experiment.candidate,
+    bundle: experiment[targetArm],
+    targets: activation.targets.map((target) => ({
+      ...target,
+      desiredDigest: agentImprovementTargetDigest(experiment, targetArm, target.surface)
+    })),
+    attemptedAt,
+    expired: Date.parse(attemptedAt) >= Date.parse(activation.expiresAt)
+  });
+  if (transition.expired) {
+    if (!options.reconcile) {
+      return uncertainActivationResult(transition, "RECONCILIATION_UNAVAILABLE");
+    }
+    let reconciled;
+    try {
+      reconciled = await options.reconcile(transition);
+    } catch {
+      return uncertainActivationResult(transition, "RECONCILIATION_THROW");
+    }
+    if (reconciled === void 0) {
+      return createAgentImprovementActivationResult(transition, {
+        completedAt: transition.attemptedAt,
+        outcome: { status: "expired" }
+      });
+    }
+    try {
+      return verifyAgentImprovementActivationResult({ ...input, result: reconciled });
+    } catch {
+      return uncertainActivationResult(transition, "INVALID_RECONCILIATION");
+    }
+  }
+  let rawResult;
+  try {
+    rawResult = await options.transition(transition);
+  } catch {
+    return uncertainActivationResult(transition, "TRANSITION_THROW");
+  }
+  try {
+    return verifyAgentImprovementActivationResult({ ...input, result: rawResult });
+  } catch {
+    return uncertainActivationResult(transition, "INVALID_RESULT");
+  }
+}
+function uncertainActivationResult(transition, code) {
+  return createAgentImprovementActivationResult(transition, {
+    completedAt: transition.attemptedAt,
+    outcome: {
+      status: "indeterminate",
+      code,
+      message: "The product transition did not return a trustworthy commit result."
+    }
+  });
+}
+function assertTransitionInput(activation, transition) {
+  const authorized = targetMap(activation.targets);
+  const planned = targetMap(transition.targets);
+  if (authorized.size !== planned.size || [...authorized.entries()].some(
+    ([identity, target]) => planned.get(identity)?.expectedBaseDigest !== target.expectedBaseDigest
+  ) || transition.expired !== Date.parse(transition.attemptedAt) >= Date.parse(activation.expiresAt) || transition.candidateBundle.digest !== activation.candidateBundleDigest || activation.intent === "activate-candidate" && transition.bundle.digest !== transition.candidateBundle.digest) {
+    throw new Error("activation transition does not match its authorization");
+  }
+}
+function assertResultAgainstActivation(activation, result) {
+  const attemptedAt = Date.parse(result.attemptedAt);
+  const completedAt = Date.parse(result.completedAt);
+  const expiresAt = Date.parse(activation.expiresAt);
+  if (result.idempotencyKey !== activation.digest || attemptedAt < Date.parse(activation.authorizedAt) || completedAt < attemptedAt) {
+    throw new Error("activation result does not bind its authorization");
+  }
+  const expired = attemptedAt >= expiresAt;
+  if (result.outcome.status === "expired" && !expired || expired && !["expired", "indeterminate", "already-applied"].includes(result.outcome.status)) {
+    throw new Error("activation result does not honor its authorization expiry");
+  }
+  if (!("targets" in result.outcome)) return;
+  const authorized = targetMap(activation.targets);
+  const observed = new Set(result.outcome.targets.map(targetIdentity));
+  if (authorized.size !== observed.size || [...authorized.keys()].some((identity) => !observed.has(identity))) {
+    throw new Error("activation result must cover every authorized target exactly once");
+  }
+  if (result.outcome.status === "applied" && result.outcome.targets.some(
+    (target) => target.beforeDigest !== authorized.get(targetIdentity(target))?.expectedBaseDigest
+  )) {
+    throw new Error("applied activation did not start from its authorized base state");
+  }
+}
+function assertResultDesiredState(proposal, activation, result) {
+  if (!("targets" in result.outcome)) return;
+  const experiment = proposal.evaluation.experiment;
+  const targetArm = activation.intent === "activate-candidate" ? "candidate" : "baseline";
+  const desired = new Map(
+    activation.targets.map((target) => [
+      targetIdentity(target),
+      agentImprovementTargetDigest(experiment, targetArm, target.surface)
+    ])
+  );
+  assertOutcomeDesiredState(activation, result, desired);
+}
+function assertOutcomeDesiredState(activation, result, desired) {
+  if (!("targets" in result.outcome)) return;
+  if (result.outcome.status === "applied") {
+    if (result.outcome.targets.some(
+      (target) => target.afterDigest !== desired.get(targetIdentity(target))
+    )) {
+      throw new Error("applied activation does not match the requested bundle");
+    }
+    return;
+  }
+  const allDesired = result.outcome.targets.every(
+    (target) => target.currentDigest === desired.get(targetIdentity(target))
+  );
+  if (result.outcome.status === "already-applied") {
+    if (!allDesired) throw new Error("already-applied activation is not at the requested state");
+    return;
+  }
+  const authorized = targetMap(activation.targets);
+  const hasStaleTarget = result.outcome.targets.some(
+    (target) => target.currentDigest !== authorized.get(targetIdentity(target))?.expectedBaseDigest
+  );
+  if (allDesired || !hasStaleTarget) {
+    throw new Error("activation conflict does not identify stale target state");
+  }
+}
+function targetMap(targets) {
+  return new Map(targets.map((target) => [targetIdentity(target), target]));
+}
+function targetIdentity(target) {
+  return `${target.surface}\0${target.identity}`;
+}
+
+export {
+  AGENTIC_PROFILE_RESOURCE_ROOT,
+  agenticGenerator,
+  commandVerifier,
+  improvementDriver,
+  rawTraceDistiller,
+  improve,
+  buildAgentImprovementActivationTargets,
+  AgentCandidateExperimentCellExecutionError,
+  runAgentCandidateExperiment,
+  executeAgentCandidateExperimentCell,
+  createAgentImprovementMeasuredComparison,
+  proposeAgentImprovement,
+  createAgentImprovementProposal,
+  reviewAgentImprovementProposal,
+  createAgentImprovementActivation,
+  verifyAgentImprovementProposal,
+  verifyAgentImprovementReview,
+  verifyAgentImprovementActivation,
+  verifyCandidateExecutionEvidence,
+  createAgentImprovementActivationResult,
+  verifyAgentImprovementActivationResult,
+  executeAgentImprovementActivation
+};
+//# sourceMappingURL=chunk-PSOCBNM3.js.map