@tangle-network/agent-runtime 0.90.1 → 0.92.0

package/dist/index.js

@@ -1,7 +1,13 @@
+import {
+  FileAgentCandidateExecutionClaimStore,
+  createProtectedAgentCandidateModelPort,
+  disposePreparedAgentCandidateExecution,
+  recoverExpiredAgentCandidateExecution
+} from "./chunk-PH65PR4F.js";
 import {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "./chunk-QK4DV5PR.js";
+} from "./chunk-AUEIDTR3.js";
 import {
   DEFAULT_ROUTER_BASE_URL,
   cleanModelId,
@@ -20,27 +26,53 @@ import {
   runLoopRunnerCli,
   selfImproveLoopRunner,
   worktreeLoopRunner
-} from "./chunk-WRUSWK4F.js";
+} from "./chunk-IGGZGKJD.js";
 import "./chunk-SGKPNBXE.js";
+import {
+  ROLLOUT_POLICY_BOUNDS,
+  ROLLOUT_POLICY_EXTENSION,
+  applyRolloutPolicyToProfile,
+  enumerateNeighborPolicies,
+  improve,
+  improvementDriver,
+  normalizeRolloutPolicy,
+  parseRolloutPolicy,
+  rawTraceDistiller,
+  rolloutPolicyProposer,
+  serializeRolloutPolicy,
+  structuralRolloutPolicyFromProfile
+} from "./chunk-RSWM2ZKM.js";
+import {
+  CANDIDATE_TRACE_ENV,
+  CANDIDATE_TRACE_TAGS,
+  InMemoryAgentCandidateExecutionClaimStore,
+  candidateExecutionClaim,
+  executePreparedAgentCandidate,
+  persistCandidateOutputArtifact,
+  prepareAgentCandidateExecution,
+  verifyAgentCandidateBundle
+} from "./chunk-A62TP7SK.js";
 import {
   InMemoryRuntimeSessionStore,
   createIterableBackend,
   createOpenAICompatibleBackend,
   createSandboxPromptBackend,
-  defaultStructuralRolloutPolicy,
   newRuntimeSession,
   normalizeBackendStreamEvent,
   nowIso,
   touchSession
-} from "./chunk-ZV4LXYCJ.js";
+} from "./chunk-I7WVPJBZ.js";
+import "./chunk-3BE7KTMU.js";
 import "./chunk-ZQZX77MM.js";
 import {
-  agenticGenerator,
-  commandVerifier,
   mcpBuildPrompt,
   mcpServeVerifier,
   toolBuildPrompt
-} from "./chunk-OOL3675H.js";
+} from "./chunk-6O73TRHW.js";
+import {
+  agenticGenerator,
+  commandVerifier
+} from "./chunk-FRBHUNQ7.js";
 import {
   RESEARCH_SUPERVISOR_SYSTEM_PROMPT,
   createAgentKnowledgeReadinessCheck,
@@ -49,25 +81,31 @@ import {
   knowledgeReadinessDeliverable,
   runKnowledgeImprovementJob,
   runSupervisedKnowledgeUpdate
-} from "./chunk-R2VAJGR3.js";
+} from "./chunk-7VJJJ2T2.js";
 import "./chunk-5QOB7H74.js";
