@tangle-network/agent-runtime 0.104.0 → 0.106.0

package/dist/chunk-FJI3EXU3.js

@@ -1,2402 +0,0 @@
-import {
-  agentCandidateProfileAsAgentProfile,
-  assertCandidateProfileBinding,
-  candidateMaterializerHarness,
-  canonicalCandidateBytes,
-  canonicalCandidateDigest,
-  canonicalCandidateDocument,
-  createAgentCandidateProfileActivation,
-  executePreparedAgentCandidate,
-  immutableCandidateValue,
-  omitTopLevelDigest,
-  omitUndefinedObjectFields,
-  parseAgentCandidateProfileActivation,
-  parseExactAgentProfile,
-  prepareAgentCandidateExecution,
-  verifiedResourceTextByDigest,
-  verifyAgentCandidateBundle,
-  verifyCanonicalCandidateDocument
-} from "./chunk-SBTWKPVR.js";
-import {
-  defaultStructuralRolloutPolicy,
-  optimizerMethod
-} from "./chunk-STJEHM5F.js";
-import {
-  assertModelAllowed,
-  harnessInvocation,
-  runLocalHarness,
-  runSettledCommand
-} from "./chunk-2X65HYMI.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
-    }) {
-      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/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, 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/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/rollout-policy.ts
-var ROLLOUT_POLICY_EXTENSION = "structural-rollout";
-var ROLLOUT_POLICY_BOUNDS = {
-  k: { min: 1, max: 10, step: 2 },
-  repairRounds: { min: 0, max: 3, step: 1 },
-  testgen: { min: 0, max: 10, step: 3 }
-};
-var MAX_CANDIDATES_PER_GENERATION = 4;
-var clamp = (v, min, max) => Math.min(max, Math.max(min, v));
-var isBoundedInt = (v, min) => typeof v === "number" && Number.isInteger(v) && v >= min;
-function parseRolloutPolicy(surface) {
-  if (typeof surface !== "string" || surface.trim().length === 0) return void 0;
-  let raw;
-  try {
-    raw = JSON.parse(surface);
-  } catch {
-    return void 0;
-  }
-  return normalizeRolloutPolicy(raw);
-}
-function normalizeRolloutPolicy(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
-  const bag = raw;
-  const k = bag.k ?? defaultStructuralRolloutPolicy.k;
-  const repairRounds = bag.repairRounds ?? defaultStructuralRolloutPolicy.repairRounds;
-  const testgen = bag.testgen ?? defaultStructuralRolloutPolicy.testgen;
-  if (!isBoundedInt(k, 1) || !isBoundedInt(repairRounds, 0) || !isBoundedInt(testgen, 0)) {
-    return void 0;
-  }
-  return {
-    k,
-    repairRounds,
-    testgen,
-    ...typeof bag.diverse === "boolean" ? { diverse: bag.diverse } : {},
-    ...typeof bag.temperature === "number" ? { temperature: bag.temperature } : {}
-  };
-}
-function serializeRolloutPolicy(policy) {
-  return JSON.stringify({
-    k: policy.k,
-    repairRounds: policy.repairRounds,
-    testgen: policy.testgen,
-    ...policy.diverse !== void 0 ? { diverse: policy.diverse } : {},
-    ...policy.temperature !== void 0 ? { temperature: policy.temperature } : {}
-  });
-}
-function structuralRolloutPolicyFromProfile(profile) {
-  const bag = profile.extensions?.[ROLLOUT_POLICY_EXTENSION];
-  if (bag === void 0) return void 0;
-  return normalizeRolloutPolicy(bag);
-}
-function applyRolloutPolicyToProfile(profile, policy) {
-  const bag = {
-    k: policy.k,
-    repairRounds: policy.repairRounds,
-    testgen: policy.testgen,
-    ...policy.diverse !== void 0 ? { diverse: policy.diverse } : {},
-    ...policy.temperature !== void 0 ? { temperature: policy.temperature } : {}
-  };
-  return {
-    ...profile,
-    extensions: { ...profile.extensions, [ROLLOUT_POLICY_EXTENSION]: bag }
-  };
-}
-function enumerateNeighborPolicies(policy) {
-  const moves = [
-    { dial: "k", delta: 1 },
-    { dial: "k", delta: -1 },
-    { dial: "repairRounds", delta: 1 },
-    { dial: "repairRounds", delta: -1 },
-    { dial: "testgen", delta: 1 },
-    { dial: "testgen", delta: -1 }
-  ];
-  const seen = /* @__PURE__ */ new Set([serializeRolloutPolicy(policy)]);
-  const neighbors = [];
-  for (const move of moves) {
-    const bounds = ROLLOUT_POLICY_BOUNDS[move.dial];
-    const next = clamp(policy[move.dial] + move.delta * bounds.step, bounds.min, bounds.max);
-    const candidate = { ...policy, [move.dial]: next };
-    const key = serializeRolloutPolicy(candidate);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    neighbors.push(candidate);
-  }
-  return neighbors;
-}
-function candidateLabel(base, next) {
-  for (const dial of ["k", "repairRounds", "testgen"]) {
-    if (next[dial] !== base[dial]) return `${dial} ${base[dial]}\u2192${next[dial]}`;
-  }
-  return "unchanged";
-}
-function rolloutPolicyProposer() {
-  return {
-    kind: "rollout-policy",
-    async propose(ctx) {
-      const policy = parseRolloutPolicy(ctx.currentSurface);
-      if (!policy) return [];
-      const neighbors = enumerateNeighborPolicies(policy);
-      if (neighbors.length === 0) return [];
-      const cap = Math.max(1, Math.min(ctx.populationSize, MAX_CANDIDATES_PER_GENERATION));
-      const start = ctx.generation * cap % neighbors.length;
-      const window = [];
-      for (let i = 0; i < Math.min(cap, neighbors.length); i += 1) {
-        window.push(neighbors[(start + i) % neighbors.length]);
-      }
-      return window.map((candidate) => ({
-        surface: serializeRolloutPolicy(candidate),
-        label: candidateLabel(policy, candidate),
-        rationale: "bounded single-dial neighbor of the current structuralRollout policy; the held-out gate decides (deterministic enumeration \u2014 the dial space is tiny and prompt-style reflective proposals are a measured zero here)"
-      }));
-    }
-  };
-}
-
-// src/improvement/improve.ts
-import { canonicalJson, makeFinding as makeFinding3 } from "@tangle-network/agent-eval";
-import {
-  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();
-    case "rollout-policy":
-      return rolloutPolicyProposer();
-    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 "rollout-policy": {
-      const policy = structuralRolloutPolicyFromProfile(profile);
-      return policy ? serializeRolloutPolicy(policy) : "";
-    }
-    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).map(
-      (f) => makeFinding3({
-        analyst_id: "generation-failure-distiller",
-        severity: f.error !== void 0 || f.composite < 0.5 ? "high" : "medium",
-        area: "generation-failure",
-        confidence: 1,
-        subject: f.scenario,
-        claim: `Scenario ${f.scenario} scored composite ${f.composite}${f.notes ? `: ${f.notes}` : ""}${f.error ? ` (error: ${f.error})` : ""}`,
-        evidence_refs: [],
-        metadata: {
-          scenario: f.scenario,
-          composite: f.composite,
-          ...f.notes ? { notes: f.notes } : {},
-          ...f.error !== void 0 ? { error: f.error } : {}
-        }
-      })
-    );
-  };
-}
-function memoryGenerationDistiller(staticFindings) {
-  const distillFailures = generationFailureDistiller(staticFindings);
-  return async (input) => {
-    const fresh = await distillFailures(input);
-    return fresh === staticFindings ? staticFindings : [...staticFindings, ...fresh];
-  };
-}
-function defaultDistillerFor(opts, findings) {
-  const surface = opts.surface ?? "prompt";
-  const durableRun = opts.runDir !== void 0 && !opts.runDir.startsWith("mem://");
-  const useRawTraces = opts.rawTraceContext ?? (surface === "memory" ? false : durableRun);
-  if (useRawTraces) return rawTraceDistiller({ fallbackFindings: findings });
-  if (surface === "memory") return memoryGenerationDistiller(findings);
-  return generationFailureDistiller(findings);
-}
-async function discardPreparedBaseline(worktree, baselineWorktree, cause) {
-  return rethrowAfterCleanup(
-    cause,
-    () => worktree.discard(baselineWorktree),
-    "improve(): code preparation failed"
-  );
-}
-function isCodeSurface(surface) {
-  return typeof surface === "object" && surface !== null && surface.kind === "code";
-}
-async function prepareCodeRun(code) {
-  const baseRef = code.baseRef ?? "main";
-  const worktree = code.worktree ?? gitWorktreeAdapter({
-    repoRoot: code.repoRoot,
-    ...code.worktreeDir ? { worktreeDir: code.worktreeDir } : {}
-  });
-  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 "rollout-policy": {
-      if (winner === "") return void 0;
-      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;
-    }
-    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 profileImprovementAgent(input) {
-  return (surfaceValue, scenario, ctx) => {
-    const profile = materializeImprovementProfileCandidate(
-      input.baselineProfile,
-      input.surface,
-      surfaceValue,
-      input.skills
-    );
-    const dispatchedProfile = profile ?? (input.surface === "rollout-policy" && surfaceValue === "" ? input.baselineProfile : void 0);
-    if (!dispatchedProfile) {
-      throw new ConfigError(
-        `improve(): surface '${input.surface}' cannot run through profileDispatch; use opts.agent for a non-profile surface`
-      );
-    }
-    return input.dispatch(dispatchedProfile, scenario, ctx);
-  };
-}
-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",
-    agent,
-    profileDispatch,
-    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 (agent !== void 0 && profileDispatch !== void 0) {
-    throw new ConfigError("improve(): provide exactly one of opts.agent or opts.profileDispatch");
-  }
-  if (agent === void 0 && profileDispatch === void 0) {
-    throw new ConfigError("improve(): provide exactly one of opts.agent or opts.profileDispatch");
-  }
-  const baselineProfile = immutableCandidateValue(parsedProfile.data);
-  if (profileDispatch && surface === "code") {
-    throw new ConfigError(
-      "improve(): surface 'code' cannot use profileDispatch because code candidates require isolated worktree execution; use opts.agent"
-    );
-  }
-  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 };
-  const effectiveAgent = profileDispatch === void 0 ? agent : profileImprovementAgent({
-    baselineProfile,
-    surface,
-    ...skills === void 0 ? {} : { skills },
-    dispatch: profileDispatch
-  });
-  if (!effectiveAgent) {
-    throw new ConfigError("improve(): provide exactly one of opts.agent or opts.profileDispatch");
-  }
-  let raw;
-  try {
-    raw = await selfImprove({
-      ...sharedOptions,
-      agent: effectiveAgent,
-      baselineSurface: preparedCode?.baseline ?? baselineSurfaceFor(baselineProfile, surface, skills),
-      proposer,
-      budget,
-      findings,
-      ...promotionGate !== void 0 ? { gate: promotionGate } : {},
-      ...analyzeGeneration === null ? {} : {
-        analyzeGeneration: analyzeGeneration ?? defaultDistillerFor(opts, 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(
-    baselineProfile,
-    surface,
-    winnerSurface,
-    skills
-  );
-  const candidate = immutableCandidateValue({
-    surface,
-    value: winnerSurface,
-    ...candidateProfile ? { profile: candidateProfile } : {}
-  });
-  return {
-    candidate,
-    decision: raw.gateDecision,
-    ...raw.lift !== void 0 ? { lift: raw.lift } : {},
-    raw,
-    dispose
-  };
-}
-
-// src/intelligence/improvement-surfaces.ts
-import {
-  agentProfileDiffSchema,
-  agentProfileSchema as agentProfileSchema2,
-  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 agentProfileSchema2.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/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.raw.provenance.runId],
-    developmentSplitDigest: improvement.raw.provenance.evidence.search.splitDigest
-  };
-  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) {
-  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 = 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 } : {},
-      ...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(", ")}]`
-  );
-}
-
-export {
-  AGENTIC_PROFILE_RESOURCE_ROOT,
-  agenticGenerator,
-  defaultBuildPrompt,
-  rawTraceEvidenceProblem,
-  requiresRawTraceEvidence,
-  commandVerifier,
-  summarizeFindings,
-  worktreeChangedPaths,
-  LIFTED_FINDING_ANALYST_ID,
-  isAnalystFinding,
-  toAnalystFindings,
-  improvementDriver,
-  rawTraceDistiller,
-  ROLLOUT_POLICY_EXTENSION,
-  ROLLOUT_POLICY_BOUNDS,
-  parseRolloutPolicy,
-  normalizeRolloutPolicy,
-  serializeRolloutPolicy,
-  structuralRolloutPolicyFromProfile,
-  applyRolloutPolicyToProfile,
-  enumerateNeighborPolicies,
-  rolloutPolicyProposer,
-  improve,
-  AGENT_IMPROVEMENT_PROFILE_SURFACES,
-  buildAgentImprovementActivationTargets,
-  agentImprovementTargetDigest,
-  agentImprovementTargetInput,
-  isAgentImprovementProfileSurface,
-  agentImprovementProfileSurfaceInput,
-  agentImprovementProfileSurfaceDigest,
-  agentImprovementTargetProfileDiffs,
-  AgentCandidateExperimentCellExecutionError,
-  runAgentCandidateExperiment,
-  executeAgentCandidateExperimentCell,
-  createAgentImprovementMeasuredComparison,
-  proposeAgentImprovement,
-  createAgentImprovementProposal,
-  reviewAgentImprovementProposal,
-  createAgentImprovementActivation,
-  verifyAgentImprovementProposal,
-  verifyAgentImprovementReview,
-  verifyAgentImprovementActivation,
-  verifyCandidateExecutionEvidence
-};
-//# sourceMappingURL=chunk-FJI3EXU3.js.map