-import {
-  assertModelAllowed,
-  composeRuntimeHooks,
-  defineRuntimeHooks,
-  notifyRuntimeDecisionPoint,
-  notifyRuntimeHookEvent
-} from "./chunk-RYBVU4M3.js";
+import "./chunk-6O5USWVH.js";
 import "./chunk-DPEUKJRO.js";
 import {
   INTELLIGENCE_WIRE_VERSION,
   buildLoopOtelSpans,
   buildLoopSpanNodes,
+  buildRuntimeEventOtelSpans,
+  composeRuntimeHooks,
   createOtelExporter,
+  createRuntimeEventCollector,
+  createRuntimeStreamEventCollector,
+  defineRuntimeHooks,
   exportEvalRuns,
-  loopEventToOtelSpan
-} from "./chunk-IVGYLCFH.js";
-import "./chunk-BZF3KQ6G.js";
+  loopEventToOtelSpan,
+  notifyRuntimeDecisionPoint,
+  notifyRuntimeHookEvent,
+  sanitizeAgentRuntimeEvent,
+  sanitizeKnowledgeReadinessReport,
+  sanitizeRuntimeStreamEvent
+} from "./chunk-APVPRF4Y.js";
+import "./chunk-3D2RHC4K.js";
+import "./chunk-VSWBYWFK.js";
+import "./chunk-3MDZX7YU.js";
 import "./chunk-FVJ7M3DA.js";
 import "./chunk-CMYMTRGA.js";
 import {
@@ -182,7 +220,7 @@ function computeBackoff(spec, attempt) {
   return Math.max(0, spec);
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/conversation/headers.ts
@@ -1282,508 +1320,6 @@ function deriveExecutionId(input) {
   return `${input.projectId}:${input.sessionId}:${input.turnIndex}`;
 }
 
-// src/improvement/improve.ts
-import {
-  gepaProposer,
-  gitWorktreeAdapter,
-  skillOptProposer
-} from "@tangle-network/agent-eval/campaign";
-import {
-  selfImprove
-} from "@tangle-network/agent-eval/contract";
-
-// src/improvement/improvement-driver.ts
-function improvementDriver(opts) {
-  const baseRef = opts.baseRef ?? "main";
-  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 = [];
-      for (let i = 0; i < ctx.populationSize; i++) {
-        if (ctx.signal.aborted) break;
-        const wt = await opts.worktree.create({
-          baseRef,
-          label: `${opts.generator.kind}-gen${ctx.generation}-cand${i}`
-        });
-        try {
-          const { applied, summary } = await opts.generator.generate({
-            worktreePath: wt.path,
-            report: ctx.report,
-            findings,
-            dataset: ctx.dataset,
-            maxShots: ctx.maxImprovementShots ?? 1,
-            signal: ctx.signal
-          });
-          if (!applied) {
-            await opts.worktree.discard(wt);
-            continue;
-          }
-          surfaces.push(await opts.worktree.finalize(wt, summary));
-        } catch (err) {
-          await opts.worktree.discard(wt).catch(() => {
-          });
-          throw err;
-        }
-      }
-      return surfaces;
-    }
-  };
-}
-function resolveFindings(ctx) {
-  const report = ctx.report;
-  if (report && typeof report === "object" && "findings" in report) {
-    const f = report.findings;
-    if (Array.isArray(f) && f.length > 0) return f;
-  }
-  return ctx.findings;
-}
-
-// src/improvement/raw-trace-distiller.ts
-import { existsSync, readdirSync } from "fs";
-import { basename, join, resolve } from "path";
-import { makeFinding } from "@tangle-network/agent-eval";
-var ANALYST_ID = "raw-trace-distiller";
-var PASS_THRESHOLD = 0.999;
-function rawTraceDistiller(options = {}) {
-  const maxCandidates = options.maxCandidates ?? 12;
-  const maxCellsPerCandidate = options.maxCellsPerCandidate ?? 8;
-  const maxFilesPerCell = options.maxFilesPerCell ?? 24;
-  return async (input) => {
-    const genRoot = absoluteRunDir(options.runDir ?? input.runDir);
-    const durable = isDurable(genRoot);
-    const ranked = [...input.candidates].map((c) => ({
-      surfaceHash: c.surfaceHash,
-      composite: c.composite,
-      campaignDir: absoluteRunDir(c.campaign.runDir),
-      cells: failingCells(c.campaign, maxCellsPerCandidate, maxFilesPerCell)
-    })).sort((a, b) => a.composite - b.composite).slice(0, maxCandidates);
-    const totalFailingCells = ranked.reduce((n, c) => n + c.cells.length, 0);
-    if (totalFailingCells === 0) {
-      if (options.fallbackFindings && options.fallbackFindings.length > 0) {
-        return options.fallbackFindings;
-      }
-      return [
-        makeFinding({
-          analyst_id: ANALYST_ID,
-          severity: "info",
-          area: "raw-trace-context",
-          confidence: 1,
-          claim: `Generation ${input.generation} had no failing cells. The full raw run traces are on disk under ${genRoot}.`,
-          recommended_action: `To keep improving, grep/cat the raw traces under ${genRoot} (per-cell spans.jsonl + cached-result.json) to find the weakest passing runs, then make a targeted harness-code edit.`,
-          evidence_refs: [{ kind: "artifact", uri: genRoot }],
-          metadata: { generation: input.generation, runDir: genRoot, failingCells: 0 }
-        })
-      ];
-    }
-    const findings = [];
-    findings.push(
-      makeFinding({
-        analyst_id: ANALYST_ID,
-        severity: "high",
-        area: "raw-trace-context",
-        confidence: 1,
-        claim: `Generation ${input.generation} produced ${totalFailingCells} failing/low-scoring cell(s) across ${ranked.length} candidate(s). Their FULL RAW run traces are on disk under ${genRoot} \u2014 the actual event logs (spans.jsonl), scores (cached-result.json), and artifacts, not a summary.${durable ? "" : " (WARNING: this run root does not exist on disk \u2014 it looks like an in-memory run; pass a real runDir to improve() to get raw-trace context.)"}`,
-        recommended_action: `Do NOT rely on a pre-summarized finding. Before editing, DIAGNOSE from the raw traces: run \`grep\`/\`cat\`/\`ls\` over the trace files and directories named in the following findings to see exactly what each failing run did and why it scored low, then make the smallest harness-code edit that fixes the dominant failure. Start with \`grep -rIn "error" ${genRoot}\` then \`cat\` the spans.jsonl of the worst cell.`,
-        evidence_refs: [{ kind: "artifact", uri: genRoot }],
-        metadata: {
-          generation: input.generation,
-          runDir: genRoot,
-          failingCells: totalFailingCells,
-          candidates: ranked.length
-        }
-      })
-    );
-    for (const cand of ranked) {
-      if (cand.cells.length === 0) continue;
-      const scenarioList = cand.cells.map((c) => c.scenarioId).join(", ");
-      const fileLines = cand.cells.map((c) => {
-        const header = `  cell ${c.scenarioId} (composite ${c.composite.toFixed(3)}${c.error ? `, error: ${truncate(c.error, 160)}` : ""}) \u2014 dir ${c.cellDir}`;
-        const files = c.files.map((f) => `    - ${f}`).join("\n");
-        const more = c.truncatedFiles ? `
-    - \u2026(ls ${c.cellDir} for the rest)` : "";
-        return c.files.length > 0 ? `${header}
-${files}${more}` : header;
-      }).join("\n");
-      findings.push(
-        makeFinding({
-          analyst_id: ANALYST_ID,
-          severity: cand.composite < 0.5 ? "critical" : "high",
-          area: "raw-trace-context",
-          confidence: 1,
-          subject: cand.surfaceHash,
-          claim: `Candidate ${cand.surfaceHash} scored composite ${cand.composite.toFixed(3)} with ${cand.cells.length} failing cell(s) [${scenarioList}]. Its raw traces are under ${cand.campaignDir}.`,
-          recommended_action: `grep/cat these raw trace files to diagnose WHY this candidate failed before editing:
-${fileLines}
-Or scan the whole candidate at once: \`grep -rIn . ${cand.campaignDir}\` and \`ls -R ${cand.campaignDir}\`.`,
-          evidence_refs: [
-            { kind: "artifact", uri: cand.campaignDir },
-            ...cand.cells.flatMap(
-              (c) => c.files.map((f) => ({ kind: "artifact", uri: f }))
-            )
-          ],
-          metadata: {
-            surfaceHash: cand.surfaceHash,
-            composite: cand.composite,
-            campaignDir: cand.campaignDir,
-            cells: cand.cells.map((c) => ({
-              scenarioId: c.scenarioId,
-              composite: c.composite,
-              cellDir: c.cellDir,
-              files: c.files,
-              ...c.error ? { error: c.error } : {}
-            }))
-          }
-        })
-      );
-    }
-    return findings;
-  };
-}
-function failingCells(campaign, maxCells, maxFiles) {
-  const campaignDir = absoluteRunDir(campaign.runDir);
-  const durable = isDurable(campaignDir);
-  const out = [];
-  for (const cell of campaign.cells) {
-    const scores = Object.values(cell.judgeScores ?? {});
-    const composite = scores.length === 0 ? 0 : scores.reduce((sum, s) => sum + (s.composite ?? 0), 0) / scores.length;
-    if (!cell.error && composite >= PASS_THRESHOLD) continue;
-    const cellDir = join(campaignDir, sanitizeCellId(cell.cellId));
-    const artifactPaths = artifactPathsForCell(campaign.artifactsByPath, cell.cellId);
-    const discovered = durable ? listTraceFiles(cellDir) : [];
-    const canonical = [join(cellDir, "spans.jsonl"), join(cellDir, "cached-result.json")];
-    const files = dedupeSorted([...discovered, ...artifactPaths, ...canonical]);
-    out.push({
-      scenarioId: cell.scenarioId,
-      composite: Number(composite.toFixed(3)),
-      ...cell.error ? { error: cell.error } : {},
-      cellDir,
-      files: files.slice(0, maxFiles),
-      truncatedFiles: files.length > maxFiles
-    });
-    if (out.length >= maxCells) break;
-  }
-  return out;
-}
-function artifactPathsForCell(artifactsByPath, cellId) {
-  if (!artifactsByPath) return [];
-  const prefix = `${cellId}/`;
-  return Object.entries(artifactsByPath).filter(([key]) => key.startsWith(prefix)).map(([, absPath]) => resolve(absPath));
-}
-function listTraceFiles(dir) {
-  const out = [];
-  for (const entry of safeReadDir(dir)) {
-    const full = join(dir, entry.name);
-    if (entry.isFile()) {
-      out.push(full);
-    } else if (!entry.isSymbolicLink() && entry.isDirectory()) {
-      for (const sub of safeReadDir(full)) {
-        if (sub.isFile()) out.push(join(full, sub.name));
-      }
-    }
-  }
-  return out;
-}
-function safeReadDir(dir) {
-  try {
-    return readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-function sanitizeCellId(cellId) {
-  return cellId.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function isDurable(runDir) {
-  return !runDir.startsWith("mem://") && existsSync(runDir);
-}
-function absoluteRunDir(runDir) {
-  return runDir.startsWith("mem://") ? runDir : resolve(runDir);
-}
-function dedupeSorted(paths) {
-  return [...new Set(paths)].sort((a, b) => {
-    const da = a.slice(0, a.length - basename(a).length);
-    const db = b.slice(0, b.length - basename(b).length);
-    return da === db ? basename(a).localeCompare(basename(b)) : da.localeCompare(db);
-  });
-}
-function truncate(s, n) {
-  return s.length <= n ? s : `${s.slice(0, n - 1)}\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
-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 "rollout-policy":
-      return rolloutPolicyProposer();
-    default:
-      return void 0;
-  }
-}
-function baselineSurfaceFor(profile, surface, skills) {
-  switch (surface) {
-    case "prompt":
-      return profile.prompt?.systemPrompt ?? "";
-    case "skills":
-      return skills?.document ?? JSON.stringify(profile.resources?.skills ?? []);
-    case "tools":
-      return JSON.stringify(profile.tools ?? {});
-    case "mcp":
-      return JSON.stringify(profile.mcp ?? {});
-    case "hooks":
-      return JSON.stringify(profile.hooks ?? {});
-    case "rollout-policy": {
-      const policy = structuralRolloutPolicyFromProfile(profile);
-      return policy ? serializeRolloutPolicy(policy) : "";
-    }
-    case "code":
-      return "";
-  }
-}
-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, 400);
-        failures.push({
-          scenario,
-          composite: Number(composite.toFixed(3)),
-          notes,
-          ...error ? { error: error.slice(0, 200) } : {}
-        });
-      }
-    }
-    if (failures.length === 0) return staticFindings;
-    failures.sort((a, b) => a.composite - b.composite);
-    return failures.slice(0, CAP);
-  };
-}
-function codeProposerFor(surface, code) {
-  if (surface !== "code" || !code) return void 0;
-  const generator = code.generator ?? agenticGenerator({
-    ...code.harness ? { harness: code.harness } : {},
-    ...code.verify ? { verify: code.verify } : {},
-    ...code.timeoutMs ? { timeoutMs: code.timeoutMs } : {}
-  });
-  return improvementDriver({
-    worktree: gitWorktreeAdapter({
-      repoRoot: code.repoRoot,
-      ...code.worktreeDir ? { worktreeDir: code.worktreeDir } : {}
-    }),
-    generator,
-    ...code.baseRef ? { baseRef: code.baseRef } : {}
-  });
-}
-function parseWinnerJson(winner, surface) {
-  try {
-    return JSON.parse(winner);
-  } catch (cause) {
-    throw new ConfigError(
-      `improve(): the shipped '${surface}' winner is not valid JSON, so it cannot be applied back to the profile: ${cause.message}`
-    );
-  }
-}
-function applyWinnerToProfile(profile, surface, winner) {
-  if (typeof winner !== "string") return profile;
-  switch (surface) {
-    case "prompt":
-      return { ...profile, prompt: { ...profile.prompt, systemPrompt: winner } };
-    case "skills":
-      return {
-        ...profile,
-        resources: { ...profile.resources, skills: parseWinnerJson(winner, surface) }
-      };
-    case "tools":
-      return { ...profile, tools: parseWinnerJson(winner, surface) };
-    case "mcp":
-      return { ...profile, mcp: parseWinnerJson(winner, surface) };
-    case "hooks":
-      return { ...profile, hooks: parseWinnerJson(winner, surface) };
-    case "rollout-policy": {
-      const policy = normalizeRolloutPolicy(parseWinnerJson(winner, surface));
-      if (!policy) {
-        throw new ConfigError(
-          `improve(): the shipped 'rollout-policy' winner is not a valid StructuralRolloutPolicy (integer k >= 1, repairRounds >= 0, testgen >= 0), so it cannot be applied: ${winner}`
-        );
-      }
-      return applyRolloutPolicyToProfile(profile, policy);
-    }
-    case "code":
-      return profile;
-  }
-}
-async function improve(profile, findings, opts) {
-  const surface = opts.surface ?? "prompt";
-  const gate = opts.gate ?? "holdout";
-  assertModelAllowed(opts.llm?.model ?? defaultReflectionModel, opts.allowedModels);
-  const proposer = opts.generator ?? defaultGeneratorFor(surface, opts.llm) ?? codeProposerFor(surface, opts.code);
-  if (!proposer) {
-    throw new ConfigError(
-      surface === "code" ? `improve(): surface 'code' needs either opts.generator or opts.code ({ repoRoot, ... }) \u2014 there is no safe zero-config repo to invent` : `improve(): surface '${surface}' has no default generator \u2014 pass opts.generator (a SurfaceProposer) explicitly`
-    );
-  }
-  const budget = gate === "none" ? { ...opts.budget, generations: 0 } : { ...opts.budget };
-  const raw = await selfImprove({
-    agent: opts.agent,
-    scenarios: opts.scenarios,
-    judge: opts.judge,
-    baselineSurface: baselineSurfaceFor(profile, surface, opts.skills),
-    proposer,
-    budget,
-    llm: opts.llm,
-    findings,
-    ...opts.runDir !== void 0 ? { runDir: opts.runDir } : {},
-    ...opts.storage !== void 0 ? { storage: opts.storage } : {},
-    ...opts.analyzeGeneration === null ? {} : {
-      analyzeGeneration: opts.analyzeGeneration ?? (opts.rawTraceContext ? rawTraceDistiller({ fallbackFindings: findings }) : generationFailureDistiller(findings))
-    }
-  });
-  const shipped = raw.gateDecision === "ship";
-  const usedSkillDocument = surface === "skills" && opts.skills !== void 0;
-  if (shipped && usedSkillDocument && typeof raw.winner.surface === "string") {
-    opts.skills?.writeBack?.(raw.winner.surface);
-  }
-  const nextProfile = shipped && !usedSkillDocument ? applyWinnerToProfile(profile, surface, raw.winner.surface) : profile;
-  return { profile: nextProfile, shipped, lift: raw.lift, gateDecision: raw.gateDecision, raw };
-}
-
 // src/improvement/reflective-generator.ts
 import { spawnSync } from "child_process";
 function reflectiveGenerator(opts) {
@@ -2359,374 +1895,6 @@ function randomSuffix() {
   return Math.random().toString(36).slice(2, 10);
 }
 
-// src/sanitize.ts
-function sanitizeKnowledgeReadinessReport(report, options = {}) {
-  return {
-    taskId: report.taskId,
-    readinessScore: report.readinessScore,
-    recommendedAction: report.recommendedAction,
-    severity: report.severity,
-    reason: report.reason,
-    blockingMissingRequirements: report.blockingMissingRequirements.map(
-      (requirement) => sanitizeKnowledgeRequirement(requirement, options)
-    ),
-    nonBlockingGaps: report.nonBlockingGaps.map(
-      (requirement) => sanitizeKnowledgeRequirement(requirement, options)
-    ),
-    evidenceCount: report.bundle.evidenceIds.length,
-    evidenceIds: options.includeEvidenceIds ? report.bundle.evidenceIds : void 0,
-    missingRequirementIds: report.bundle.missing.map((requirement) => requirement.id)
-  };
-}
-function sanitizeAgentRuntimeEvent(event, options = {}) {
-  const base = { type: event.type, task: sanitizeTask(event.task, options) };
-  if (event.type === "readiness_start" || event.type === "task_start" || event.type === "control_start") {
-    return event.type === "control_start" ? { ...base, knowledge: sanitizeKnowledgeReadinessReport(event.knowledge, options) } : base;
-  }
-  if (event.type === "readiness_end") {
-    return { ...base, knowledge: sanitizeKnowledgeReadinessReport(event.knowledge, options) };
-  }
-  if (event.type === "questions_start") {
-    return {
-      ...base,
-      questions: event.questions.map((question) => sanitizeQuestion(question, options))
-    };
-  }
-  if (event.type === "questions_end") {
-    return {
-      ...base,
-      questions: event.questions.map((question) => sanitizeQuestion(question, options)),
-      userAnswers: options.includeUserAnswers ? event.userAnswers : redactRecord(event.userAnswers)
-    };
-  }
-  if (event.type === "acquisition_start") {
-    return { ...base, acquisitionPlans: event.acquisitionPlans.map(sanitizeAcquisitionPlan) };
-  }
-  if (event.type === "acquisition_end") {
-    return {
-      ...base,
-      acquisitionPlans: event.acquisitionPlans.map(sanitizeAcquisitionPlan),
-      acquiredEvidenceCount: event.acquiredEvidenceIds.length,
-      acquiredEvidenceIds: options.includeEvidenceIds ? event.acquiredEvidenceIds : void 0
-    };
-  }
-  if (event.type === "control_step") {
-    return { ...base, step: sanitizeControlStep(event.step, options) };
-  }
-  if (event.type === "control_end") {
-    return { ...base, control: sanitizeControlRun(event.control, options) };
-  }
-  return { ...base, status: event.status, reason: event.reason };
-}
-function sanitizeRuntimeStreamEvent(event, options = {}) {
-  const withTask = "task" in event && event.task ? { task: sanitizeTask(event.task, options) } : {};
-  const withSession = "session" in event && event.session ? { session: sanitizeRuntimeSession(event.session, options) } : {};
-  if (event.type === "readiness_end") {
-    return {
-      type: event.type,
-      ...withTask,
-      timestamp: event.timestamp,
-      decision: event.decision,
-      knowledge: sanitizeKnowledgeReadinessReport(event.knowledge, options)
-    };
-  }
-  if (event.type === "questions_start") {
-    return {
-      type: event.type,
-      ...withTask,
-      timestamp: event.timestamp,
-      questions: event.questions.map((question) => sanitizeQuestion(question, options))
-    };
-  }
-  if (event.type === "questions_end") {
-    return {
-      type: event.type,
-      ...withTask,
-      timestamp: event.timestamp,
-      questions: event.questions.map((question) => sanitizeQuestion(question, options)),
-      userAnswers: options.includeUserAnswers ? event.userAnswers : redactRecord(event.userAnswers)
-    };
-  }
-  if (event.type === "acquisition_start") {
-    return {
-      type: event.type,
-      ...withTask,
-      timestamp: event.timestamp,
-      acquisitionPlans: event.acquisitionPlans.map(sanitizeAcquisitionPlan)
-    };
-  }
-  if (event.type === "acquisition_end") {
-    return {
-      type: event.type,
-      ...withTask,
-      timestamp: event.timestamp,
-      acquisitionPlans: event.acquisitionPlans.map(sanitizeAcquisitionPlan),
-      acquiredEvidenceCount: event.acquiredEvidenceIds.length,
-      acquiredEvidenceIds: options.includeEvidenceIds ? event.acquiredEvidenceIds : void 0
-    };
-  }
-  if (event.type === "tool_call") {
-    return {
-      type: event.type,
-      ...withTask,
-      ...withSession,
-      timestamp: event.timestamp,
-      toolName: event.toolName,
-      toolCallId: event.toolCallId,
-      args: options.includeControlPayloads ? event.args : void 0
-    };
-  }
-  if (event.type === "tool_result") {
-    return {
-      type: event.type,
-      ...withTask,
-      ...withSession,
-      timestamp: event.timestamp,
-      toolName: event.toolName,
-      toolCallId: event.toolCallId,
-      result: options.includeControlPayloads ? event.result : void 0
-    };
-  }
-  if (event.type === "llm_call") {
-    return {
-      type: event.type,
-      ...withTask,
-      ...withSession,
-      timestamp: event.timestamp,
-      model: event.model,
-      tokensIn: event.tokensIn,
-      tokensOut: event.tokensOut,
-      costUsd: event.costUsd,
-      latencyMs: event.latencyMs,
-      finishReason: event.finishReason
-    };
-  }
-  if (event.type === "artifact") {
-    return {
-      type: event.type,
-      ...withTask,
-      ...withSession,
-      timestamp: event.timestamp,
-      artifactId: event.artifactId,
-      name: event.name,
-      mimeType: event.mimeType,
-      uri: options.includeEvidenceIds ? event.uri : void 0,
-      content: options.includeControlPayloads ? event.content : void 0,
-      metadata: options.includeMetadata ? event.metadata : void 0
-    };
-  }
-  if (event.type === "proposal_created") {
-    return {
-      type: event.type,
-      ...withTask,
-      ...withSession,
-      timestamp: event.timestamp,
-      proposalId: event.proposalId,
-      title: options.includeControlPayloads ? event.title : void 0,
-      content: options.includeControlPayloads ? event.content : void 0,
-      status: event.status
-    };
-  }
-  if (event.type === "final") {
-    const sanitizedError = event.error !== void 0 ? {
-      kind: event.error.kind,
-      message: event.error.message,
-      status: event.error.status,
-      body: options.includeControlPayloads ? event.error.body : void 0
-    } : void 0;
-    return {
-      type: event.type,
-      ...withTask,
-      ...withSession,
-      timestamp: event.timestamp,
-      status: event.status,
-      reason: event.reason,
-      text: options.includeControlPayloads ? event.text : void 0,
-      metadata: options.includeMetadata ? event.metadata : void 0,
-      ...sanitizedError !== void 0 ? { error: sanitizedError } : {}
-    };
-  }
-  return {
-    type: event.type,
-    ...withTask,
-    ...withSession,
-    timestamp: "timestamp" in event ? event.timestamp : void 0,
-    ...pickPublicStreamFields(event)
-  };
-}
-function sanitizeTask(task, options) {
-  return {
-    id: task.id,
-    intent: task.intent,
-    domain: task.domain,
-    inputs: options.includeInputs ? task.inputs : task.inputs ? "[redacted]" : void 0,
-    requiredKnowledge: task.requiredKnowledge?.map(
-      (requirement) => sanitizeKnowledgeRequirement(requirement, options)
-    ),
-    metadata: options.includeMetadata ? task.metadata : task.metadata ? "[redacted]" : void 0
-  };
-}
-function sanitizeRuntimeSession(session, options) {
-  return {
-    id: session.id,
-    backend: session.backend,
-    status: session.status,
-    hasResumeToken: Boolean(session.resumeToken),
-    createdAt: session.createdAt,
-    updatedAt: session.updatedAt,
-    metadata: options.includeMetadata ? session.metadata : session.metadata ? "[redacted]" : void 0
-  };
-}
-function sanitizeKnowledgeRequirement(requirement, options) {
-  const includeDescription = options.includeRequirementDescriptions && requirement.sensitivity !== "secret";
-  return {
-    id: requirement.id,
-    description: includeDescription ? requirement.description : void 0,
-    requiredFor: requirement.requiredFor,
-    category: requirement.category,
-    acquisitionMode: requirement.acquisitionMode,
-    importance: requirement.importance,
-    freshness: requirement.freshness,
-    sensitivity: requirement.sensitivity,
-    confidenceNeeded: requirement.confidenceNeeded,
-    currentConfidence: requirement.currentConfidence,
-    evidenceCount: requirement.evidenceIds.length,
-    evidenceIds: options.includeEvidenceIds ? requirement.evidenceIds : void 0,
-    fallbackPolicy: requirement.fallbackPolicy
-  };
-}
-function sanitizeQuestion(question, options) {
-  return {
-    id: question.id,
-    question: options.includeRequirementDescriptions && question.answerType !== "credential" ? question.question : void 0,
-    reason: options.includeRequirementDescriptions ? question.reason : void 0,
-    requirementId: question.requirementId,
-    importance: question.importance,
-    answerType: question.answerType,
-    impactIfUnknown: options.includeRequirementDescriptions ? question.impactIfUnknown : void 0,
-    optionCount: question.options?.length ?? 0
-  };
-}
-function sanitizeAcquisitionPlan(plan) {
-  return {
-    id: plan.id,
-    requirementIds: plan.requirementIds,
-    mode: plan.mode,
-    priority: plan.priority,
-    expectedEvidenceCount: plan.expectedEvidenceIds?.length ?? 0,
-    questionCount: plan.questions?.length ?? 0
-  };
-}
-function sanitizeControlStep(step, options) {
-  const actionOutcome = step.actionOutcome;
-  return {
-    index: step.index,
-    decisionType: step.decision.type,
-    reason: step.decision.reason,
-    action: options.includeControlPayloads && step.decision.type === "continue" ? step.decision.action : void 0,
-    result: options.includeControlPayloads && actionOutcome?.ok ? actionOutcome.result : void 0,
-    actionOk: actionOutcome?.ok,
-    actionError: actionOutcome?.ok === false ? actionOutcome.error : void 0,
-    durationMs: actionOutcome?.durationMs,
-    evalsBefore: summarizeEvals(step.evalsBefore, options),
-    evalsAfter: summarizeEvals(step.evalsAfter, options),
-    startedAt: step.startedAt,
-    endedAt: step.endedAt
-  };
-}
-function sanitizeControlRun(control, options) {
-  return {
-    pass: control.pass,
-    completed: control.completed,
-    reason: control.reason,
-    score: control.score,
-    stepCount: control.steps.length,
-    wallMs: control.wallMs,
-    spentCostUsd: control.spentCostUsd,
-    failureClass: control.failureClass,
-    stoppedBy: control.stoppedBy,
-    runId: control.runId,
-    runtimeErrorCount: control.runtimeErrors.length,
-    finalEvals: summarizeEvals(control.finalEvals, options)
-  };
-}
-function summarizeEvals(evals, options) {
-  return evals.map((evalResult) => ({
-    id: evalResult.id,
-    passed: evalResult.passed,
-    score: evalResult.score,
-    severity: evalResult.severity,
-    objective: evalResult.objective,
-    detail: options.includeEvalDetails ? evalResult.detail : void 0,
-    evidence: options.includeEvalDetails ? evalResult.evidence : void 0
-  }));
-}
-function redactRecord(record) {
-  return Object.fromEntries(Object.keys(record).map((key) => [key, "[redacted]"]));
-}
-function pickPublicStreamFields(event) {
-  if (event.type === "session_created" || event.type === "session_resumed") return {};
-  if (event.type === "backend_start" || event.type === "backend_end")
-    return { backend: event.backend };
-  if (event.type === "backend_error") {
-    const sanitizedError = event.error !== void 0 ? {
-      kind: event.error.kind,
-      status: event.error.status
-    } : void 0;
-    return {
-      backend: event.backend,
-      message: event.message,
-      recoverable: event.recoverable,
-      ...sanitizedError !== void 0 ? { error: sanitizedError } : {}
-    };
-  }
-  if (event.type === "task_end") return { status: event.status, reason: event.reason };
-  if (event.type === "text_delta" || event.type === "reasoning_delta") return { text: event.text };
-  return {};
-}
-function createRuntimeEventCollector(options = {}) {
-  const events = [];
-  return {
-    events,
-    onEvent: (event) => {
-      events.push(sanitizeAgentRuntimeEvent(event, options));
-    }
-  };
-}
-function createRuntimeStreamEventCollector(options = {}) {
-  const events = [];
-  const eventCountsByType = {};
-  let firstSessionId;
-  let finalStatus;
-  let finalReason;
-  let finalText = "";
-  return {
-    events,
-    onEvent: (event) => {
-      events.push(sanitizeRuntimeStreamEvent(event, options));
-      eventCountsByType[event.type] = (eventCountsByType[event.type] ?? 0) + 1;
-      if (event.type === "text_delta") finalText += event.text;
-      if (!firstSessionId && (event.type === "session_created" || event.type === "session_resumed")) {
-        firstSessionId = event.session.id;
-      }
-      if (event.type === "final") {
-        finalStatus = event.status;
-        finalReason = event.reason;
-      }
-    },
-    summary() {
-      return {
-        eventCount: events.length,
-        eventCountsByType: { ...eventCountsByType },
-        firstSessionId,
-        finalStatus,
-        finalReason,
-        finalText
-      };
-    }
-  };
-}
-
 // src/sse.ts
 function encodeServerSentEvent(data, options = {}) {
   const lines = [];
@@ -3247,6 +2415,8 @@ function randomSuffix2(len = 8) {
 export {
   AgentEvalError,
   BackendTransportError,
+  CANDIDATE_TRACE_ENV,
+  CANDIDATE_TRACE_TAGS,
   CircuitBreakerState,
   CircuitOpenError,
   ConfigError,
@@ -3255,8 +2425,10 @@ export {
   DELEGATED_LOOP_MODES,
   DeadlineExceededError,
   FORWARD_HEADERS,
+  FileAgentCandidateExecutionClaimStore,
   FileConversationJournal,
   INTELLIGENCE_WIRE_VERSION,
+  InMemoryAgentCandidateExecutionClaimStore,
   InMemoryConversationJournal,
   InMemoryRuntimeSessionStore,
   JudgeError,
@@ -3275,6 +2447,8 @@ export {
   buildForwardHeaders,
   buildLoopOtelSpans,
   buildLoopSpanNodes,
+  buildRuntimeEventOtelSpans,
+  candidateExecutionClaim,
   cleanModelId,
   commandVerifier,
   composeRuntimeHooks,
@@ -3284,6 +2458,7 @@ export {
   createIterableBackend,
   createOpenAICompatibleBackend,
   createOtelExporter,
+  createProtectedAgentCandidateModelPort,
   createRuntimeEventCollector,
   createRuntimeStreamEventCollector,
   createSandboxPromptBackend,
@@ -3294,7 +2469,9 @@ export {
   defineConversation,
   defineRuntimeHooks,
   deriveExecutionId,
+  disposePreparedAgentCandidateExecution,
   enumerateNeighborPolicies,
+  executePreparedAgentCandidate,
   exportEvalRuns,
   formatSupervisedKnowledgeTask,
   getModels,
@@ -3315,9 +2492,12 @@ export {
   notifyRuntimeHookEvent,
   parseLoopRunnerArgv,
   parseRolloutPolicy,
+  persistCandidateOutputArtifact,
+  prepareAgentCandidateExecution,
   rawTraceDistiller,
   readDepth,
   readinessServerSentEvent,
+  recoverExpiredAgentCandidateExecution,
   reflectiveGenerator,
   researchLoopRunner,
   resolveAgentBackend,
@@ -3349,6 +2529,7 @@ export {
   toolBuildPrompt,
   turnId,
   validateChatModelId,
+  verifyAgentCandidateBundle,
   worktreeLoopRunner
 };
 //# sourceMappingURL=index.js.map