@tangle-network/agent-runtime 0.105.0 → 0.106.0

package/dist/chunk-WRTOVNN4.js

@@ -1,4728 +0,0 @@
-import {
-  newRuntimeSession,
-  normalizeBackendStreamEvent,
-  nowIso
-} from "./chunk-Q2JSAVQ3.js";
-import {
-  createExecutor,
-  createExecutorRegistry,
-  createSandboxLineage,
-  createWorktreeCliExecutor,
-  defaultSelectWinner,
-  gateOnDeliverable,
-  probeSandboxCapabilities,
-  rollingDispatch,
-  runAgentRounds,
-  supervise
-} from "./chunk-XBG2W2VW.js";
-import {
-  observe,
-  refine,
-  runAgentic,
-  sample,
-  sampleThenRefine,
-  strategyAuthorMethod
-} from "./chunk-YJZA2BIK.js";
-import {
-  redactProtectedReason,
-  redactProtectedValue
-} from "./chunk-UPWGXKXB.js";
-import {
-  createSupervisor,
-  notifyRuntimeHookEvent,
-  routerBrain,
-  runBrainLoop,
-  settledToIteration,
-  withDriverExecutor
-} from "./chunk-HLKC4UYB.js";
-import {
-  InMemoryResultBlobStore,
-  InMemorySpawnJournal
-} from "./chunk-ISPWRSEC.js";
-import {
-  addTokenUsage,
-  isAbortError,
-  randomSuffix,
-  sleep,
-  stringifySafe,
-  zeroTokenUsage
-} from "./chunk-3MDZX7YU.js";
-import {
-  createSandboxToolPartState,
-  mapSandboxEvent,
-  mapSandboxToolEvent
-} from "./chunk-M22PL4GH.js";
-import {
-  AnalystError,
-  BackendTransportError,
-  PlannerError,
-  ValidationError
-} from "./chunk-YEJR7IXO.js";
-
-// src/runtime/index.ts
-import { computeFindingId, makeFinding } from "@tangle-network/agent-eval";
-
-// src/runtime/audit-intent.ts
-var defaultAuditorInstruction = "You audit whether an AI agent is on the RIGHT ROUTE \u2014 not whether it works hard, but whether its actions serve the stated intents. Infer the REVEALED intent from the action pattern (what the trajectory is actually optimizing). Compare against the declared task intent, the user intent when given, and the meta-intent when given. Flawless execution down the wrong route is DIVERGED. Busy-work that neither advances nor harms is DRIFTING. Judge only from the trajectory \u2014 be specific about which actions ground your verdict. Recommend abort only when continuing cannot serve the intent.";
-function summarize(trace, maxLines) {
-  const lines = [];
-  for (const ev of trace) {
-    const e = ev;
-    const role = e.role;
-    if (role === "tool") lines.push(`RESULT ${String(e.content).slice(0, 200)}`);
-    else if (role === "assistant") {
-      const calls = e.tool_calls?.map((c) => `${c.function?.name}(${(c.function?.arguments ?? "").slice(0, 120)})`).join(", ");
-      lines.push(calls ? `CALL ${calls}` : `SAY ${String(e.content).slice(0, 160)}`);
-    } else if (role === "user") lines.push(`USER ${String(e.content).slice(0, 160)}`);
-  }
-  return lines.slice(-maxLines).join("\n");
-}
-var auditSchema = {
-  name: "intent_audit",
-  schema: {
-    type: "object",
-    additionalProperties: false,
-    required: ["revealedIntent", "verdict", "evidence", "recommendation", "confidence"],
-    properties: {
-      revealedIntent: { type: "string" },
-      verdict: { type: "string", enum: ["aligned", "drifting", "diverged"] },
-      evidence: { type: "string" },
-      recommendation: { type: "string", enum: ["continue", "steer", "abort"] },
-      steer: { type: "string" },
-      confidence: { type: "number" }
-    }
-  }
-};
-async function auditIntent(input, opts) {
-  const res = await opts.chat.chat(
-    {
-      ...opts.model ? { model: opts.model } : {},
-      jsonSchema: auditSchema,
-      messages: [
-        { role: "system", content: opts.auditorInstruction ?? defaultAuditorInstruction },
-        {
-          role: "user",
-          content: `DECLARED INTENT (the task):
-${input.declaredIntent}
-
-` + (input.userIntent ? `USER INTENT (the principal's actual goal):
-${input.userIntent}
-
-` : "") + (input.metaIntent ? `META-INTENT (what the whole run is for):
-${input.metaIntent}
-
-` : "") + `TRAJECTORY (in order):
-${summarize(input.trace, opts.maxTraceLines ?? 80)}
-
-Audit the route: revealed intent, verdict, evidence, one recommendation.`
-        }
-      ]
-    },
-    { ...opts.signal ? { signal: opts.signal } : {} }
-  );
-  let parsed;
-  try {
-    parsed = JSON.parse(res.content);
-  } catch {
-    throw new Error(`auditIntent: auditor returned non-JSON: ${res.content.slice(0, 200)}`);
-  }
-  if (!parsed.verdict || !parsed.recommendation) {
-    throw new Error(`auditIntent: missing verdict/recommendation: ${res.content.slice(0, 200)}`);
-  }
-  return {
-    revealedIntent: parsed.revealedIntent ?? "",
-    verdict: parsed.verdict,
-    evidence: parsed.evidence ?? "",
-    recommendation: parsed.recommendation,
-    ...parsed.steer ? { steer: parsed.steer } : {},
-    confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5
-  };
-}
-
-// src/runtime/benchmark-report.ts
-import {
-  benjaminiHochberg,
-  confidenceInterval,
-  pairedBootstrap,
-  pairedTTest,
-  wilson
-} from "@tangle-network/agent-eval";
-var defaultScoreOf = (r) => {
-  const o = r.outcome;
-  if (typeof o.holdoutScore === "number") return o.holdoutScore;
-  if (typeof o.searchScore === "number") return o.searchScore;
-  const raw = o.raw ?? {};
-  for (const k of ["composite", "score", "passed", "resolved"]) {
-    if (typeof raw[k] === "number") return raw[k];
-  }
-  return void 0;
-};
-var defaultProfileKeyOf = (r) => {
-  const cell = r.agentProfile;
-  const harness = cell?.harness;
-  return harness ? `${harness}\xB7${r.model}` : r.model;
-};
-var defaultGroupOf = (r) => r.scenarioId ?? r.experimentId;
-function quantile(sorted, q) {
-  if (sorted.length === 0) return 0;
-  const idx = Math.min(sorted.length - 1, Math.floor(q * (sorted.length - 1)));
-  return sorted[idx] ?? 0;
-}
-function mean(xs) {
-  return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
-}
-function meanByScenario(records, scoreOf) {
-  const sums = /* @__PURE__ */ new Map();
-  for (const r of records) {
-    const s = scoreOf(r);
-    if (typeof s !== "number") continue;
-    const id = r.scenarioId;
-    if (!id) {
-      throw new Error(
-        `benchmark-report: RunRecord (candidate ${r.candidateId ?? "unknown"}) is missing scenarioId \u2014 cannot pair or interval it honestly. Pass opts.stats only on a scenario-tagged corpus.`
-      );
-    }
-    const acc = sums.get(id) ?? { total: 0, n: 0 };
-    acc.total += s;
-    acc.n += 1;
-    sums.set(id, acc);
-  }
-  const out = /* @__PURE__ */ new Map();
-  for (const [id, acc] of sums) out.set(id, acc.n ? acc.total / acc.n : 0);
-  return out;
-}
-function leaderboard(records, opts = {}) {
-  const scoreOf = opts.scoreOf ?? defaultScoreOf;
-  const profileKeyOf = opts.profileKeyOf ?? defaultProfileKeyOf;
-  const groupOf = opts.groupOf ?? defaultGroupOf;
-  const labelOf = opts.labelOf ?? ((k) => k);
-  const axisSet = /* @__PURE__ */ new Set();
-  if (opts.axisScoresOf) {
-    for (const r of records) for (const k of Object.keys(opts.axisScoresOf(r))) axisSet.add(k);
-  } else {
-    for (const r of records) axisSet.add(groupOf(r));
-  }
-  const axes = [...axisSet].sort();
-  const byProfile = /* @__PURE__ */ new Map();
-  for (const r of records) {
-    const key = profileKeyOf(r);
-    const bucket = byProfile.get(key);
-    if (bucket) bucket.push(r);
-    else byProfile.set(key, [r]);
-  }
-  const rows = [];
-  for (const [profileKey, recs] of byProfile) {
-    const scores = recs.map(scoreOf).filter((s) => typeof s === "number");
-    const axisBuckets = /* @__PURE__ */ new Map();
-    for (const r of recs) {
-      if (opts.axisScoresOf) {
-        for (const [axis, s] of Object.entries(opts.axisScoresOf(r))) {
-          const b = axisBuckets.get(axis) ?? [];
-          b.push(s);
-          axisBuckets.set(axis, b);
-        }
-      } else {
-        const s = scoreOf(r);
-        if (typeof s === "number") {
-          const axis = groupOf(r);
-          const b = axisBuckets.get(axis) ?? [];
-          b.push(s);
-          axisBuckets.set(axis, b);
-        }
-      }
-    }
-    const perAxis = {};
-    for (const [axis, b] of axisBuckets) perAxis[axis] = mean(b);
-    const latencies = recs.map((r) => r.wallMs).sort((a, b) => a - b);
-    const pass = opts.passThreshold ?? 0.999;
-    let scoreCi;
-    let passCi;
-    if (opts.stats) {
-      const collapsed = [...meanByScenario(recs, scoreOf).values()];
-      if (collapsed.length > 0) {
-        const ci2 = confidenceInterval(collapsed, 0.95, { seed: 7 });
-        scoreCi = { lower: ci2.lower, upper: ci2.upper };
-        const w = wilson(collapsed.filter((s) => s >= pass).length, collapsed.length, 0.95);
-        passCi = { lower: w.lower, upper: w.upper };
-      }
-    }
-    rows.push({
-      profileKey,
-      label: labelOf(profileKey),
-      model: recs[0]?.model ?? profileKey,
-      n: recs.length,
-      meanScore: mean(scores),
-      solveRate: scores.length === 0 ? 0 : scores.filter((s) => s >= pass).length / scores.length,
-      perAxis,
-      costUsd: recs.reduce((a, r) => a + r.costUsd, 0),
-      tokensIn: recs.reduce((a, r) => a + (r.tokenUsage?.input ?? 0), 0),
-      tokensOut: recs.reduce((a, r) => a + (r.tokenUsage?.output ?? 0), 0),
-      latencyP50Ms: quantile(latencies, 0.5),
-      latencyP90Ms: quantile(latencies, 0.9),
-      ...scoreCi ? { scoreCi } : {},
-      ...passCi ? { passCi } : {}
-    });
-  }
-  rows.sort(
-    (a, b) => b.meanScore - a.meanScore || a.costUsd - b.costUsd || a.label.localeCompare(b.label)
-  );
-  const models = [...new Set(records.map((r) => r.model))].sort();
-  return {
-    title: opts.title ?? "Benchmark report",
-    axes,
-    profiles: rows,
-    meta: opts.meta ?? {},
-    provenance: {
-      records: records.length,
-      profiles: rows.length,
-      axes: axes.length,
-      models,
-      totalCostUsd: records.reduce((a, r) => a + r.costUsd, 0)
-    }
-  };
-}
-function pairwiseSignificance(records, opts = {}) {
-  const scoreOf = opts.scoreOf ?? defaultScoreOf;
-  const profileKeyOf = opts.profileKeyOf ?? defaultProfileKeyOf;
-  const labelOf = opts.labelOf ?? ((k) => k);
-  const minPairs = opts.minPairs ?? 12;
-  const byProfile = /* @__PURE__ */ new Map();
-  for (const r of records) {
-    const k = profileKeyOf(r);
-    const b = byProfile.get(k);
-    if (b) b.push(r);
-    else byProfile.set(k, [r]);
-  }
-  const keys = [...byProfile.keys()].sort();
-  const collapsed = new Map(keys.map((k) => [k, meanByScenario(byProfile.get(k) ?? [], scoreOf)]));
-  const raw = [];
-  for (let i = 0; i < keys.length; i += 1) {
-    for (let j = i + 1; j < keys.length; j += 1) {
-      const ka = keys[i];
-      const kb = keys[j];
-      const am = collapsed.get(ka);
-      const bm = collapsed.get(kb);
-      const aScores = [];
-      const bScores = [];
-      for (const sid of [...am.keys()].sort()) {
-        const bv = bm.get(sid);
-        if (bv !== void 0) {
-          aScores.push(am.get(sid));
-          bScores.push(bv);
-        }
-      }
-      if (aScores.length === 0) continue;
-      const boot = pairedBootstrap(aScores, bScores, { seed: 7, statistic: "median" });
-      const p = pairedTTest(aScores, bScores).p;
-      raw.push({
-        a: labelOf(ka),
-        b: labelOf(kb),
-        pairs: aScores.length,
-        delta: boot.median,
-        ciLow: boot.low,
-        ciHigh: boot.high,
-        p
-      });
-    }
-  }
-  const { significant } = benjaminiHochberg(
-    raw.map((r) => r.p),
-    opts.fdr ?? 0.05
-  );
-  return raw.map((r, i) => ({
-    ...r,
-    significant: (significant[i] ?? false) && r.pairs >= minPairs
-  }));
-}
-var pct = (x) => `${(100 * x).toFixed(1)}%`;
-var ci = (iv) => iv ? ` [${pct(iv.lower)}, ${pct(iv.upper)}]` : "";
-function renderLeaderboardMarkdown(report) {
-  const lines = [];
-  lines.push(`# ${report.title}`, "");
-  const p = report.provenance;
-  lines.push(
-    `**${p.profiles} profiles \xD7 ${p.axes} axes**, ${p.records} runs, ${p.models.length} models \xB7 total $${p.totalCostUsd.toFixed(2)}`,
-    ""
-  );
-  for (const [k, v] of Object.entries(report.meta)) lines.push(`- **${k}:** ${v}`);
-  if (Object.keys(report.meta).length) lines.push("");
-  lines.push("## Leaderboard", "");
-  lines.push(
-    "| # | Profile | Score (95% CI) | Solved (95% CI) | Runs | Cost | Tok in/out | p50 | p90 |"
-  );
-  lines.push("|---|---|--:|--:|--:|--:|--:|--:|--:|");
-  report.profiles.forEach((r, i) => {
-    lines.push(
-      `| ${i + 1} | ${r.label} | ${pct(r.meanScore)}${ci(r.scoreCi)} | ${pct(r.solveRate)}${ci(r.passCi)} | ${r.n} | $${r.costUsd.toFixed(3)} | ${r.tokensIn}/${r.tokensOut} | ${(r.latencyP50Ms / 1e3).toFixed(1)}s | ${(r.latencyP90Ms / 1e3).toFixed(1)}s |`
-    );
-  });
-  lines.push("");
-  lines.push("## Score matrix \u2014 profile \xD7 axis", "");
-  lines.push(`| Profile | ${report.axes.join(" | ")} |`);
-  lines.push(`|---|${report.axes.map(() => "--:").join("|")}|`);
-  for (const r of report.profiles) {
-    const cells = report.axes.map((a) => {
-      const v = r.perAxis[a];
-      return v === void 0 ? "\xB7" : pct(v);
-    });
-    lines.push(`| ${r.label} | ${cells.join(" | ")} |`);
-  }
-  lines.push("");
-  lines.push("> `\xB7` = the profile never ran that axis (blank, never zero).");
-  return lines.join("\n");
-}
-function renderPairwiseMarkdown(verdicts, title = "Pairwise significance (paired, BH-corrected)") {
-  const lines = [`## ${title}`, ""];
-  if (verdicts.length === 0) return lines.concat("_no comparable pairs_").join("\n");
-  lines.push("| A vs B | \u0394(b\u2212a) median | 95% CI | pairs | p | verdict |");
-  lines.push("|---|--:|--:|--:|--:|---|");
-  for (const v of verdicts) {
-    const verdict = v.significant ? `**${v.delta >= 0 ? v.b : v.a} wins**` : "ns";
-    lines.push(
-      `| ${v.a} vs ${v.b} | ${v.delta >= 0 ? "+" : ""}${pct(v.delta)} | [${pct(v.ciLow)}, ${pct(v.ciHigh)}] | ${v.pairs} | ${v.p.toFixed(3)} | ${verdict} |`
-    );
-  }
-  lines.push(
-    "",
-    "> `ns` = not significant after Benjamini\u2013Hochberg (or below the paired-count floor)."
-  );
-  return lines.join("\n");
-}
-function esc(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function ramp(score) {
-  const x = Math.max(0, Math.min(1, score));
-  const r = Math.round(x < 0.5 ? 220 : 220 - (x - 0.5) * 2 * 160);
-  const g = Math.round(x < 0.5 ? x * 2 * 170 : 170);
-  return `rgb(${r},${g},60)`;
-}
-function renderLeaderboardSvg(report) {
-  const rowH = 26;
-  const labelW = 220;
-  const cellW = 54;
-  const pad = 16;
-  const barAreaW = 360;
-  const profiles = report.profiles;
-  const barsH = profiles.length * rowH + pad;
-  const heatTop = barsH + 48;
-  const heatW = labelW + report.axes.length * cellW + pad;
-  const heatH = profiles.length * rowH + pad;
-  const width = Math.max(labelW + barAreaW + pad * 2, heatW);
-  const height = heatTop + heatH + pad;
-  const out = [];
-  out.push(
-    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" font-family="ui-sans-serif,system-ui,sans-serif" font-size="12">`
-  );
-  out.push(`<rect width="${width}" height="${height}" fill="white"/>`);
-  out.push(
-    `<text x="${pad}" y="${pad + 4}" font-weight="700" font-size="14">${esc(report.title)} \u2014 score</text>`
-  );
-  profiles.forEach((r, i) => {
-    const y = pad + 12 + i * rowH;
-    out.push(`<text x="${pad}" y="${y + 14}">${esc(r.label)}</text>`);
-    const w = Math.round(r.meanScore * barAreaW);
-    out.push(`<rect x="${labelW}" y="${y + 4}" width="${barAreaW}" height="16" fill="#eef0f2"/>`);
-    out.push(
-      `<rect x="${labelW}" y="${y + 4}" width="${w}" height="16" fill="${ramp(r.meanScore)}"/>`
-    );
-    out.push(`<text x="${labelW + barAreaW + 6}" y="${y + 16}">${pct(r.meanScore)}</text>`);
-  });
-  out.push(
-    `<text x="${pad}" y="${heatTop - 12}" font-weight="700" font-size="14">profile \xD7 axis</text>`
-  );
-  report.axes.forEach((a, c) => {
-    const x = labelW + c * cellW;
-    out.push(
-      `<text x="${x + cellW / 2}" y="${heatTop}" text-anchor="middle" fill="#555">${esc(a.length > 8 ? `${a.slice(0, 7)}\u2026` : a)}</text>`
-    );
-  });
-  profiles.forEach((r, i) => {
-    const y = heatTop + 8 + i * rowH;
-    out.push(`<text x="${pad}" y="${y + 16}">${esc(r.label)}</text>`);
-    report.axes.forEach((a, c) => {
-      const x = labelW + c * cellW;
-      const s = r.perAxis[a];
-      if (s !== void 0) {
-        out.push(
-          `<rect x="${x}" y="${y}" width="${cellW - 3}" height="${rowH - 4}" fill="${ramp(s)}"/>`
-        );
-        out.push(
-          `<text x="${x + (cellW - 3) / 2}" y="${y + 15}" text-anchor="middle" fill="white" font-size="10">${Math.round(100 * s)}</text>`
-        );
-      } else {
-        out.push(
-          `<rect x="${x}" y="${y}" width="${cellW - 3}" height="${rowH - 4}" fill="#f3f4f6"/>`
-        );
-      }
-    });
-  });
-  out.push("</svg>");
-  return out.join("\n");
-}
-function renderLeaderboardHtml(report) {
-  const svg = renderLeaderboardSvg(report);
-  const p = report.provenance;
-  const rows = report.profiles.map(
-    (r, i) => `<tr><td>${i + 1}</td><td>${esc(r.label)}</td><td class="n">${pct(r.meanScore)}</td><td class="n">${pct(r.solveRate)}</td><td class="n">${r.n}</td><td class="n">$${r.costUsd.toFixed(3)}</td>${report.axes.map((a) => {
-      const v = r.perAxis[a];
-      return `<td class="n">${v === void 0 ? "\xB7" : pct(v)}</td>`;
-    }).join("")}</tr>`
-  ).join("\n");
-  const axisHead = report.axes.map((a) => `<th>${esc(a)}</th>`).join("");
-  return `<!doctype html><html><head><meta charset="utf-8"><title>${esc(report.title)}</title>
-<style>
-body{font:14px ui-sans-serif,system-ui,sans-serif;margin:2rem;color:#111}
-h1{font-size:1.4rem}.sub{color:#555;margin:.2rem 0 1.2rem}
-table{border-collapse:collapse;margin-top:1rem}td,th{border:1px solid #e5e7eb;padding:.35rem .6rem}
-th{background:#f9fafb;text-align:left}.n{text-align:right;font-variant-numeric:tabular-nums}
-tr:first-child td{font-weight:600}
-</style></head><body>
-<h1>${esc(report.title)}</h1>
-<div class="sub">${p.profiles} profiles \xD7 ${p.axes} axes \xB7 ${p.records} runs \xB7 ${p.models.length} models \xB7 total $${p.totalCostUsd.toFixed(2)}</div>
-${svg}
-<table><thead><tr><th>#</th><th>Profile</th><th>Score</th><th>Solved</th><th>Runs</th><th>Cost</th>${axisHead}</tr></thead>
-<tbody>
-${rows}
-</tbody></table>
-</body></html>`;
-}
-
-// src/runtime/completion.ts
-function completionAuthorizes(v, policy) {
-  if (!v?.done) return false;
-  if (v.determinism === "deterministic") return true;
-  return (v.confidence ?? 0) >= (policy?.minConfidence ?? 0.8);
-}
-function stopSentinel(seed) {
-  let h = 2166136261;
-  for (let i = 0; i < seed.length; i += 1) {
-    h ^= seed.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return `<<<{{STOP:${(h >>> 0).toString(16).padStart(8, "0")}}}>>>`;
-}
-function sentinelCompletion(sentinel, opts) {
-  return {
-    assess({ history }) {
-      const last = history[history.length - 1];
-      const out = typeof last?.output === "string" ? last.output : "";
-      const done = out.includes(sentinel);
-      return {
-        done,
-        determinism: "probabilistic",
-        confidence: done ? opts?.confidence ?? 0.9 : 0,
-        reasons: done ? "agent emitted its assigned stop sentinel" : void 0,
-        evidence: done && last ? [{ kind: "artifact", uri: `attempt:${last.index}` }] : []
-      };
-    }
-  };
-}
-function deterministicCompletion(check) {
-  return {
-    assess({ history }) {
-      const last = history[history.length - 1];
-      if (last?.output === void 0) {
-        return { done: false, determinism: "deterministic", reasons: "no output yet" };
-      }
-      const r = check(last.output, history);
-      return {
-        done: r.passed,
-        determinism: "deterministic",
-        reasons: r.reasons,
-        evidence: [{ kind: "artifact", uri: `attempt:${last.index}` }]
-      };
-    }
-  };
-}
-
-// src/runtime/define-leaderboard.ts
-import { execFileSync } from "child_process";
-import { mkdirSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import {
-  CODING_HARNESSES,
-  expandProfileAxes,
-  harnessAxisOf
-} from "@tangle-network/agent-eval";
-import {
-  runProfileMatrix
-} from "@tangle-network/agent-eval/campaign";
-import { collectAgentResponseText } from "@tangle-network/sandbox";
-
-// src/runtime/loop-dispatch.ts
-function campaignTraceToLoopEmitter(trace) {
-  return {
-    emit(event) {
-      trace.span(event.kind, { runId: event.runId, timestamp: event.timestamp, ...event.payload }).end();
-    }
-  };
-}
-async function runLoopForCell(opts, scenario, profile, ctx) {
-  const loopOptions = opts.toLoopOptions(scenario, profile);
-  return runLoopWithCampaignContext(opts, loopOptions, ctx, {
-    model: profile.model?.default ?? modelFromLoopOptions(loopOptions),
-    maximumCharge: typeof opts.maximumCharge === "function" ? opts.maximumCharge(scenario, profile) : opts.maximumCharge,
-    resolveModel: opts.resolveCostModel ? (result) => opts.resolveCostModel?.(result, scenario, profile) : void 0
-  });
-}
-async function runLoopWithCampaignContext(opts, loopOptions, ctx, cost) {
-  const paid = await ctx.cost.runPaidCall({
-    channel: "agent",
-    actor: opts.costSource ?? "loop",
-    model: cost.model,
-    signal: ctx.signal,
-    ...cost.maximumCharge ? { maximumCharge: cost.maximumCharge } : {},
-    execute: (executionSignal) => runAgentRounds({
-      ...loopOptions,
-      ctx: {
-        sandboxClient: opts.sandboxClient,
-        signal: executionSignal,
-        traceEmitter: opts.forwardTrace === false ? void 0 : campaignTraceToLoopEmitter(ctx.trace)
-      }
-    }),
-    receipt: (result2) => loopCostReceipt(result2, cost.resolveModel?.(result2) ?? cost.model)
-  });
-  if (!paid.succeeded) {
-    throw paid.error;
-  }
-  const result = paid.value;
-  const toArtifact = opts.toArtifact ?? ((r) => r.winner?.output);
-  return toArtifact(result);
-}
-function loopCostReceipt(result, model) {
-  return {
-    model,
-    inputTokens: result.tokenUsage.input,
-    outputTokens: result.tokenUsage.output,
-    ...result.costUsd > 0 ? { actualCostUsd: result.costUsd } : {}
-  };
-}
-function modelFromLoopOptions(options) {
-  const profiles = options.agentRun ? [options.agentRun.profile] : options.agentRuns?.map((run) => run.profile) ?? [];
-  const models = new Set(
-    profiles.map((profile) => profile.model?.default).filter((model) => !!model)
-  );
-  if (models.size === 1) return [...models][0];
-  return models.size > 1 ? "mixed" : "unknown";
-}
-function loopCampaignDispatch(opts) {
-  return (scenario, ctx) => {
-    const loopOptions = opts.toLoopOptions(scenario);
-    return runLoopWithCampaignContext(opts, loopOptions, ctx, {
-      model: modelFromLoopOptions(loopOptions),
-      maximumCharge: typeof opts.maximumCharge === "function" ? opts.maximumCharge(scenario) : opts.maximumCharge,
-      resolveModel: opts.resolveCostModel ? (result) => opts.resolveCostModel?.(result, scenario) : void 0
-    });
-  };
-}
-function loopDispatch(opts) {
-  return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
-}
-
-// src/runtime/inline-sandbox-client.ts
-function isAsyncIterable(v) {
-  return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
-}
-async function settle(exec, task, signal) {
-  const r = exec.execute(task, signal);
-  if (isAsyncIterable(r)) {
-    for await (const _ of r) {
-    }
-    return exec.resultArtifact();
-  }
-  return r;
-}
-function inlineSandboxClient(factory) {
-  let seq = 0;
-  return {
-    async create(options) {
-      const id = `inline-${seq++}`;
-      const createOptions = options;
-      return {
-        id,
-        async *streamPrompt(message, opts) {
-          const controller = new AbortController();
-          const callerSignal = opts?.signal;
-          const onAbort = () => controller.abort(callerSignal?.reason ?? new Error("prompt aborted"));
-          if (callerSignal) {
-            if (callerSignal.aborted) onAbort();
-            else callerSignal.addEventListener("abort", onAbort, { once: true });
-          }
-          const spec = { profile: { name: id }, harness: null };
-          const exec = factory(spec, { signal: controller.signal, seams: { createOptions } });
-          try {
-            const artifact = await settle(exec, message, controller.signal);
-            const out = artifact.out;
-            const tokensIn = artifact.spent.tokens.input;
-            const tokensOut = artifact.spent.tokens.output;
-            const costUsd = artifact.spent.usd;
-            if (tokensIn || tokensOut || costUsd) {
-              yield {
-                type: "llm_call",
-                data: { tokensIn, tokensOut, costUsd }
-              };
-            }
-            yield {
-              type: "result",
-              data: {
-                finalText: out?.content ?? "",
-                tokenUsage: {
-                  inputTokens: tokensIn,
-                  outputTokens: tokensOut
-                },
-                costUsd
-              }
-            };
-          } finally {
-            callerSignal?.removeEventListener("abort", onAbort);
-            await exec.teardown("brutalKill").catch(() => {
-            });
-          }
-        },
-        async delete() {
-        }
-      };
-    }
-  };
-}
-
-// src/runtime/local-sandbox-client.ts
-import {
-  canonicalCandidateDigest
-} from "@tangle-network/agent-interface";
-
-// src/runtime/stdio-mcp-client.ts
-import { spawn } from "child_process";
-import { createInterface } from "readline";
-import {
-  validateAgentProfileSecurity
-} from "@tangle-network/agent-interface";
-
-// src/runtime/key-provider.ts
-function envKeyProvider(env = process.env) {
-  return {
-    async get(name) {
-      const value = env[name];
-      return value !== void 0 && value.trim().length > 0 ? value : void 0;
-    }
-  };
-}
-var mcpSecretEnvMetadataKey = "secretEnv";
-function secretEnvOfMcpServer(server) {
-  const raw = server.metadata?.[mcpSecretEnvMetadataKey];
-  if (raw === void 0 || raw === null) return void 0;
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new ValidationError(
-      `secretEnvOfMcpServer: metadata.${mcpSecretEnvMetadataKey} must be an object mapping env var name -> key name`
-    );
-  }
-  const entries = Object.entries(raw);
-  if (entries.length === 0) return void 0;
-  for (const [envName, keyName] of entries) {
-    if (!envName.trim() || typeof keyName !== "string" || !keyName.trim()) {
-      throw new ValidationError(
-        `secretEnvOfMcpServer: metadata.${mcpSecretEnvMetadataKey}['${envName}'] must name a non-empty provider key`
-      );
-    }
-  }
-  return raw;
-}
-async function resolveSecretEnv(secretEnv, keys, label) {
-  const entries = Object.entries(secretEnv);
-  if (entries.length === 0) return {};
-  if (!keys) {
-    throw new ValidationError(
-      `${label} declares secret env (${entries.map(([e]) => e).join(", ")}) but no KeyProvider was supplied \u2014 refusing to boot an external server keyless`
-    );
-  }
-  const resolved = {};
-  for (const [envName, keyName] of entries) {
-    const value = await keys.get(keyName);
-    if (value === void 0) {
-      throw new ValidationError(
-        `${label}: the KeyProvider holds no value for '${keyName}' (wanted for env ${envName}) \u2014 provision the key or drop the grant`
-      );
-    }
-    resolved[envName] = value;
-  }
-  return resolved;
-}
-
-// src/runtime/mcp-environment.ts
-async function rpc(endpoint, body) {
-  let lastErr;
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    try {
-      const r = await fetch(endpoint.url, {
-        method: "POST",
-        headers: { "content-type": "application/json", ...endpoint.headers ?? {} },
-        body: JSON.stringify(body)
-      });
-      const text = await r.text();
-      const dataLines = text.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim());
-      const payload = dataLines.length ? dataLines[dataLines.length - 1] : text;
-      try {
-        return { status: r.status, json: JSON.parse(payload ?? "null") };
-      } catch {
-        return { status: r.status, json: text };
-      }
-    } catch (err) {
-      lastErr = err;
-      await new Promise((res) => setTimeout(res, 1e3 * (attempt + 1)));
-    }
-  }
-  throw new Error(
-    `mcp rpc ${endpoint.url} failed after 4 attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
-  );
-}
-function sanitizeMcpToolSchema(s) {
-  const o = s && typeof s === "object" ? s : {};
-  const banned = o.oneOf || o.anyOf || o.allOf || o.not || o.enum;
-  if (o.type === "object" && !banned && o.properties && typeof o.properties === "object") {
-    return {
-      type: "object",
-      properties: o.properties,
-      ...Array.isArray(o.required) ? { required: o.required } : {}
-    };
-  }
-  return { type: "object", properties: {} };
-}
-function createMcpEnvironment(opts) {
-  const endpoints = /* @__PURE__ */ new Map();
-  const maxChars = opts.maxResultChars ?? 1500;
-  return {
-    name: opts.name,
-    async open(task) {
-      const { handle, endpoint } = await opts.open(task);
-      endpoints.set(handle.id, endpoint);
-      return handle;
-    },
-    async tools(task, handle) {
-      const endpoint = endpoints.get(handle.id);
-      if (!endpoint) throw new Error(`${opts.name}: tools() before open() for ${handle.id}`);
-      const { json } = await rpc(endpoint, {
-        jsonrpc: "2.0",
-        id: 1,
-        method: "tools/list",
-        params: {}
-      });
-      const all = (json.result?.tools ?? []).map(
-        (t) => ({
-          type: "function",
-          function: {
-            name: t.name,
-            description: (t.description ?? "").slice(0, 1e3),
-            parameters: sanitizeMcpToolSchema(t.inputSchema)
-          }
-        })
-      );
-      return opts.selectTools ? opts.selectTools(task, all) : all;
-    },
-    async call(handle, name, args) {
-      const endpoint = endpoints.get(handle.id);
-      if (!endpoint) return "ERROR: workspace closed";
-      const { json } = await rpc(endpoint, {
-        jsonrpc: "2.0",
-        id: 2,
-        method: "tools/call",
-        params: { name, arguments: args }
-      });
-      const result = json ?? {};
-      if (result.error) return `ERROR: ${JSON.stringify(result.error).slice(0, 300)}`;
-      const text = result.result?.content?.map((c) => c.text ?? "").join("\n") ?? JSON.stringify(result.result ?? json);
-      return text.slice(0, maxChars);
-    },
-    score: (task, handle) => opts.score(task, handle),
-    async close(handle) {
-      endpoints.delete(handle.id);
-      await opts.close?.(handle);
-    }
-  };
-}
-
-// src/runtime/stdio-mcp-client.ts
-var PROTOCOL_VERSION = "2024-11-05";
-var SAFE_INHERITED_ENV_NAMES = [
-  "PATH",
-  "LANG",
-  "LC_ALL",
-  "LC_CTYPE",
-  "TZ",
-  "SYSTEMROOT",
-  "WINDIR",
-  "COMSPEC",
-  "PATHEXT"
-];
-function inheritedStdioEnv(source = process.env) {
-  const env = {};
-  for (const name of SAFE_INHERITED_ENV_NAMES) {
-    const value = source[name];
-    if (value !== void 0) env[name] = value;
-  }
-  return env;
-}
-var McpSpawnFault = class extends Error {
-};
-async function connectStdioMcp(spec) {
-  const timeoutMs = spec.timeoutMs ?? 3e4;
-  const protectedValues = Object.values(spec.protectedEnv ?? {});
-  const redactReason = (value) => redactProtectedReason(value, protectedValues);
-  const child = spawn(spec.command, spec.args ?? [], {
-    ...spec.cwd ? { cwd: spec.cwd } : {},
-    stdio: ["pipe", "pipe", "pipe"],
-    env: { ...inheritedStdioEnv(), ...spec.env, ...spec.protectedEnv }
-  });
-  const stderr = [];
-  child.stderr.on("data", (d) => stderr.push(String(d)));
-  const stderrTail = () => stderr.length > 0 ? `
-stderr:
-${redactReason(stderr.join("")).slice(-2e3)}` : "";
-  let nextId = 1;
-  let spawnFault;
-  let closed = false;
-  const pending = /* @__PURE__ */ new Map();
-  const failAllPending = (err) => {
-    for (const p of pending.values()) {
-      clearTimeout(p.timer);
-      p.reject(err);
-    }
-    pending.clear();
-  };
-  child.on("error", (err) => {
-    const code = err.code;
-    spawnFault = code === "ENOENT" ? new McpSpawnFault(
-      `'${spec.command}' not found in PATH (setup bug, not a failed candidate)`
-    ) : new McpSpawnFault(`'${spec.command}' failed to spawn: ${err.message}`);
-    failAllPending(spawnFault);
-  });
-  child.stdin.on("error", (err) => {
-    failAllPending(
-      new Error(redactReason(`writing to MCP server stdin failed: ${err.message}${stderrTail()}`))
-    );
-  });
-  child.on("close", (code, signal) => {
-    failAllPending(
-      spawnFault ?? new Error(
-        redactReason(
-          `MCP server exited (code ${code}, signal ${signal}) before serving${stderrTail()}`
-        )
-      )
-    );
-  });
-  const rl = createInterface({ input: child.stdout });
-  rl.on("line", (line) => {
-    let msg;
-    try {
-      msg = JSON.parse(line);
-    } catch {
-      return;
-    }
-    if (!msg || typeof msg !== "object" || typeof msg.id !== "number") return;
-    const p = pending.get(msg.id);
-    if (!p) return;
-    pending.delete(msg.id);
-    clearTimeout(p.timer);
-    p.resolve(msg);
-  });
-  const send = (msg) => {
-    child.stdin.write(`${JSON.stringify(msg)}
-`);
-  };
-  const request = (method, params, timeoutMessage = `MCP server did not answer '${method}' within ${timeoutMs}ms`) => new Promise((resolve, reject) => {
-    if (spawnFault) return reject(spawnFault);
-    if (closed) return reject(new Error("MCP connection closed"));
-    const id = nextId++;
-    const timer = setTimeout(() => {
-      pending.delete(id);
-      reject(new Error(redactReason(`${timeoutMessage}${stderrTail()}`)));
-    }, timeoutMs);
-    pending.set(id, { resolve, reject, timer });
-    try {
-      send({ jsonrpc: "2.0", id, method, ...params ? { params } : {} });
-    } catch (err) {
-      pending.delete(id);
-      clearTimeout(timer);
-      reject(
-        new Error(
-          redactReason(
-            `writing to MCP server stdin failed: ${err instanceof Error ? err.message : String(err)}${stderrTail()}`
-          )
-        )
-      );
-    }
-  });
-  const close = async () => {
-    if (closed) return;
-    closed = true;
-    rl.close();
-    failAllPending(new Error("MCP connection closed"));
-    child.kill("SIGKILL");
-  };
-  const handshakeTimeout = `MCP server did not complete the handshake within ${timeoutMs}ms`;
-  try {
-    const init = await request(
-      "initialize",
-      {
-        protocolVersion: PROTOCOL_VERSION,
-        capabilities: {},
-        clientInfo: { name: "agent-runtime-local-mcp", version: "0" }
-      },
-      handshakeTimeout
-    );
-    if (init.error)
-      throw new Error(
-        redactReason(`initialize errored: ${JSON.stringify(init.error)}${stderrTail()}`)
-      );
-    send({ jsonrpc: "2.0", method: "notifications/initialized" });
-    const list = await request("tools/list", void 0, handshakeTimeout);
-    if (list.error)
-      throw new Error(
-        redactReason(`tools/list errored: ${JSON.stringify(list.error)}${stderrTail()}`)
-      );
-    const rawTools = list.result?.tools;
-    if (!Array.isArray(rawTools))
-      throw new Error(`tools/list result has no tools array${stderrTail()}`);
-    const tools = redactProtectedValue(rawTools, protectedValues).value;
-    const callTool = async (name, args) => {
-      const res = await request("tools/call", { name, arguments: args });
-      if (res.error) return `ERROR: ${redactReason(JSON.stringify(res.error)).slice(0, 300)}`;
-      const result = res.result;
-      const chunks = result?.content?.map((c) => c.text ?? "");
-      const joined = chunks?.join("\n") ?? JSON.stringify(result ?? null);
-      const collapsed = chunks?.join("");
-      let text = joined;
-      if (collapsed !== void 0) {
-        const collapsedRedacted = redactReason(collapsed);
-        if (collapsedRedacted !== collapsed) text = collapsedRedacted;
-      }
-      return redactReason(result?.isError ? `ERROR: ${text}` : text);
-    };
-    return { tools, callTool, close };
-  } catch (err) {
-    await close();
-    throw err;
-  }
-}
-async function materializeLocalMcp(profile, opts = {}) {
-  const security = validateAgentProfileSecurity(profile, opts.profileSecurityPolicy);
-  if (!security.ok) {
-    const reasons = security.issues.filter((issue) => issue.level === "error").map((issue) => issue.message).join("; ");
-    throw new ValidationError(`materializeLocalMcp: profile host execution refused: ${reasons}`);
-  }
-  const maxResultChars = opts.maxResultChars ?? 2e3;
-  const connections = [];
-  const routes = /* @__PURE__ */ new Map();
-  const tools = [];
-  const close = async () => {
-    await Promise.all(connections.map((c) => c.close()));
-  };
-  try {
-    for (const [key, server] of Object.entries(profile.mcp ?? {})) {
-      if (server.enabled === false) continue;
-      const transport = server.transport ?? "stdio";
-      if (transport !== "stdio") {
-        throw new ValidationError(
-          `materializeLocalMcp: profile.mcp['${key}'] has transport '${transport}' \u2014 the same-host client only spawns stdio servers; a remote (http/sse) server needs an http MCP client (not yet built here) or the sandbox backend. Failing loud: scoring this profile without its declared server would fake the with/without ablation`
-        );
-      }
-      if (!server.command || server.command.trim().length === 0) {
-        throw new ValidationError(
-          `materializeLocalMcp: profile.mcp['${key}'] declares a stdio server with no command`
-        );
-      }
-      const secretRefs = secretEnvOfMcpServer(server);
-      const provisioned = secretRefs ? await resolveSecretEnv(
-        secretRefs,
-        opts.keys,
-        `materializeLocalMcp: profile.mcp['${key}']`
-      ) : void 0;
-      const conn = await connectStdioMcp({
-        command: server.command,
-        ...server.args ? { args: server.args } : {},
-        ...server.cwd ? { cwd: server.cwd } : {},
-        ...server.env ? { env: server.env } : {},
-        ...provisioned ? { protectedEnv: provisioned } : {},
-        ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {}
-      });
-      connections.push(conn);
-      const prefix = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-      for (const t of conn.tools) {
-        const name = `${prefix}__${t.name.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-        if (routes.has(name)) {
-          throw new ValidationError(
-            `materializeLocalMcp: namespaced tool '${name}' collides across servers \u2014 rename the profile.mcp keys`
-          );
-        }
-        routes.set(name, { conn, tool: t.name });
-        tools.push({
-          type: "function",
-          function: {
-            name,
-            description: (t.description ?? "").slice(0, 1e3),
-            parameters: sanitizeMcpToolSchema(t.inputSchema)
-          }
-        });
-      }
-    }
-  } catch (err) {
-    await close();
-    throw err;
-  }
-  return {
-    tools,
-    owns: (name) => routes.has(name),
-    call: async (name, args) => {
-      const route = routes.get(name);
-      if (!route) throw new Error(`materializeLocalMcp: unknown tool '${name}'`);
-      const out = await route.conn.callTool(route.tool, args);
-      return out.length > maxResultChars ? out.slice(0, maxResultChars) : out;
-    },
-    close
-  };
-}
-
-// src/runtime/local-sandbox-client.ts
-function localSandboxClient(opts) {
-  if (opts.profileSecurityPolicy?.allowLocalMcp && opts.profile === void 0) {
-    throw new ValidationError(
-      "localSandboxClient: allowLocalMcp requires a fixed author-controlled profile; dynamic profiles need a real sandbox"
-    );
-  }
-  const trustedProfileDigest = opts.profileSecurityPolicy?.allowLocalMcp && opts.profile !== void 0 ? canonicalCandidateDigest(opts.profile) : void 0;
-  const maxTurns = opts.maxTurns ?? 8;
-  let seq = 0;
-  return {
-    async create(options) {
-      const profile = options?.backend?.profile ?? opts.profile ?? {};
-      const policyApplies = opts.profileSecurityPolicy !== void 0 && (!opts.profileSecurityPolicy.allowLocalMcp || trustedProfileDigest !== void 0 && canonicalCandidateDigest(profile) === trustedProfileDigest);
-      const mcp = await materializeLocalMcp(profile, {
-        ...opts.keys ? { keys: opts.keys } : {},
-        ...policyApplies ? { profileSecurityPolicy: opts.profileSecurityPolicy } : {}
-      });
-      const brain = routerBrain(
-        {
-          routerBaseUrl: opts.router.baseUrl,
-          routerKey: opts.router.key,
-          model: opts.router.model
-        },
-        opts.temperature !== void 0 ? { temperature: opts.temperature } : {}
-      );
-      const system = [profile.prompt?.systemPrompt, ...profile.prompt?.instructions ?? []].filter((s) => typeof s === "string" && s.trim().length > 0).join("\n\n");
-      const id = `local-${seq++}`;
-      return {
-        id,
-        async *streamPrompt(message, popts) {
-          let costUsd = 0;
-          const chat = async (messages, tools) => {
-            const r2 = await brain(messages, tools);
-            if (r2.costUsd) costUsd += r2.costUsd;
-            return r2;
-          };
-          const r = await runBrainLoop({
-            chat,
-            tools: mcp.tools,
-            execute: (name, args) => mcp.call(name, args),
-            initialMessages: [
-              ...system ? [{ role: "system", content: system }] : [],
-              { role: "user", content: message }
-            ],
-            maxTurns,
-            hooks: { stopBefore: () => popts?.signal?.aborted === true }
-          });
-          if (r.usage.input || r.usage.output || costUsd) {
-            yield {
-              type: "llm_call",
-              data: { tokensIn: r.usage.input, tokensOut: r.usage.output, costUsd }
-            };
-          }
-          yield {
-            type: "result",
-            data: {
-              finalText: r.final,
-              tokenUsage: { inputTokens: r.usage.input, outputTokens: r.usage.output },
-              costUsd
-            }
-          };
-        },
-        async delete() {
-          await mcp.close();
-        }
-      };
-    }
-  };
-}
-
-// src/runtime/resolve-sandbox-client.ts
-function resolveSandboxClient(opts) {
-  switch (opts.backend) {
-    case "sandbox": {
-      if (!opts.sandboxClient) {
-        throw new Error("resolveSandboxClient: backend 'sandbox' requires opts.sandboxClient");
-      }
-      return opts.sandboxClient;
-    }
-    case "bridge": {
-      const bridge = opts.bridge;
-      if (!bridge?.bearer || !bridge.model) {
-        throw new Error(
-          "resolveSandboxClient: backend 'bridge' requires bridge.bearer and bridge.model"
-        );
-      }
-      return inlineSandboxClient(
-        createExecutor({
-          backend: "bridge",
-          bridgeUrl: bridge.url ?? "http://127.0.0.1:3355",
-          bridgeBearer: bridge.bearer,
-          model: bridge.model,
-          timeoutMs: bridge.timeoutMs
-        })
-      );
-    }
-    case "router": {
-      const router = opts.router;
-      if (!router?.baseUrl || !router.key || !router.model) {
-        throw new Error(
-          "resolveSandboxClient: backend 'router' requires router.baseUrl, router.key and router.model"
-        );
-      }
-      return inlineSandboxClient(
-        createExecutor({
-          backend: "router",
-          routerBaseUrl: router.baseUrl,
-          routerKey: router.key,
-          model: router.model
-        })
-      );
-    }
-    case "local": {
-      const local = opts.local;
-      if (!local?.router?.baseUrl || !local.router.key || !local.router.model) {
-        throw new Error(
-          "resolveSandboxClient: backend 'local' requires local.router.baseUrl, local.router.key and local.router.model"
-        );
-      }
-      return localSandboxClient(local);
-    }
-  }
-}
-
-// src/runtime/steering-drivers.ts
-function decideUntilValidOrCapped(history, maxIterations) {
-  if (history.some((it) => it.verdict?.valid)) return "pick-winner";
-  return history.length < maxIterations ? "refine" : "fail";
-}
-function naiveDriver(options) {
-  const { continuation, applyContinuation, maxIterations, name = "naive" } = options;
-  return {
-    name,
-    plan(task, history) {
-      if (history.length === 0) return Promise.resolve([task]);
-      const last = history[history.length - 1];
-      if (last?.verdict?.valid) return Promise.resolve([]);
-      if (history.length >= maxIterations) return Promise.resolve([]);
-      return Promise.resolve([applyContinuation(task, continuation)]);
-    },
-    decide(history) {
-      return decideUntilValidOrCapped(history, maxIterations);
-    },
-    // Pure refine topology (one task per round) — render the steer move.
-    describePlan() {
-      return { kind: "refine", rationale: "naive fixed continuation (no grade signal)" };
-    }
-  };
-}
-function dumbDriver(options) {
-  const { onPass, onFail, applyContinuation, maxIterations, name = "dumb" } = options;
-  return {
-    name,
-    plan(task, history) {
-      if (history.length === 0) return Promise.resolve([task]);
-      const last = history[history.length - 1];
-      const passed = last?.verdict?.valid === true;
-      if (passed) return Promise.resolve([]);
-      if (history.length >= maxIterations) return Promise.resolve([]);
-      const continuation = passed ? onPass : onFail;
-      return Promise.resolve([applyContinuation(task, continuation)]);
-    },
-    decide(history) {
-      return decideUntilValidOrCapped(history, maxIterations);
-    },
-    describePlan() {
-      return { kind: "refine", rationale: "dumb pass/fail-only continuation (no grader findings)" };
-    }
-  };
-}
-
-// src/runtime/define-leaderboard.ts
-function argOf(argv, name) {
-  const i = argv.indexOf(`--${name}`);
-  if (i >= 0 && i + 1 < argv.length) return argv[i + 1];
-  return void 0;
-}
-function splitList(v) {
-  if (v === void 0) return void 0;
-  const parts = v.split(",").map((s) => s.trim()).filter(Boolean);
-  return parts.length > 0 ? parts : void 0;
-}
-function withSnapshot(model, snapshot) {
-  return model.includes("@") ? model : `${model}@${snapshot}`;
-}
-function bareModel(model) {
-  return model.split("@")[0] ?? model;
-}
-function gitSha() {
-  try {
-    return execFileSync("git", ["rev-parse", "HEAD"], { encoding: "utf8" }).trim();
-  } catch {
-    return "unknown";
-  }
-}
-function normalizeScore(s) {
-  return typeof s === "number" ? { composite: s } : s;
-}
-function defineLeaderboard(spec) {
-  const caseId = (c) => {
-    const id = spec.caseId ? spec.caseId(c) : c.id;
-    if (typeof id !== "string" || id.length === 0) {
-      throw new Error(
-        `defineLeaderboard(${spec.name}): every case needs a stable string id \u2014 give cases an \`id\` property or supply spec.caseId`
-      );
-    }
-    return id;
-  };
-  const selectCases = (ids) => {
-    if (!ids) return spec.cases;
-    const byId = new Map(spec.cases.map((c) => [caseId(c), c]));
-    return ids.map((id) => {
-      const c = byId.get(id);
-      if (c === void 0) {
-        throw new Error(
-          `defineLeaderboard(${spec.name}): unknown case "${id}" (have: ${[...byId.keys()].join(", ")})`
-        );
-      }
-      return c;
-    });
-  };
-  const scoreJudge = {
-    name: `${spec.name}-score`,
-    dimensions: [{ key: "composite", description: `${spec.name} case score` }],
-    score({ artifact, scenario }) {
-      const s = normalizeScore(spec.score(artifact, scenario.case));
-      return {
-        composite: s.composite,
-        dimensions: { composite: s.composite, ...s.dimensions },
-        notes: s.notes ?? ""
-      };
-    }
-  };
-  async function run(argv = process.argv.slice(2)) {
-    const args = {};
-    for (const name of [
-      "backend",
-      "harnesses",
-      "models",
-      "cases",
-      "shots",
-      "reps",
-      "model-snapshot",
-      "run-dir",
-      "export-dir"
-    ]) {
-      args[name] = argOf(argv, name);
-    }
-    for (const [name, flag] of Object.entries(spec.flags ?? {})) {
-      args[name] = argOf(argv, name) ?? flag.default;
-    }
-    const backendName = args.backend ?? "sandbox";
-    const shots = Number(args.shots ?? spec.shots ?? 1);
-    const reps = Number(args.reps ?? spec.reps ?? 1);
-    const snapshot = args["model-snapshot"] ?? "leaderboard";
-    const runDir = args["run-dir"] ?? join(tmpdir(), `leaderboard-${spec.name}-${Date.now()}-${process.pid}`);
-    const exportDir = args["export-dir"] ?? join(runDir, "export");
-    mkdirSync(runDir, { recursive: true });
-    const cases = selectCases(splitList(args.cases));
-    if (cases.length === 0) throw new Error(`defineLeaderboard(${spec.name}): no cases to run`);
-    const scenarios = cases.map((c) => ({
-      id: caseId(c),
-      kind: spec.name,
-      case: c
-    }));
-    const harnesses = splitList(args.harnesses) ?? spec.axis?.harnesses ?? CODING_HARNESSES;
-    const rawModels = splitList(args.models) ?? spec.axis?.models ?? (spec.baseProfile?.model?.default !== void 0 ? [spec.baseProfile.model.default] : void 0);
-    if (!rawModels || rawModels.length === 0) {
-      throw new Error(
-        `defineLeaderboard(${spec.name}): no models \u2014 pass --models, set spec.axis.models, or give spec.baseProfile a model.default`
-      );
-    }
-    const models = rawModels.map((m) => withSnapshot(m, snapshot));
-    const base = spec.baseProfile ?? { name: spec.name, model: { default: bareModel(models[0] ?? "") } };
-    const profiles = expandProfileAxes({ base, harnesses, models });
-    const ctx = {
-      name: spec.name,
-      backend: backendName,
-      runDir,
-      exportDir,
-      args,
-      harnesses,
-      models,
-      caseIds: scenarios.map((s) => s.id),
-      shots,
-      reps
-    };
-    const backends = {
-      sandbox: () => {
-        throw new Error(
-          `defineLeaderboard(${spec.name}): the 'sandbox' backend needs your product's real SandboxClient \u2014 supply spec.backends.sandbox (e.g. () => new SandboxClient({ apiKey, baseUrl }))`
-        );
-      },
-      "cli-bridge": () => {
-        const bearer = process.env.BRIDGE_BEARER ?? process.env.CLI_BRIDGE_BEARER;
-        if (!bearer) {
-          throw new Error(
-            `defineLeaderboard(${spec.name}): backend 'cli-bridge' needs BRIDGE_BEARER or CLI_BRIDGE_BEARER set`
-          );
-        }
-        return resolveSandboxClient({
-          backend: "bridge",
-          bridge: {
-            url: process.env.CLI_BRIDGE_URL,
-            bearer,
-            model: bareModel(models[0] ?? ""),
-            timeoutMs: 9e5
-          }
-        });
-      },
-      ...spec.backends
-    };
-    const makeClient = backends[backendName];
-    if (!makeClient) {
-      throw new Error(
-        `defineLeaderboard(${spec.name}): unknown backend "${backendName}" (have: ${Object.keys(backends).join(", ")})`
-      );
-    }
-    const sandboxClient = makeClient();
-    const promptById = /* @__PURE__ */ new Map();
-    for (const s of scenarios) promptById.set(s.id, await spec.prompt(s.case));
-    const promptOf = (s) => {
-      const p = promptById.get(s.id);
-      if (p === void 0)
-        throw new Error(`defineLeaderboard(${spec.name}): no prompt for case "${s.id}"`);
-      return p;
-    };
-    let shotNonce = 0;
-    const maximumCharge = spec.maximumCharge;
-    const dispatch = spec.dispatch ?? ((profile, scenario, dispatchCtx) => {
-      const cellDispatch = loopDispatch({
-        sandboxClient,
-        maximumCharge: typeof maximumCharge === "function" ? (cellScenario, cellProfile) => maximumCharge(cellProfile, cellScenario) : maximumCharge,
-        resolveCostModel: (result, _cellScenario, cellProfile) => {
-          if (!spec.resolveModel) return cellProfile.model?.default;
-          const served = new Set(
-            result.iterations.map((iteration) => spec.resolveModel?.(iteration.events)).filter((model) => model !== void 0)
-          );
-          if (served.size > 1) {
-            throw new Error(
-              `defineLeaderboard(${spec.name}): one cell reported multiple served models: ${[...served].join(", ")}`
-            );
-          }
-          return [...served][0] ?? cellProfile.model?.default;
-        },
-        toLoopOptions: (cellScenario, cellProfile) => {
-          const axis = harnessAxisOf(cellProfile);
-          const modelId = bareModel(axis?.model ?? models[0] ?? "");
-          return {
-            // naiveDriver = the no-signal retry floor: re-run the same case as
-            // an independent attempt until one scores (>0) or the shot cap.
-            driver: naiveDriver({
-              continuation: "",
-              applyContinuation: (task) => task,
-              maxIterations: shots
-            }),
-            agentRun: {
-              profile: cellProfile,
-              taskToPrompt: (s) => `${promptOf(s)}
-
-<!-- independent-attempt:${shotNonce++} -->`,
-              ...axis ? {
-                sandboxOverrides: {
-                  backend: {
-                    type: axis.harness,
-                    model: { ...spec.modelBackend, model: modelId }
-                  }
-                }
-              } : {}
-            },
-            output: {
-              parse: (events) => spec.parseOutput ? spec.parseOutput(events, cellScenario.case) : (
-                // The default decode produces string — the TArtifact
-                // default. A structured-TArtifact spec supplies parseOutput
-                // (documented on the field), so this cast never lies.
-                collectAgentResponseText(events) ?? ""
-              )
-            },
-            validator: {
-              validate: async (output) => {
-                const s = normalizeScore(spec.score(output, cellScenario.case));
-                return { valid: s.composite > 0, score: s.composite };
-              }
-            },
-            task: cellScenario,
-            maxIterations: shots
-          };
-        },
-        toArtifact: (result) => {
-          for (const iter of result.iterations) {
-            spec.onCellEvents?.(iter.events, scenario.case, {
-              index: iter.index,
-              ...iter.error ? { error: iter.error.message } : {},
-              ...iter.verdict ? { verdict: { score: iter.verdict.score } } : {}
-            });
-          }
-          return result.winner?.output;
-        }
-      });
-      return cellDispatch(profile, scenario, dispatchCtx);
-    });
-    await spec.setup?.(ctx);
-    try {
-      const result = await runProfileMatrix({
-        profiles,
-        scenarios,
-        dispatch,
-        judges: spec.judges ?? [scoreJudge],
-        runDir,
-        commitSha: gitSha(),
-        reps,
-        ...spec.matrix
-      });
-      if (spec.export) {
-        await spec.export(result, ctx);
-      } else {
-        mkdirSync(exportDir, { recursive: true });
-        writeFileSync(join(runDir, "matrix-result.json"), `${JSON.stringify(result, null, 2)}
-`);
-        const table = renderLeaderboardMarkdown(
-          leaderboard(result.records, { title: spec.name, meta: { backend: backendName } })
-        );
-        writeFileSync(join(exportDir, "leaderboard.md"), table);
-        console.log(table);
-      }
-      return result;
-    } finally {
-      await spec.teardown?.(ctx);
-    }
-  }
-  function toBenchmarkAdapter() {
-    return {
-      name: spec.name,
-      async preflight() {
-        const seen = /* @__PURE__ */ new Set();
-        for (const c of spec.cases) {
-          const id = caseId(c);
-          if (seen.has(id)) {
-            throw new Error(`defineLeaderboard(${spec.name}): duplicate case id "${id}"`);
-          }
-          seen.add(id);
-        }
-      },
-      async loadTasks(opts) {
-        const selected = selectCases(opts?.ids);
-        const limited = opts?.limit !== void 0 ? selected.slice(0, opts.limit) : selected;
-        return Promise.all(
-          limited.map(async (c) => ({
-            id: caseId(c),
-            prompt: await spec.prompt(c),
-            metadata: { case: c }
-          }))
-        );
-      },
-      async judge(task, artifact) {
-        const [c] = selectCases([task.id]);
-        if (c === void 0)
-          throw new Error(`defineLeaderboard(${spec.name}): no case "${task.id}"`);
-        const s = normalizeScore(spec.score(artifact, c));
-        return { resolved: s.composite > 0, score: s.composite, detail: s.notes };
-      },
-      async goldArtifact() {
-        return void 0;
-      }
-    };
-  }
-  return { run, toBenchmarkAdapter };
-}
-
-// src/runtime/harvest-corpus.ts
-async function harvestCorpus(opts) {
-  const concurrency = Math.max(1, opts.concurrency ?? 4);
-  const report = { runsObserved: 0, findings: 0, learned: 0, failures: [] };
-  const iterator = Symbol.asyncIterator in Object(opts.runs) ? opts.runs[Symbol.asyncIterator]() : (async function* () {
-    yield* opts.runs;
-  })();
-  let consumed = 0;
-  let done = false;
-  const next = async () => {
-    if (done || opts.maxRuns !== void 0 && consumed >= opts.maxRuns) return null;
-    const r = await iterator.next();
-    if (r.done) {
-      done = true;
-      return null;
-    }
-    consumed += 1;
-    return r.value;
-  };
-  const workers = Array.from({ length: concurrency }, async () => {
-    for (let input = await next(); input !== null; input = await next()) {
-      if (opts.signal?.aborted) return;
-      try {
-        const obs = await observe(input, {
-          chat: opts.chat,
-          ...opts.model ? { model: opts.model } : {},
-          corpus: opts.corpus,
-          tags: opts.tags ?? [],
-          ...opts.analystInstruction ? { analystInstruction: opts.analystInstruction } : {},
-          ...opts.signal ? { signal: opts.signal } : {}
-        });
-        report.runsObserved += 1;
-        report.findings += obs.findings.length;
-        report.learned += obs.learned.length;
-      } catch (e) {
-        report.failures.push({
-          runId: input.runId ?? `run-${consumed}`,
-          error: e instanceof Error ? e.message.slice(0, 300) : String(e)
-        });
-      }
-    }
-  });
-  await Promise.all(workers);
-  if (report.runsObserved === 0 && report.failures.length > 0) {
-    throw new Error(
-      `harvestCorpus: every run failed analysis (${report.failures.length}) \u2014 first: ${report.failures[0]?.error}`
-    );
-  }
-  return report;
-}
-
-// src/runtime/in-process-sandbox-client.ts
-import { mkdtempSync, rmSync } from "fs";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { dirname, join as join2 } from "path";
-function isAsyncIterable2(v) {
-  return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
-}
-function inProcessSandboxClient(options) {
-  const { onPrompt, onTask, workdir: workdirPrefix, id: idOption } = options;
-  let seq = 0;
-  return {
-    async create(_options) {
-      const current = seq++;
-      const id = typeof idOption === "function" ? idOption(current) : idOption ?? `in-process-${current}`;
-      const boxWorkdir = workdirPrefix !== void 0 ? mkdtempSync(join2(tmpdir2(), `${workdirPrefix}-`)) : void 0;
-      let round = 0;
-      const fsMembers = boxWorkdir !== void 0 ? {
-        fs: {
-          async read(path) {
-            return readFile(join2(boxWorkdir, path), "utf8");
-          },
-          async write(path, content) {
-            const abs = join2(boxWorkdir, path);
-            await mkdir(dirname(abs), { recursive: true });
-            await writeFile(abs, content, "utf8");
-          }
-        },
-        async exec(command) {
-          const { exec: execCb } = await import("child_process");
-          const { promisify } = await import("util");
-          const execAsync = promisify(execCb);
-          try {
-            const { stdout, stderr } = await execAsync(command, {
-              cwd: boxWorkdir,
-              timeout: 3e4
-            });
-            return { exitCode: 0, stdout, stderr };
-          } catch (err) {
-            const e = err;
-            return {
-              exitCode: e.code ?? 1,
-              stdout: e.stdout ?? "",
-              stderr: e.stderr ?? e.message ?? ""
-            };
-          }
-        }
-      } : {};
-      async function* drive(behavior, mode, message, opts) {
-        const prompt = typeof message === "string" ? message : JSON.stringify(message);
-        const { signal: optSignal, ...rest } = opts ?? {};
-        const signal = optSignal ?? new AbortController().signal;
-        const ctx = {
-          round,
-          workdir: boxWorkdir,
-          signal,
-          mode,
-          ...Object.keys(rest).length > 0 ? { options: rest } : {}
-        };
-        round += 1;
-        const produced = await behavior(prompt, ctx);
-        if (isAsyncIterable2(produced)) {
-          for await (const ev of produced) yield ev;
-        } else {
-          for (const ev of produced) yield ev;
-        }
-      }
-      const box = {
-        id,
-        streamPrompt(message, opts) {
-          return drive(onPrompt, "prompt", message, opts);
-        },
-        // Task-mode verb (`streamAgentTurn`'s `box-task` backend). Drives
-        // `onTask` when configured; otherwise the box's one behavior callback.
-        streamTask(message, opts) {
-          return drive(onTask ?? onPrompt, "task", message, opts);
-        },
-        ...fsMembers,
-        async delete() {
-          if (boxWorkdir !== void 0) rmSync(boxWorkdir, { recursive: true, force: true });
-        }
-      };
-      return box;
-    }
-  };
-}
-
-// src/runtime/personify/analyst.ts
-var judgeEvidenceUri = /^(verdict|judge|score)\b/i;
-var assertTraceDerivedFindings = (findings) => {
-  for (const f of findings) {
-    for (const ref of f.evidence_refs ?? []) {
-      if (ref.kind === "metric" && judgeEvidenceUri.test(ref.uri)) {
-        throw new PlannerError(
-          `steer-firewall: finding ${stringifySafe(f.finding_id)} cites judge-derived evidence (${stringifySafe(ref.uri)}); findings fed to a combinator's steer decision must be trace-derived, not judge-derived (selector \u2260 judge)`
-        );
-      }
-    }
-  }
-};
-function createScopeAnalyst(scope, options) {
-  if (!options.analyst || typeof options.analyst.act !== "function") {
-    throw new AnalystError("createScopeAnalyst: analyst must be an Agent with an act() method");
-  }
-  const label = options.label ?? "analyst";
-  return {
-    async analyze(input) {
-      const task = options.buildTask(input);
-      const spawned = scope.spawn(options.analyst, task, {
-        budget: options.budget,
-        label
-      });
-      if (!spawned.ok) {
-        throw new AnalystError(
-          `createScopeAnalyst: analyst spawn refused by the conserved pool (${spawned.reason}); cannot steer node ${stringifySafe(input.nodeId)} on an unrun analyst`
-        );
-      }
-      const settled = await drainAnalystSettlement(scope, spawned.handle.id);
-      const findings = readAnalystFindings(settled);
-      assertTraceDerivedFindings(findings);
-      return findings;
-    }
-  };
-}
-async function drainAnalystSettlement(scope, analystId) {
-  for (; ; ) {
-    const settled = await scope.next();
-    if (settled === null) {
-      throw new AnalystError(
-        `createScopeAnalyst: scope drained before analyst ${stringifySafe(analystId)} settled`
-      );
-    }
-    if (settled.handle.id === analystId) return settled;
-  }
-}
-function readAnalystFindings(settled) {
-  if (settled.kind === "down") {
-    throw new AnalystError(
-      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} settled down (${settled.infra ? "infra" : "result"}): ${stringifySafe(settled.reason)}`
-    );
-  }
-  const out = settled.out;
-  if (!Array.isArray(out)) {
-    throw new PlannerError(
-      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} must return AnalystFinding[], got ${stringifySafe(out)}`
-    );
-  }
-  return out;
-}
-function registryScopeAnalyst(registry, buildInputs) {
-  return {
-    async analyze(input) {
-      const projection = buildInputs(input);
-      const result = await registry.run(projection.runId, projection.inputs, projection.opts);
-      const findings = result.findings;
-      assertTraceDerivedFindings(findings);
-      return findings;
-    }
-  };
-}
-function buildSteerContext(findings, settledSoFar) {
-  assertTraceDerivedFindings(findings);
-  const lastValidScore = observedBestScore(settledSoFar);
-  return {
-    findings,
-    settledSoFar,
-    ...lastValidScore !== void 0 ? { lastValidScore } : {}
-  };
-}
-function observedBestScore(settledSoFar) {
-  let best;
-  for (const s of settledSoFar) {
-    if (s.kind !== "done") continue;
-    const v = s.verdict;
-    if (!v || v.valid !== true || typeof v.score !== "number") continue;
-    if (best === void 0 || v.score > best) best = v.score;
-  }
-  return best;
-}
-
-// src/runtime/personify/combinators.ts
-function selectValidWinner(opts) {
-  const strategy = opts?.strategy ?? "highest-score";
-  const sizeOfIter = (iter) => {
-    const out = iter.output;
-    if (out === void 0 || opts?.sizeOf === void 0) return Number.POSITIVE_INFINITY;
-    const deliverable = out.kind === "done" ? out.deliverable : out;
-    return opts.sizeOf(deliverable);
-  };
-  return (iterations) => {
-    const valid = iterations.filter(
-      (iter) => iter.output !== void 0 && !iter.error && iter.verdict?.valid === true
-    );
-    if (valid.length === 0) return void 0;
-    switch (strategy) {
-      case "first-valid":
-        return [...valid].sort((a, b) => a.index - b.index)[0];
-      case "smallest-artifact":
-        return [...valid].sort((a, b) => sizeOfIter(a) - sizeOfIter(b) || a.index - b.index)[0];
-      default:
-        return [...valid].sort(
-          (a, b) => (b.verdict?.score ?? 0) - (a.verdict?.score ?? 0) || a.index - b.index
-        )[0];
-    }
-  };
-}
-function pipeline(stages) {
-  if (stages.length === 0) {
-    throw new ValidationError("pipeline: at least one stage is required");
-  }
-  return (ctx) => ({
-    name: `${ctx.persona.name}/pipeline`,
-    async act(task, scope) {
-      let carry = task;
-      for (const stage of stages) {
-        const child = ctx.spawnChild(stage.label, ctx.persona.root);
-        const res = scope.spawn(child, stage.feed(carry, ctx, task), {
-          budget: ctx.budget.perChild,
-          label: stage.label
-        });
-        if (!res.ok) {
-          return blocked([`${stage.label}: not admitted (${res.reason})`]);
-        }
-        const settled = await drainOne(scope, stage.label);
-        const out = stage.collect(settled);
-        if (out.kind === "blocked") return out;
-        carry = out.deliverable;
-      }
-      return { kind: "done", deliverable: carry };
-    }
-  });
-}
-function fanout(items, opts) {
-  if (opts.synthesize && opts.selectWinner) {
-    throw new ValidationError("fanout: pass at most one of `synthesize` or `selectWinner`");
-  }
-  return (ctx) => ({
-    name: `${ctx.persona.name}/fanout`,
-    async act(_task, scope) {
-      const rejected = [];
-      const unitAt = (i) => {
-        const item = items[i];
-        if (item === void 0) return void 0;
-        const label = opts.label ? opts.label(item, i) : `item:${i}`;
-        const spec = opts.itemSpec ? opts.itemSpec(item, i, ctx) : ctx.persona.root;
-        return {
-          agent: ctx.spawnChild(label, spec),
-          task: opts.itemTask(item, i, ctx),
-          opts: { budget: ctx.budget.perChild, label }
-        };
-      };
-      let opened = 0;
-      let drained;
-      if (opts.width !== void 0) {
-        let next = 0;
-        const report = await rollingDispatch(scope, {
-          width: opts.width,
-          nextUnit: () => {
-            const unit = unitAt(next);
-            next += 1;
-            return unit;
-          }
-        });
-        opened = report.admitted;
-        for (const r of report.rejected) {
-          const [label, reason] = splitOnce(r, ": ");
-          rejected.push(`${label}: not admitted (${reason})`);
-        }
-        drained = projectDrain(report.settled);
-      } else {
-        for (let i = 0; i < items.length; i += 1) {
-          const unit = unitAt(i);
-          if (unit === void 0) continue;
-          const res = scope.spawn(unit.agent, unit.task, unit.opts);
-          if (res.ok) opened += 1;
-          else rejected.push(`${unit.opts.label}: not admitted (${res.reason})`);
-        }
-        drained = opened === 0 ? emptyRound() : await drain(scope);
-      }
-      if (opened === 0) {
-        return blocked(
-          rejected.length > 0 ? rejected : ["fanout: budget admitted no item (fanout fully rejected)"]
-        );
-      }
-      if (drained.done.length === 0) {
-        return blocked(
-          orderedBlockers(
-            drained.blockers,
-            rejected,
-            "fanout: every item settled without a usable result"
-          )
-        );
-      }
-      if (!opts.synthesize) {
-        const select = opts.selectWinner ?? defaultSelectWinner;
-        const winner = select(drained.iterations);
-        if (!winner || winner.output === void 0) {
-          return blocked(
-            orderedBlockers(drained.blockers, rejected, "fanout: no item survived selection")
-          );
-        }
-        return { kind: "done", deliverable: winner.output };
-      }
-      const synthLabel = "synthesize";
-      const synthChild = ctx.spawnChild(synthLabel, ctx.persona.root);
-      const synthRes = scope.spawn(synthChild, opts.synthesize.synthesisTask(drained.done, ctx), {
-        budget: ctx.budget.perChild,
-        label: synthLabel
-      });
-      if (!synthRes.ok) {
-        return blocked([...drained.blockers, `${synthLabel}: not admitted (${synthRes.reason})`]);
-      }
-      const synthSettled = await drainOne(scope, synthLabel);
-      const out = opts.synthesize.collect(synthSettled);
-      if (out.kind === "blocked") return out;
-      return out;
-    }
-  });
-}
-function loopUntil(seed, spec) {
-  return (ctx) => ({
-    name: `${ctx.persona.name}/loopUntil`,
-    async act(task, scope) {
-      let state = { round: 0, value: seed };
-      const blockers = [];
-      const settledSoFar = [];
-      for (; ; ) {
-        const label = spec.label ? spec.label(state.round) : `step:${state.round}`;
-        const child = ctx.spawnChild(label, ctx.persona.root);
-        const res = scope.spawn(child, spec.step(task, state, ctx), {
-          budget: ctx.budget.perChild,
-          label
-        });
-        if (!res.ok) {
-          if (state.round === 0) return blocked([`${label}: not admitted (${res.reason})`]);
-          break;
-        }
-        const settled = await drainOne(scope, label);
-        if (settled.kind === "down") blockers.push(blockerFromDown(settled));
-        settledSoFar.push(settled);
-        state = spec.fold(state, settled);
-        const findings = ctx.analyst ? await ctx.analyst.analyze({ task, settledSoFar, nodeId: scope.view.root }) : [];
-        const reached = spec.until(state, findings);
-        if (reached) return reached;
-        state = { round: state.round + 1, value: state.value };
-      }
-      return blocked(
-        blockers.length > 0 ? blockers : ["loopUntil: budget exhausted before the satisfiability gate was reached"]
-      );
-    }
-  });
-}
-function panel(spec) {
-  if (spec.judges.length === 0) {
-    throw new ValidationError("panel: at least one judge is required");
-  }
-  return (ctx) => ({
-    name: `${ctx.persona.name}/panel`,
-    async act(task, scope) {
-      const artifact = task;
-      const byLabel = /* @__PURE__ */ new Map();
-      const rejected = [];
-      let opened = 0;
-      for (const judge of spec.judges) {
-        const child = ctx.spawnChild(judge.label, ctx.persona.root);
-        const res = scope.spawn(child, spec.judgeTask(artifact, judge, ctx), {
-          budget: ctx.budget.perChild,
-          label: judge.label
-        });
-        if (res.ok) {
-          byLabel.set(judge.label, judge);
-          opened += 1;
-        } else {
-          rejected.push(`${judge.label}: not admitted (${res.reason})`);
-        }
-      }
-      if (opened === 0) {
-        return blocked(rejected.length > 0 ? rejected : ["panel: budget admitted no judge"]);
-      }
-      const verdicts = [];
-      for (let s = await scope.next(); s !== null; s = await scope.next()) {
-        const judge = byLabel.get(s.handle.label);
-        if (!judge) {
-          throw new ValidationError(
-            `panel: settled child "${s.handle.label}" has no judge descriptor`
-          );
-        }
-        if (s.kind === "down") {
-          verdicts.push({ judge, down: true });
-          continue;
-        }
-        verdicts.push({
-          judge,
-          down: false,
-          ...s.verdict ? { verdict: s.verdict } : {},
-          output: s.out
-        });
-      }
-      return spec.merge(verdicts, artifact);
-    }
-  });
-}
-function verify(spec) {
-  return (ctx) => ({
-    name: `${ctx.persona.name}/verify`,
-    async act(task, scope) {
-      const implementLabel = spec.implementLabel ?? "implement";
-      const implChild = ctx.spawnChild(implementLabel, ctx.persona.root);
-      const implRes = scope.spawn(implChild, spec.implement(task, ctx), {
-        budget: ctx.budget.perChild,
-        label: implementLabel
-      });
-      if (!implRes.ok) return blocked([`${implementLabel}: not admitted (${implRes.reason})`]);
-      const candidate = await drainOne(scope, implementLabel);
-      if (candidate.kind === "down") return blocked([blockerFromDown(candidate)]);
-      const verifierLabel = spec.verifierLabel ?? "verify";
-      const verifierChild = ctx.spawnChild(verifierLabel, ctx.persona.root);
-      const verifierRes = scope.spawn(
-        verifierChild,
-        spec.verifier(candidate, ctx),
-        { budget: ctx.budget.perChild, label: verifierLabel }
-      );
-      if (!verifierRes.ok)
-        return blocked([`${verifierLabel}: not admitted (${verifierRes.reason})`]);
-      const gate = await drainOne(scope, verifierLabel);
-      if (gate.kind === "down") return blocked([blockerFromDown(gate)]);
-      if (!gate.verdict || gate.verdict.valid !== true) {
-        return blocked([`${verifierLabel}: gate rejected the candidate (${verdictDetail(gate)})`]);
-      }
-      return spec.collect(candidate, gate.verdict);
-    }
-  });
-}
-function widen(spec) {
-  return (ctx) => ({
-    name: `${ctx.persona.name}/widen`,
-    async act(_task, scope) {
-      let opened = 0;
-      for (const [i, seed] of spec.seeds.entries()) {
-        const label = `seed:${i}`;
-        const child = ctx.spawnChild(label, ctx.persona.root);
-        const res = scope.spawn(child, spec.seedTask(seed, i, ctx), {
-          budget: ctx.budget.perChild,
-          label
-        });
-        if (res.ok) opened += 1;
-      }
-      if (opened === 0) {
-        return blocked(["widen: budget admitted no seed lineage"]);
-      }
-      const gathered = [];
-      let widenIndex = 0;
-      for (let s = await scope.next(); s !== null; s = await scope.next()) {
-        gathered.push(s);
-        const findings = ctx.analyst ? await ctx.analyst.analyze({
-          task: _task,
-          settledSoFar: gathered,
-          nodeId: scope.view.root
-        }) : [];
-        const decision = spec.gate.decide(s, findings, scope.budget);
-        if (decision.kind !== "widen") continue;
-        const label = `widen:${widenIndex}`;
-        widenIndex += 1;
-        const child = ctx.spawnChild(label, ctx.persona.root);
-        scope.spawn(child, spec.widenTask(decision.toward, ctx), {
-          budget: ctx.budget.perChild,
-          label
-        });
-      }
-      const done = gathered.filter(isDone);
-      if (done.length === 0) {
-        return blocked(
-          orderedBlockers(
-            gathered.filter(isDown).map(blockerFromDown),
-            [],
-            "widen: every lineage settled without a usable result"
-          )
-        );
-      }
-      return spec.synthesize(done, ctx);
-    }
-  });
-}
-function flatWidenGate() {
-  return {
-    decide() {
-      return { kind: "stop" };
-    }
-  };
-}
-function emptyRound() {
-  return { iterations: [], done: [], blockers: [] };
-}
-function projectDrain(settled) {
-  const round = emptyRound();
-  for (const s of settled) {
-    if (s.kind === "down") {
-      round.blockers.push(blockerFromDown(s));
-      continue;
-    }
-    round.iterations.push(settledToIteration(s));
-    round.done.push(s);
-  }
-  return round;
-}
-function splitOnce(text, sep) {
-  const at = text.indexOf(sep);
-  if (at < 0) return [text, ""];
-  return [text.slice(0, at), text.slice(at + sep.length)];
-}
-async function drain(scope) {
-  const iterations = [];
-  const done = [];
-  const blockers = [];
-  for (let s = await scope.next(); s !== null; s = await scope.next()) {
-    if (s.kind === "down") {
-      blockers.push(blockerFromDown(s));
-      continue;
-    }
-    iterations.push(settledToIteration(s));
-    done.push(s);
-  }
-  return { iterations, done, blockers };
-}
-async function drainOne(scope, label) {
-  const s = await scope.next();
-  if (s === null) {
-    throw new ValidationError(`combinator: child "${label}" was spawned but never settled`);
-  }
-  return s;
-}
-function isDone(s) {
-  return s.kind === "done";
-}
-function isDown(s) {
-  return s.kind === "down";
-}
-function blockerFromDown(s) {
-  return `${s.handle.label}: ${s.infra ? "infra" : "failed"} \u2014 ${s.reason}`;
-}
-function verdictDetail(s) {
-  if (!s.verdict) return "no verdict";
-  return s.verdict.notes ?? `score ${s.verdict.score}`;
-}
-function orderedBlockers(drained, rejected, fallback) {
-  const all = [...drained, ...rejected];
-  return all.length > 0 ? all : [fallback];
-}
-function blocked(blockers) {
-  if (blockers.length === 0) {
-    throw new ValidationError("combinator: a blocked outcome must name at least one blocker");
-  }
-  return { kind: "blocked", blockers };
-}
-
-// src/runtime/personify/corpus.ts
-var corpusSchemaVersion = "1.0.0";
-function assertCorpusRecord(value, where) {
-  if (typeof value !== "object" || value === null) {
-    throw new Error(`${where}: corpus record is not an object`);
-  }
-  const r = value;
-  if (r.schemaVersion !== corpusSchemaVersion) {
-    throw new Error(
-      `${where}: corpus record schemaVersion '${String(r.schemaVersion)}' != '${corpusSchemaVersion}'`
-    );
-  }
-  requireNonEmptyString(r.id, `${where}.id`);
-  requireNonEmptyString(r.runId, `${where}.runId`);
-  requireNonEmptyString(r.producedAt, `${where}.producedAt`);
-  requireNonEmptyString(r.area, `${where}.area`);
-  requireNonEmptyString(r.claim, `${where}.claim`);
-  if (r.rationale !== void 0 && typeof r.rationale !== "string") {
-    throw new Error(`${where}.rationale: expected string, got ${typeof r.rationale}`);
-  }
-  if (!Array.isArray(r.tags) || r.tags.some((t) => typeof t !== "string")) {
-    throw new Error(`${where}.tags: expected string[]`);
-  }
-  if (typeof r.confidence !== "number" || !Number.isFinite(r.confidence)) {
-    throw new Error(`${where}.confidence: expected a finite number, got ${String(r.confidence)}`);
-  }
-  if (r.confidence < 0 || r.confidence > 1) {
-    throw new Error(`${where}.confidence: ${r.confidence} is outside the [0, 1] range`);
-  }
-  if (r.evidence !== void 0) {
-    if (!Array.isArray(r.evidence)) {
-      throw new Error(`${where}.evidence: expected an array`);
-    }
-    for (let i = 0; i < r.evidence.length; i++) {
-      const ev = r.evidence[i];
-      if (typeof ev !== "object" || ev === null) {
-        throw new Error(`${where}.evidence[${i}]: not an object`);
-      }
-      requireNonEmptyString(ev.kind, `${where}.evidence[${i}].kind`);
-      requireNonEmptyString(ev.uri, `${where}.evidence[${i}].uri`);
-    }
-  }
-}
-function requireNonEmptyString(value, where) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`${where}: expected a non-empty string, got ${describe(value)}`);
-  }
-}
-function describe(value) {
-  if (value === void 0) return "undefined";
-  if (value === null) return "null";
-  if (typeof value === "string") return `'${value}'`;
-  return typeof value;
-}
-function recordsEqual(a, b) {
-  return stableStringify(a) === stableStringify(b);
-}
-function stableStringify(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([x], [y]) => x < y ? -1 : x > y ? 1 : 0);
-  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
-}
-function applyFilter(records, filter) {
-  const matched = records.filter((r) => {
-    if (filter.area !== void 0 && r.area !== filter.area) return false;
-    if (filter.runId !== void 0 && r.runId !== filter.runId) return false;
-    if (filter.minConfidence !== void 0 && r.confidence < filter.minConfidence) return false;
-    if (filter.tags !== void 0 && !filter.tags.every((t) => r.tags.includes(t))) return false;
-    return true;
-  });
-  const ordered = [...matched].sort(
-    (a, b) => b.confidence !== a.confidence ? b.confidence - a.confidence : b.producedAt < a.producedAt ? -1 : b.producedAt > a.producedAt ? 1 : 0
-  );
-  if (filter.limit !== void 0) {
-    if (!Number.isInteger(filter.limit) || filter.limit < 0) {
-      throw new Error(
-        `corpus query: filter.limit must be a non-negative integer, got ${filter.limit}`
-      );
-    }
-    return ordered.slice(0, filter.limit);
-  }
-  return ordered;
-}
-var InMemoryCorpus = class {
-  byId = /* @__PURE__ */ new Map();
-  async append(record) {
-    try {
-      assertCorpusRecord(record, "append: record");
-    } catch (err) {
-      return { succeeded: false, error: err instanceof Error ? err.message : String(err) };
-    }
-    const existing = this.byId.get(record.id);
-    if (existing) {
-      if (recordsEqual(existing, record)) return { succeeded: true };
-      return {
-        succeeded: false,
-        error: `corpus conflict: id '${record.id}' is already stored with a different record; a learned fact is append-only \u2014 re-mint the id or reconcile before re-appending`
-      };
-    }
-    this.byId.set(record.id, freeze(record));
-    return { succeeded: true };
-  }
-  async query(filter) {
-    return applyFilter([...this.byId.values()], filter);
-  }
-};
-var FileCorpus = class {
-  constructor(path) {
-    this.path = path;
-  }
-  path;
-  async append(record) {
-    try {
-      assertCorpusRecord(record, "append: record");
-    } catch (err) {
-      return { succeeded: false, error: err instanceof Error ? err.message : String(err) };
-    }
-    let stored;
-    try {
-      stored = await this.load();
-    } catch (err) {
-      return { succeeded: false, error: err instanceof Error ? err.message : String(err) };
-    }
-    const existing = stored.get(record.id);
-    if (existing) {
-      if (recordsEqual(existing, record)) return { succeeded: true };
-      return {
-        succeeded: false,
-        error: `corpus conflict: id '${record.id}' is already stored in ${this.path} with a different record; a learned fact is append-only \u2014 re-mint the id or reconcile before re-appending`
-      };
-    }
-    await this.appendLine(record);
-    return { succeeded: true };
-  }
-  async query(filter) {
-    const stored = await this.load();
-    return applyFilter([...stored.values()], filter);
-  }
-  async load() {
-    const fs = await import("fs/promises");
-    let text;
-    try {
-      text = await fs.readFile(this.path, "utf8");
-    } catch (err) {
-      if (isNoEntError(err)) return /* @__PURE__ */ new Map();
-      throw err;
-    }
-    const lines = text.split("\n").filter((line) => line.length > 0);
-    const byId = /* @__PURE__ */ new Map();
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch (err) {
-        throw new Error(
-          `corpus corrupted: ${this.path} line ${i + 1} is not valid JSON: ` + (err instanceof Error ? err.message : String(err))
-        );
-      }
-      assertCorpusRecord(parsed, `corpus ${this.path} line ${i + 1}`);
-      const existing = byId.get(parsed.id);
-      if (existing && !recordsEqual(existing, parsed)) {
-        throw new Error(
-          `corpus corrupted: ${this.path} has two different records for id '${parsed.id}'; an append-only corpus must never hold a conflicting re-append under one id`
-        );
-      }
-      byId.set(parsed.id, freeze(parsed));
-    }
-    return byId;
-  }
-  async appendLine(record) {
-    const fs = await import("fs/promises");
-    const path = await import("path");
-    await fs.mkdir(path.dirname(this.path), { recursive: true });
-    const fh = await fs.open(this.path, "a");
-    try {
-      await fh.write(`${JSON.stringify(record)}
-`);
-      await fh.sync();
-    } finally {
-      await fh.close();
-    }
-  }
-};
-async function renderCorpusToInstructions(opts) {
-  const { corpus, filter, profile, target = "prompt", maxLines } = opts;
-  if (maxLines !== void 0 && (!Number.isInteger(maxLines) || maxLines < 0)) {
-    throw new Error(
-      `renderCorpusToInstructions: maxLines must be a non-negative integer, got ${maxLines}`
-    );
-  }
-  const matched = await corpus.query(filter);
-  const capped = maxLines !== void 0 ? matched.slice(0, maxLines) : matched;
-  const lines = capped.map(renderLine);
-  if (lines.length === 0) return structuredClone(profile);
-  const next = structuredClone(profile);
-  if (target === "resources") {
-    const resources = next.resources ?? {};
-    const prior = resources.instructions;
-    if (prior !== void 0 && typeof prior !== "string") {
-      throw new Error(
-        "renderCorpusToInstructions: resources.instructions is an AgentProfileResourceRef, not a string; cannot string-append corpus facts without dropping the ref (pass target: 'prompt' or pre-resolve the ref)"
-      );
-    }
-    const blob = [prior, ...lines].filter((s) => typeof s === "string" && s.length > 0);
-    next.resources = { ...resources, instructions: blob.join("\n") };
-    return next;
-  }
-  const prompt = next.prompt ?? {};
-  next.prompt = { ...prompt, instructions: [...prompt.instructions ?? [], ...lines] };
-  return next;
-}
-function renderLine(record) {
-  return record.rationale ? `${record.claim} (${record.rationale})` : record.claim;
-}
-function freeze(record) {
-  return Object.freeze({ ...record });
-}
-function isNoEntError(err) {
-  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
-}
-
-// src/runtime/personify/registry.ts
-function createShapeRegistry() {
-  const shapes = /* @__PURE__ */ new Map();
-  return {
-    register(name, factory) {
-      if (shapes.has(name)) {
-        throw new ValidationError(`shape registry: shape "${name}" already registered`);
-      }
-      shapes.set(name, factory);
-    },
-    resolve(name) {
-      const factory = shapes.get(name);
-      if (!factory) {
-        return { succeeded: false, error: `shape registry: unknown shape "${name}"` };
-      }
-      return { succeeded: true, value: factory };
-    },
-    names() {
-      return [...shapes.keys()];
-    }
-  };
-}
-var builtinShapes = createShapeRegistry();
-function registerShape(name, factory) {
-  builtinShapes.register(name, factory);
-}
-
-// src/runtime/personify/persona.ts
-function definePersona(input) {
-  if (!input.executors.registry && !input.executors.seams) {
-    throw new ValidationError(
-      `definePersona("${input.name}"): executors must supply a registry or a seams bag (built-in runtimes read their seams off ExecutorContext; neither was provided)`
-    );
-  }
-  if (!input.root || typeof input.root !== "object" || !("harness" in input.root)) {
-    throw new ValidationError(`definePersona("${input.name}"): root must be an AgentSpec`);
-  }
-  return Object.freeze({
-    name: input.name,
-    root: input.root,
-    directive: input.directive,
-    context: input.context,
-    executors: input.executors,
-    ...input.extensions ? { extensions: input.extensions } : {}
-  });
-}
-function createShapeContext(persona, budget, analyst) {
-  return {
-    persona,
-    budget,
-    ...analyst ? { analyst } : {},
-    spawnChild(name, spec) {
-      const agent = {
-        name,
-        executorSpec: spec,
-        act() {
-          throw new ValidationError(
-            `personify: spawned child "${name}" was run directly; its executorSpec drives it (a leaf, or \u2014 for a driver child \u2014 a nested scope through the recursive driver-executor)`
-          );
-        }
-      };
-      return agent;
-    },
-    childSpec(profile, harness) {
-      return {
-        profile,
-        harness: harness === void 0 ? persona.root.harness : harness,
-        ...persona.root.executor ? { executor: persona.root.executor } : {}
-      };
-    }
-  };
-}
-async function runPersonified(options) {
-  const { persona } = options;
-  const shape = resolveShape(options.shape);
-  const shapeBudget = resolveShapeBudget(options.budget, options.shapeBudget);
-  const ctx = createShapeContext(persona, shapeBudget, options.analyst);
-  const rootAgent = shape(ctx);
-  const executors = personaRegistry(persona);
-  const supervisor = createSupervisor();
-  if (options.handle) supervisor.attach(options.handle);
-  const supervisorOpts = {
-    budget: options.budget,
-    runId: options.runId ?? `${persona.name}:${shapeName(options.shape, shape)}`,
-    journal: options.journal ?? new InMemorySpawnJournal(),
-    blobs: options.blobs ?? new InMemoryResultBlobStore(),
-    executors,
-    ...options.maxDepth !== void 0 ? { maxDepth: options.maxDepth } : {},
-    ...options.maxRestarts !== void 0 ? { maxRestarts: options.maxRestarts } : {},
-    ...options.withinMs !== void 0 ? { withinMs: options.withinMs } : {},
-    ...options.now ? { now: options.now } : {},
-    ...options.signal ? { signal: options.signal } : {},
-    ...options.hooks ? { hooks: options.hooks } : {}
-  };
-  return supervisor.run(rootAgent, options.task, supervisorOpts);
-}
-function resolveShape(shape) {
-  if (typeof shape !== "string") return shape;
-  const resolved = builtinShapes.resolve(shape);
-  if (!resolved.succeeded) {
-    throw new ValidationError(
-      `runPersonified: ${resolved.error} (registered: ${builtinShapes.names().join(", ")})`
-    );
-  }
-  return resolved.value;
-}
-function shapeName(shape, _resolved) {
-  return typeof shape === "string" ? shape : shape.name || "shape";
-}
-function resolveShapeBudget(root, over) {
-  const fanout2 = over?.fanout ?? defaultFanout;
-  const perChild = over?.perChild ?? {
-    maxIterations: Math.max(1, Math.floor(root.maxIterations / fanout2)),
-    maxTokens: Math.max(1, Math.floor(root.maxTokens / fanout2)),
-    ...root.maxUsd !== void 0 ? { maxUsd: root.maxUsd / fanout2 } : {},
-    ...root.deadlineMs !== void 0 ? { deadlineMs: root.deadlineMs } : {}
-  };
-  return { perChild, fanout: fanout2 };
-}
-var defaultFanout = 3;
-function personaRegistry(persona) {
-  const { registry, seams } = persona.executors;
-  if (registry) return withDriverExecutor(registry);
-  if (!seams) {
-    throw new ValidationError(
-      `personify: persona "${persona.name}" supplies neither a registry nor seams`
-    );
-  }
-  return withDriverExecutor(withSeams(createExecutorRegistry(), seams));
-}
-function withSeams(base, seams) {
-  return {
-    register(runtime, factory) {
-      base.register(runtime, factory);
-    },
-    resolve(spec) {
-      const resolved = base.resolve(spec);
-      if (!resolved.succeeded) return resolved;
-      const inner = resolved.value;
-      const wrapped = (s, ctx) => inner(s, mergeSeams(ctx, seams));
-      return { succeeded: true, value: wrapped };
-    }
-  };
-}
-function mergeSeams(ctx, seams) {
-  return { signal: ctx.signal, seams: { ...seams, ...ctx.seams } };
-}
-
-// src/runtime/personify/trajectory.ts
-var defaultEqualKTolerance = 0.05;
-async function trajectoryReport(journal, blobs, root, options = {}) {
-  const events = await journal.loadTree(root);
-  if (events === void 0) {
-    throw new Error(`trajectoryReport: no journaled tree for root '${root}'`);
-  }
-  const spawns = events.filter(isNodeCreation).sort(bySeq);
-  const closes = events.filter((ev) => ev.kind !== "spawned" && ev.kind !== "waiting" && ev.kind !== "metered").sort(bySeq);
-  const nodes = /* @__PURE__ */ new Map();
-  for (const ev of spawns) {
-    nodes.set(ev.id, {
-      id: ev.id,
-      parent: ev.parent,
-      label: ev.label,
-      // A wait-state has no executor, so it has no runtime in the executor sense — it is tagged
-      // `'wait'` so a reader can separate zero-cost waiting from paid work in the trajectory.
-      runtime: ev.kind === "waiting" ? "wait" : ev.runtime,
-      status: ev.kind === "waiting" ? "waiting" : "pending",
-      ownSpend: zeroSpend(),
-      children: []
-    });
-  }
-  for (const ev of closes) {
-    const node = requireNode(nodes, ev.id, root);
-    if (ev.kind === "cancelled") {
-      node.status = "cancelled";
-      continue;
-    }
-    if (ev.kind === "woken") {
-      node.status = ev.by === "cancelled" ? "cancelled" : "done";
-      node.outRef = ev.outRef;
-      continue;
-    }
-    node.status = ev.status === "done" ? "done" : "failed";
-    node.ownSpend = ev.spent;
-    node.verdict = ev.verdict;
-    node.outRef = ev.outRef;
-  }
-  for (const ev of events) {
-    if (ev.kind !== "metered") continue;
-    const node = requireNode(nodes, ev.id, root);
-    node.ownSpend = addNodeSpend(node.ownSpend, ev.spend);
-  }
-  if (!nodes.has(root)) {
-    throw new Error(
-      `trajectoryReport: root '${root}' has no spawned event in its journaled tree (corrupted log)`
-    );
-  }
-  for (const ev of spawns) {
-    if (ev.parent === void 0) continue;
-    requireNode(nodes, ev.parent, root).children.push(ev.id);
-  }
-  const rolledUp = rollUpSpend(nodes, root);
-  if (options.withOutputs) {
-    await attachOutputs(nodes, blobs);
-  }
-  const ordered = spawns.map((ev) => nodes.get(ev.id)).filter(isNode);
-  const reported = ordered.map(
-    (node) => freezeNode(node, requireSpend(rolledUp, node.id, root))
-  );
-  return {
-    root,
-    nodes: reported,
-    total: requireSpend(rolledUp, root, root),
-    statusCounts: countStatuses(reported)
-  };
-}
-function equalKOnCost(arms, options = {}) {
-  if (arms.length === 0) {
-    throw new Error("equalKOnCost: no arms to compare");
-  }
-  const tolerance = options.tolerance ?? defaultEqualKTolerance;
-  const armCosts = arms.map((arm) => ({
-    label: arm.label,
-    tokens: arm.report.total.tokens.input + arm.report.total.tokens.output,
-    usd: arm.report.total.usd,
-    iterations: arm.report.total.iterations
-  }));
-  const tokenValues = armCosts.map((a) => a.tokens);
-  const usdValues = armCosts.map((a) => a.usd);
-  const spread = {
-    tokens: spreadOf(tokenValues),
-    usd: spreadOf(usdValues)
-  };
-  const withinTolerance = fractionalSpread(tokenValues) <= tolerance && fractionalSpread(usdValues) <= tolerance;
-  return {
-    withinTolerance,
-    arms: armCosts,
-    spread,
-    tolerance
-  };
-}
-function rollUpSpend(nodes, root) {
-  const rolled = /* @__PURE__ */ new Map();
-  const stack = [{ id: root, expanded: false }];
-  while (stack.length > 0) {
-    const frame = stack.pop();
-    if (frame === void 0) continue;
-    const node = requireNode(nodes, frame.id, root);
-    if (!frame.expanded) {
-      stack.push({ id: frame.id, expanded: true });
-      for (const child of node.children) stack.push({ id: child, expanded: false });
-      continue;
-    }
-    const sum = cloneSpend(node.ownSpend);
-    for (const child of node.children) addSpend(sum, requireSpend(rolled, child, root));
-    rolled.set(frame.id, sum);
-  }
-  return rolled;
-}
-async function attachOutputs(nodes, blobs) {
-  for (const node of nodes.values()) {
-    if (node.status !== "done" || node.outRef === void 0) continue;
-    const out = await blobs.get(node.outRef);
-    if (out === void 0) {
-      throw new Error(
-        `trajectoryReport: blob store has no artifact for outRef '${node.outRef}' (node '${node.id}')`
-      );
-    }
-    node.output = out;
-  }
-}
-function freezeNode(node, rolledUpSpend) {
-  return {
-    id: node.id,
-    parent: node.parent,
-    children: [...node.children],
-    label: node.label,
-    runtime: node.runtime,
-    status: node.status,
-    ownSpend: node.ownSpend,
-    rolledUpSpend,
-    verdict: node.verdict,
-    output: node.output,
-    outRef: node.outRef
-  };
-}
-function countStatuses(reported) {
-  const counts = {
-    done: 0,
-    failed: 0,
-    cancelled: 0,
-    pending: 0,
-    waiting: 0
-  };
-  for (const node of reported) counts[node.status] += 1;
-  return counts;
-}
-function zeroSpend() {
-  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
-}
-function addNodeSpend(a, b) {
-  return {
-    iterations: a.iterations + b.iterations,
-    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },
-    usd: a.usd + b.usd,
-    ...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
-    ms: a.ms + b.ms
-  };
-}
-function cloneSpend(spend) {
-  return {
-    iterations: spend.iterations,
-    tokens: { input: spend.tokens.input, output: spend.tokens.output },
-    usd: spend.usd,
-    ...spend.usdKnown === false ? { usdKnown: false } : {},
-    ms: spend.ms
-  };
-}
-function addSpend(acc, delta) {
-  acc.iterations += delta.iterations;
-  addTokenUsage(acc.tokens, delta.tokens);
-  acc.usd += delta.usd;
-  if (delta.usdKnown === false) acc.usdKnown = false;
-  acc.ms += delta.ms;
-}
-function spreadOf(values) {
-  if (values.length === 0) return 0;
-  return Math.max(...values) - Math.min(...values);
-}
-function fractionalSpread(values) {
-  const spread = spreadOf(values);
-  if (spread === 0) return 0;
-  const median = medianOf(values);
-  if (median === 0) {
-    throw new Error(
-      "equalKOnCost: arms have a non-zero cost spread on a zero-median channel; cannot express it as a fraction"
-    );
-  }
-  return spread / median;
-}
-function medianOf(values) {
-  if (values.length === 0) {
-    throw new Error("equalKOnCost: cannot take the median of an empty channel");
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  const hi = sorted[mid];
-  if (sorted.length % 2 !== 0) return hi;
-  const lo = sorted[mid - 1];
-  return (lo + hi) / 2;
-}
-function isNodeCreation(ev) {
-  return ev.kind === "spawned" || ev.kind === "waiting";
-}
-function isNode(node) {
-  return node !== void 0;
-}
-function bySeq(a, b) {
-  return a.seq - b.seq;
-}
-function requireNode(nodes, id, root) {
-  const node = nodes.get(id);
-  if (!node) {
-    throw new Error(
-      `trajectoryReport: tree '${root}' references node '${id}' with no prior spawn (corrupted log)`
-    );
-  }
-  return node;
-}
-function requireSpend(rolled, id, root) {
-  const spend = rolled.get(id);
-  if (!spend) {
-    throw new Error(
-      `trajectoryReport: node '${id}' was never rolled up in tree '${root}' (unreachable from root)`
-    );
-  }
-  return spend;
-}
-
-// src/runtime/promotion-gate.ts
-import { heldoutSignificance } from "@tangle-network/agent-eval/campaign";
-function promotionGate(opts) {
-  const mode = opts.mode ?? "superiority";
-  if (opts.candidate === opts.incumbent) {
-    return {
-      promoted: false,
-      reason: "identical-champion",
-      mode,
-      n: 0,
-      lift: { mean: 0, median: 0, low: 0, high: 0 }
-    };
-  }
-  const before = [];
-  const after = [];
-  const incUsd = [];
-  const candUsd = [];
-  const incMs = [];
-  const candMs = [];
-  const cellIds = [];
-  for (const row of opts.report.perTask) {
-    const inc = row.cells?.[opts.incumbent];
-    const cand = row.cells?.[opts.candidate];
-    if (!inc || !cand) continue;
-    before.push(inc.score);
-    after.push(cand.score);
-    incUsd.push(inc.usd);
-    candUsd.push(cand.usd);
-    incMs.push(inc.ms);
-    candMs.push(cand.ms);
-    cellIds.push(row.taskId);
-  }
-  if (before.length === 0) {
-    throw new Error(
-      `promotionGate: no holdout task carried cells for both "${opts.incumbent}" and "${opts.candidate}" \u2014 the report must come from a run that included both strategies`
-    );
-  }
-  const sig = heldoutSignificance(
-    { before, after, cellIds },
-    {
-      deltaThreshold: opts.deltaThreshold ?? 0,
-      minProductiveRuns: opts.minPairedTasks ?? 6,
-      statistic: opts.statistic ?? "mean",
-      ...opts.seed !== void 0 ? { seed: opts.seed } : {},
-      ...opts.resamples !== void 0 ? { resamples: opts.resamples } : {}
-    }
-  );
-  const lift = {
-    mean: sig.bootstrap.mean,
-    median: sig.bootstrap.median,
-    low: sig.bootstrap.low,
-    high: sig.bootstrap.high
-  };
-  const latSig = heldoutSignificance(
-    { before: incMs, after: candMs, cellIds },
-    {
-      deltaThreshold: 0,
-      minProductiveRuns: 1,
-      statistic: opts.statistic ?? "mean",
-      ...opts.seed !== void 0 ? { seed: opts.seed } : {},
-      ...opts.resamples !== void 0 ? { resamples: opts.resamples } : {}
-    }
-  );
-  const latency = {
-    mean: latSig.bootstrap.mean,
-    median: latSig.bootstrap.median,
-    low: latSig.bootstrap.low,
-    high: latSig.bootstrap.high
-  };
-  if (mode === "superiority") {
-    if (sig.fewRuns) return { promoted: false, reason: "few-tasks", mode, n: sig.n, lift, latency };
-    return sig.significant ? { promoted: true, reason: "significant", mode, n: sig.n, lift, latency } : { promoted: false, reason: "no-margin", mode, n: sig.n, lift, latency };
-  }
-  const tolerance = opts.scoreTolerance ?? 0.05;
-  const scoreSig = heldoutSignificance(
-    { before, after, cellIds },
-    {
-      deltaThreshold: -tolerance,
-      minProductiveRuns: opts.minPairedTasks ?? 6,
-      statistic: opts.statistic ?? "mean",
-      ...opts.seed !== void 0 ? { seed: opts.seed } : {},
-      ...opts.resamples !== void 0 ? { resamples: opts.resamples } : {}
-    }
-  );
-  const costSig = heldoutSignificance(
-    { before: candUsd, after: incUsd, cellIds },
-    {
-      deltaThreshold: 0,
-      minProductiveRuns: opts.minPairedTasks ?? 6,
-      statistic: opts.statistic ?? "mean",
-      ...opts.seed !== void 0 ? { seed: opts.seed } : {},
-      ...opts.resamples !== void 0 ? { resamples: opts.resamples } : {}
-    }
-  );
-  const costSavings = {
-    mean: costSig.bootstrap.mean,
-    median: costSig.bootstrap.median,
-    low: costSig.bootstrap.low,
-    high: costSig.bootstrap.high
-  };
-  if (scoreSig.fewRuns)
-    return { promoted: false, reason: "few-tasks", mode, n: scoreSig.n, lift, costSavings, latency };
-  if (!scoreSig.significant)
-    return {
-      promoted: false,
-      reason: "non-inferiority-unproven",
-      mode,
-      n: scoreSig.n,
-      lift,
-      costSavings,
-      latency
-    };
-  if (!costSig.significant)
-    return {
-      promoted: false,
-      reason: "not-cheaper",
-      mode,
-      n: scoreSig.n,
-      lift,
-      costSavings,
-      latency
-    };
-  return {
-    promoted: true,
-    reason: "non-inferior-and-cheaper",
-    mode,
-    n: scoreSig.n,
-    lift,
-    costSavings,
-    latency
-  };
-}
-
-// src/runtime/report-usage.ts
-function reportLoopUsage(cost, result, source = "loop") {
-  cost.observe(result.costUsd, source);
-  cost.observeTokens(result.tokenUsage);
-}
-
-// src/runtime/run-benchmark.ts
-import { pairedBootstrap as pairedBootstrap2, paretoFrontier } from "@tangle-network/agent-eval";
-async function pool(items, limit, fn) {
-  const out = new Array(items.length);
-  let next = 0;
-  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
-    while (next < items.length) {
-      const i = next;
-      next += 1;
-      out[i] = await fn(items[i], i);
-    }
-  });
-  await Promise.all(workers);
-  return out;
-}
-async function runBenchmark(cfg) {
-  const strategies = cfg.strategies ?? [sample, refine];
-  const budget = cfg.budget ?? 3;
-  const concurrency = cfg.concurrency ?? 3;
-  let settled = 0;
-  const perTask = await pool(cfg.tasks, concurrency, async (task) => {
-    const cells = {};
-    const errors = {};
-    let row;
-    try {
-      for (const s of strategies) {
-        try {
-          const r = await runAgentic({
-            ...cfg.worker,
-            surface: cfg.environment,
-            task,
-            strategy: s,
-            budget,
-            ...cfg.hooks ? { hooks: cfg.hooks } : {}
-          });
-          cells[s.name] = {
-            score: r.score,
-            resolved: r.resolved,
-            progression: r.progression,
-            usd: r.usd,
-            ms: r.ms,
-            tokens: r.tokens
-          };
-        } catch (e) {
-          errors[s.name] = e instanceof Error ? e.message.slice(0, 300) : String(e);
-          cells[s.name] = {
-            score: 0,
-            resolved: false,
-            progression: [],
-            usd: 0,
-            ms: 0,
-            tokens: { input: 0, output: 0 }
-          };
-        }
-      }
-      row = {
-        taskId: task.id,
-        cells,
-        ...Object.keys(errors).length > 0 ? { errors } : {}
-      };
-    } catch (e) {
-      row = { taskId: task.id, error: e instanceof Error ? e.message.slice(0, 300) : String(e) };
-    }
-    settled += 1;
-    cfg.onTask?.(row, settled, cfg.tasks.length);
-    return row;
-  });
-  const ok = perTask.filter(
-    (r) => !!r.cells
-  );
-  const mean2 = (xs) => xs.length ? xs.reduce((s, x) => s + x, 0) / xs.length : 0;
-  const perStrategy = {};
-  for (const s of strategies) {
-    const cells = ok.map((r) => r.cells[s.name]).filter((c) => !!c);
-    perStrategy[s.name] = {
-      score: mean2(cells.map((c) => c.score)),
-      resolved: mean2(cells.map((c) => c.resolved ? 1 : 0)),
-      usd: mean2(cells.map((c) => c.usd)),
-      ms: mean2(cells.map((c) => c.ms))
-    };
-  }
-  const frontier = paretoFrontier(
-    Object.entries(perStrategy).map(([name, v]) => ({ name, score: v.score, usd: v.usd })),
-    [
-      { name: "score", direction: "maximize", value: (c) => c.score },
-      { name: "usd", direction: "minimize", value: (c) => c.usd }
-    ]
-  ).frontier.map((c) => c.name);
-  const report = {
-    n: ok.length,
-    excluded: perTask.length - ok.length,
-    perStrategy,
-    perTask,
-    pareto: frontier
-  };
-  const names = strategies.map((s) => s.name);
-  if (names.includes("refine") && names.includes("sample") && ok.length >= 2) {
-    const b = pairedBootstrap2(
-      ok.map((r) => r.cells.sample?.score ?? 0),
-      ok.map((r) => r.cells.refine?.score ?? 0)
-    );
-    report.refineVsSample = { mean: b.mean, low: b.low, high: b.high, n: b.n };
-  }
-  return report;
-}
-function printBenchmarkReport(report) {
-  const pct2 = (x) => `${(x * 100).toFixed(1)}%`;
-  const pp = (x) => `${x >= 0 ? "+" : ""}${(x * 100).toFixed(1)}pp`;
-  console.log(
-    `
-=== benchmark \xB7 n=${report.n}${report.excluded ? ` (excluded ${report.excluded})` : ""} ===`
-  );
-  console.log(
-    `  ${"strategy".padEnd(16)} ${"score".padStart(7)} ${"resolved".padStart(9)} ${"$/task".padStart(8)} ${"s/task".padStart(7)}`
-  );
-  for (const [s, v] of Object.entries(report.perStrategy))
-    console.log(
-      `  ${(report.pareto.includes(s) ? `${s} *` : s).padEnd(16)} ${pct2(v.score).padStart(7)} ${pct2(v.resolved).padStart(9)} ${`$${v.usd.toFixed(3)}`.padStart(8)} ${(v.ms / 1e3).toFixed(0).padStart(6)}s`
-    );
-  if (report.pareto.length) console.log(`  * = on the (score, $) Pareto frontier`);
-  for (const row of report.perTask)
-    if (row.error) console.log(`  \u26A0 ${row.taskId}: ${row.error.slice(0, 120)}`);
-  const l = report.refineVsSample;
-  if (l) {
-    const sig = l.low > 0 ? "SIGNIF +" : l.high < 0 ? "SIGNIF -" : "n.s.";
-    console.log(`  refine \u2212 sample: ${pp(l.mean)}  CI [${pp(l.low)}, ${pp(l.high)}]  (${sig})`);
-  }
-}
-
-// src/runtime/sandbox-run.ts
-var SandboxRunAbortError = class extends Error {
-  name = "AbortError";
-  /** Events drained from the stream before the abort interrupted the turn. */
-  events;
-  /** The last artifact read error, if the abort fired during the retry loop. */
-  readError;
-  constructor(events, readError) {
-    super("aborted");
-    this.events = events;
-    if (readError !== void 0) this.readError = readError;
-  }
-};
-async function openSandboxRun(client, options, deliverable) {
-  const runId = options.runId ?? `sandbox-run-${randomSuffix()}`;
-  const now = options.now ?? Date.now;
-  const capabilities = await probeSandboxCapabilities(client);
-  const lineage = createSandboxLineage(client, capabilities, {
-    ...options.maxConcurrency !== void 0 ? { maxConcurrency: options.maxConcurrency } : {}
-  });
-  let handle;
-  let started = false;
-  let runStartedAt;
-  let failed = false;
-  let turnCount = 0;
-  function emit(event) {
-    notifyRuntimeHookEvent(
-      options.hooks,
-      {
-        id: `${runId}:${event.target}:${event.phase}${event.stepIndex === void 0 ? "" : `:${event.stepIndex}`}`,
-        runId,
-        scenarioId: options.scenarioId,
-        target: event.target,
-        phase: event.phase,
-        timestamp: event.timestamp,
-        stepIndex: event.stepIndex,
-        payload: event.payload,
-        metadata: { producer: "openSandboxRun" }
-      },
-      { signal: options.signal }
-    );
-  }
-  const runPayload = () => ({
-    agentName: options.agentRun.name ?? options.agentRun.profile.name ?? "agent",
-    profileName: options.agentRun.profile.name,
-    backendType: backendType(options.agentRun),
-    deliverableKind: deliverable.kind,
-    ...deliverable.kind === "artifact" ? { deliverablePath: deliverable.path } : {},
-    ...handle ? { sessionId: handle.sessionId, sandboxId: handle.box.id } : {}
-  });
-  const turnPayload = (prompt, turnKind, startedAt, result, error) => ({
-    ...runPayload(),
-    turnKind,
-    promptChars: prompt.length,
-    promptHash: hashText(prompt),
-    ...result !== void 0 || error !== void 0 ? { durationMs: Math.max(0, now() - startedAt) } : {},
-    ...result ? {
-      eventCount: result.events.length,
-      eventTypes: eventTypeCounts(result.events),
-      ...result.readError !== void 0 ? { readError: result.readError } : {}
-    } : {},
-    ...error !== void 0 ? { error: errorMessage(error) } : {}
-  });
-  async function settle2(box, events) {
-    const collected = [];
-    try {
-      for await (const ev of events) collected.push(ev);
-    } catch (err) {
-      if (isAbortError(err)) throw new SandboxRunAbortError(collected);
-      throw err;
-    }
-    if (deliverable.kind === "events") {
-      return { out: deliverable.fromEvents(collected), events: collected };
-    }
-    if (options.signal.aborted) throw new SandboxRunAbortError(collected);
-    let raw = "";
-    let readError;
-    const readAttempts = 4;
-    const readDelayMs = options.readRetryDelayMs ?? 1e3;
-    for (let attempt = 0; attempt < readAttempts; attempt += 1) {
-      if (options.signal.aborted) throw new SandboxRunAbortError(collected, readError);
-      try {
-        raw = await box.fs.read(deliverable.path);
-        readError = void 0;
-        break;
-      } catch (err) {
-        readError = err instanceof Error ? err.message : String(err);
-        if (attempt < readAttempts - 1 && readDelayMs > 0)
-          await sleep(readDelayMs * (attempt + 1), options.signal);
-      }
-    }
-    return {
-      out: deliverable.fromArtifact(raw, collected),
-      events: collected,
-      ...readError !== void 0 ? { readError } : {}
-    };
-  }
-  return {
-    get box() {
-      if (!handle) throw new Error("openSandboxRun: box unavailable before start()");
-      return handle.box;
-    },
-    get sessionId() {
-      if (!handle) throw new Error("openSandboxRun: sessionId unavailable before start()");
-      return handle.sessionId;
-    },
-    async start(prompt) {
-      if (started)
-        throw new Error(
-          "openSandboxRun: start() already called \u2014 use resume() to continue the session"
-        );
-      started = true;
-      runStartedAt = now();
-      emit({
-        target: "agent.run",
-        phase: "before",
-        timestamp: runStartedAt,
-        payload: { ...runPayload(), turnCount: 0 }
-      });
-      const stepIndex = turnCount;
-      const turnStartedAt = now();
-      emit({
-        target: "agent.turn",
-        phase: "before",
-        timestamp: turnStartedAt,
-        stepIndex,
-        payload: turnPayload(prompt, "start", turnStartedAt)
-      });
-      try {
-        const r = await lineage.start(
-          options.agentRun,
-          prompt,
-          options.signal,
-          options.promptOptions
-        );
-        handle = r.handle;
-        await options.beforeStart?.({
-          box: handle.box,
-          sessionId: handle.sessionId,
-          signal: options.signal
-        });
-        const result = await settle2(handle.box, r.events);
-        turnCount += 1;
-        emit({
-          target: "agent.turn",
-          phase: "after",
-          timestamp: now(),
-          stepIndex,
-          payload: turnPayload(prompt, "start", turnStartedAt, result)
-        });
-        return result;
-      } catch (error) {
-        failed = true;
-        emit({
-          target: "agent.turn",
-          phase: "error",
-          timestamp: now(),
-          stepIndex,
-          payload: turnPayload(prompt, "start", turnStartedAt, void 0, error)
-        });
-        emit({
-          target: "agent.run",
-          phase: "error",
-          timestamp: now(),
-          payload: { ...runPayload(), turnCount, error: errorMessage(error) }
-        });
-        throw error;
-      }
-    },
-    async resume(prompt) {
-      if (!handle) throw new Error("openSandboxRun: resume() called before start()");
-      const stepIndex = turnCount;
-      const turnStartedAt = now();
-      emit({
-        target: "agent.turn",
-        phase: "before",
-        timestamp: turnStartedAt,
-        stepIndex,
-        payload: turnPayload(prompt, "resume", turnStartedAt)
-      });
-      try {
-        const result = await settle2(
-          handle.box,
-          await lineage.continue(handle, prompt, options.signal, options.promptOptions)
-        );
-        turnCount += 1;
-        emit({
-          target: "agent.turn",
-          phase: "after",
-          timestamp: now(),
-          stepIndex,
-          payload: turnPayload(prompt, "resume", turnStartedAt, result)
-        });
-        return result;
-      } catch (error) {
-        failed = true;
-        emit({
-          target: "agent.turn",
-          phase: "error",
-          timestamp: now(),
-          stepIndex,
-          payload: turnPayload(prompt, "resume", turnStartedAt, void 0, error)
-        });
-        emit({
-          target: "agent.run",
-          phase: "error",
-          timestamp: now(),
-          payload: { ...runPayload(), turnCount, error: errorMessage(error) }
-        });
-        throw error;
-      }
-    },
-    async close() {
-      await lineage.teardown();
-      if (runStartedAt !== void 0) {
-        emit({
-          target: "agent.run",
-          phase: "after",
-          timestamp: now(),
-          payload: {
-            ...runPayload(),
-            turnCount,
-            status: failed ? "error" : "completed",
-            durationMs: Math.max(0, now() - runStartedAt)
-          }
-        });
-      }
-    }
-  };
-}
-function backendType(spec) {
-  const backend = spec.sandboxOverrides?.backend;
-  return backend?.type;
-}
-function eventTypeCounts(events) {
-  const counts = {};
-  for (const event of events) counts[event.type] = (counts[event.type] ?? 0) + 1;
-  return counts;
-}
-function hashText(value) {
-  let hash = 2166136261;
-  for (let i = 0; i < value.length; i += 1) {
-    hash ^= value.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/runtime/strategy-author.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
-var strategyAuthorContract = `
-You author an OPTIMIZATION STRATEGY for an agentic loop system. A strategy decides how to
-spend a compute budget to beat a task's deployable check. You compose exactly two steps:
-
-  shot(spec?: { handle?, messages?, steer?, persona?, tools? }): Promise<ShotResult | null>
-    Runs ONE worker attempt (a bounded tool loop) over an artifact.
-    - omit handle  => the shot opens its OWN fresh artifact and closes it after (a sample).
-    - pass handle  => the shot CONTINUES that artifact (state accumulates across shots).
-    - messages     => the carried conversation (pass the previous ShotResult.messages to continue).
-    - steer        => a corrective instruction injected before the shot.
-    - persona      => { systemPrompt?, model? } \u2014 give THIS shot its own role and/or model
-      (multi-agent strategies: a researcher shot then an engineer shot, a panel of k
-      personas over one budget). On a fresh shot the systemPrompt replaces the task's; on
-      a carried conversation it arrives as a hand-off message. Same conserved budget.
-    - tools        => string[] \u2014 restrict THIS shot to a subset of the task's tools by
-      name (focus an explore shot on read-only tools, an execute shot on write tools).
-      Restriction-only; unknown names make the shot fail. ALWAYS select from
-      await listTools(handle) \u2014 never hardcode. Omitted => the shot sees every tool.
-    ShotResult = { messages, score (0..1 on the task's check), passes, total, completions, toolErrors }
-    Returns null if the attempt failed infra-wise.
-
-  critique(messages): Promise<string | null>
-    A firewalled trace-analyst reads the attempt's trajectory and returns ONE corrective
-    instruction (or null when it judges the work complete). Costs ~1 completion.
-
-  consult(messages, instruction): Promise<string | null>
-    The RAW analyst channel: the same firewalled critic answers YOUR instruction over the
-    trajectory verbatim (no reformatting) \u2014 use it when you need a specific reply format
-    (a decision, a prediction). Costs ~1 completion.
-
-  surface.open(task) / surface.close(handle)
-    Open a persistent artifact you manage yourself (remember to close in a finally).
-    close is idempotent \u2014 closing an already-closed handle is a safe no-op.
-
-  listTools(handle): Promise<Array<{ name, description? }>>
-    The tools THIS task actually offers. TOOL SETS VARY PER TASK \u2014 if you restrict a
-    shot with \`tools\`, you MUST pick names from await listTools(handle); hardcoding
-    names from an example kills your shots on every task whose tools differ.
-
-Rules:
-- ALWAYS await every shot/critique/surface call \u2014 a floating promise that rejects
-  crashes the whole benchmark run.
-- Stay within ~budget total shots; every shot/critique spends from a conserved pool.
-- For a FRESH attempt OMIT \`messages\` entirely (never pass \`[]\` \u2014 an empty array is a
-  fresh conversation too, but be explicit). To CONTINUE, pass the previous
-  ShotResult.messages unchanged.
-- Return { score, resolved, completions, progression, shots } \u2014 score = the BEST checkpoint
-  you reached (keep-best, never final-state), progression = score after each shot.
-- The module must be EXACTLY this shape (no other imports, no commentary outside code):
-
-import { defineStrategy } from '@tangle-network/agent-runtime/loops'
-export default defineStrategy('your-strategy-name', async ({ surface, task, budget, shot, critique, listTools }) => {
-  // your composition (listTools comes from the destructured context \u2014 it is NOT a global)
-})
-`;
-function assertStrategyContract(code) {
-  const allowedImport = /^\s*import\s+\{[^}]*\}\s+from\s+['"]@tangle-network\/agent-runtime\/loops['"]/;
-  for (const line of code.split("\n")) {
-    if (/^\s*import\s/.test(line) && !allowedImport.test(line)) {
-      throw new Error(`authored code rejected: foreign import \u2014 ${line.trim().slice(0, 120)}`);
-    }
-  }
-  const banned = [
-    [/\brequire\s*\(/, "require()"],
-    [/\bimport\s*\(/, "dynamic import()"],
-    [/\beval\s*\(/, "eval()"],
-    [/new\s+Function\s*\(/, "new Function()"],
-    [/\bprocess\s*[.[]/, "process access"],
-    [/\bglobalThis\s*[.[]/, "globalThis access"],
-    [/\bfetch\s*\(/, "network access"],
-    [/child_process|node:fs|node:net|node:http|worker_threads/, "node builtin access"]
-  ];
-  for (const [re, what] of banned) {
-    if (re.test(code)) throw new Error(`authored code rejected: ${what}`);
-  }
-}
-async function requestAuthoredCode(opts, model) {
-  const res = await opts.chat.chat(
-    {
-      ...model ? { model } : {},
-      ...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
-      ...opts.maxTokens !== void 0 ? { maxTokens: opts.maxTokens } : {},
-      messages: [
-        {
-          role: "system",
-          content: "You are a senior researcher authoring optimization strategies for agent loops: you read per-task losses like experimental data, form a mechanism-level hypothesis, and author the one composition that tests it. Output exactly one fenced ```ts code block and nothing else."
-        },
-        {
-          role: "user",
-          content: `${opts.contract ?? strategyAuthorContract}
-
-BASELINE RESULTS on the "${opts.environmentName}" environment (budget=${opts.budget}) \u2014 the per-task losses are your gradient:
-${opts.lossesJson}
-
-Author ONE new strategy that you expect to beat the baselines on THIS environment at the same budget.
-${strategyAuthorMethod}
-
-Output only the module code block.`
-        }
-      ]
-    },
-    { ...opts.signal ? { signal: opts.signal } : {} }
-  );
-  const match = res.content.match(/```(?:ts|typescript)?\s*\n([\s\S]*?)```/);
-  if (!match?.[1]) {
-    throw new Error(
-      `authorStrategy: no code block in the author's reply (model=${model ?? "default"}): ${res.content.slice(0, 300)}`
-    );
-  }
-  return match[1];
-}
-async function authorStrategy(opts) {
-  let code;
-  try {
-    code = await requestAuthoredCode(opts, opts.model);
-  } catch (primaryError) {
-    if (!opts.fallbackModel) throw primaryError;
-    code = await requestAuthoredCode(opts, opts.fallbackModel);
-  }
-  assertStrategyContract(code);
-  mkdirSync2(opts.outDir, { recursive: true });
-  const file = join3(opts.outDir, `authored-${Date.now()}.mts`);
-  writeFileSync2(file, code);
-  const mod = await import(`file://${file}`);
-  if (!mod.default || typeof mod.default.driver !== "function" || !mod.default.name) {
-    throw new Error(`authorStrategy: ${file} does not export a default Strategy`);
-  }
-  return { strategy: mod.default, file, code };
-}
-
-// src/runtime/strategy-evolution.ts
-import { existsSync, readFileSync, writeFileSync as writeFileSync3 } from "fs";
-import { gzipSync } from "zlib";
-function discriminatingMeans(report, fieldOrder) {
-  const rows = report.perTask.filter((r) => {
-    if (!r.cells) return false;
-    const scores = fieldOrder.map((n) => r.cells?.[n]?.score).filter((s) => s !== void 0);
-    if (scores.length < fieldOrder.length) return false;
-    return Math.max(...scores) - Math.min(...scores) > 0;
-  });
-  if (rows.length === 0) return null;
-  const out = {};
-  for (const name of fieldOrder) {
-    const cells = rows.map((r) => r.cells?.[name]).filter((c) => !!c);
-    out[name] = {
-      score: cells.reduce((s, c) => s + c.score, 0) / cells.length,
-      usd: cells.reduce((s, c) => s + c.usd, 0) / cells.length
-    };
-  }
-  return out;
-}
-function pickChampion(means, fieldOrder, policy, epsilon) {
-  const entries = fieldOrder.map((name) => ({ name, summary: means[name] })).filter((e) => !!e.summary);
-  if (entries.length === 0)
-    throw new Error("pickChampion: the means table carries none of the field strategies");
-  const best = Math.max(...entries.map((e) => e.summary.score));
-  const pick = policy === "score" ? entries.find((e) => e.summary.score === best) : entries.filter((e) => e.summary.score >= best - epsilon).sort((a, b) => a.summary.usd - b.summary.usd || b.summary.score - a.summary.score)[0];
-  if (!pick) throw new Error("pickChampion: empty pick (unreachable)");
-  return { name: pick.name, score: pick.summary.score, usd: pick.summary.usd };
-}
-function selectChampion(report, fieldOrder, policy, epsilon) {
-  return pickChampion(report.perStrategy, fieldOrder, policy, epsilon);
-}
-var fieldSummary = (archive) => archive.map(
-  (n) => `- ${n.name} (${n.source}, gen ${n.generation}, last score ${(n.score * 100).toFixed(0)}%)`
-).join("\n");
-var compactLosses = (report, detail) => {
-  const r2 = (x) => Math.round(x * 100) / 100;
-  const rows = report.perTask.map(
-    (row) => row.cells ? {
-      task: row.taskId,
-      ...row.errors ? {
-        errors: Object.fromEntries(
-          Object.entries(row.errors).map(([n, msg]) => [n, msg.slice(0, 100)])
-        )
-      } : {},
-      cells: Object.fromEntries(
-        Object.entries(row.cells).map(([name, c]) => [
-          name,
-          // 'binary' is the leakage-bounded channel: the author learns pass/fail per
-          // task and nothing else — the per-generation leak from the evaluation data
-          // is capped at one bit per cell (arXiv:2606.11045 measured that exploration
-          // survives this; whether AUTHORING does is the E1-coarse A/B).
-          detail === "binary" ? { resolved: c.resolved, usd: Math.round(c.usd * 1e4) / 1e4 } : {
-            score: r2(c.score),
-            resolved: c.resolved,
-            usd: Math.round(c.usd * 1e4) / 1e4,
-            progression: (c.progression ?? []).map(r2)
-          }
-        ])
-      )
-    } : { task: row.taskId, error: row.error?.slice(0, 80) }
-  );
-  return JSON.stringify(rows).slice(0, 12e3);
-};
-function renameStrategy(orig, unique) {
-  if (orig.name === unique) return orig;
-  return {
-    name: unique,
-    driver: (s, t, o, b) => {
-      const agent = orig.driver(s, t, o, b);
-      return {
-        ...agent,
-        name: unique,
-        act: async (task, scope) => {
-          const out = await agent.act(task, scope);
-          if (out.kind !== "done") return out;
-          const deliverable = { ...out.deliverable, mode: unique };
-          return { ...out, deliverable };
-        }
-      };
-    }
-  };
-}
-async function runStrategyEvolution(cfg) {
-  const budget = cfg.budget ?? 3;
-  const concurrency = cfg.concurrency ?? 3;
-  const generations = cfg.generations ?? 2;
-  const populationSize = cfg.populationSize ?? 2;
-  const baselines = cfg.baselines ?? [sample, refine, sampleThenRefine];
-  const policy = cfg.champion ?? "costAware";
-  const epsilon = cfg.championEpsilon ?? (cfg.objective === "cost" ? cfg.scoreTolerance ?? 0.05 : 0.01);
-  const byName = new Map(baselines.map((s) => [s.name, s]));
-  const codeByName = /* @__PURE__ */ new Map();
-  const fingerprint = {
-    trainN: cfg.trainN,
-    holdoutN: cfg.holdoutN,
-    budget,
-    generations,
-    populationSize
-  };
-  let ckpt;
-  if (cfg.checkpoint?.resume && existsSync(cfg.checkpoint.path)) {
-    const raw = JSON.parse(readFileSync(cfg.checkpoint.path, "utf8"));
-    if (JSON.stringify(raw.fingerprint) !== JSON.stringify(fingerprint)) {
-      throw new Error(
-        `evolution resume: checkpoint design mismatch \u2014 checkpoint ${JSON.stringify(raw.fingerprint)} vs config ${JSON.stringify(fingerprint)}; delete ${cfg.checkpoint.path} or match the config`
-      );
-    }
-    ckpt = raw;
-  }
-  const save = (state) => {
-    if (cfg.checkpoint)
-      writeFileSync3(cfg.checkpoint.path, JSON.stringify({ ...state, fingerprint }, null, 1));
-  };
-  const bench = async (phase, tasks, strategies) => {
-    await cfg.onPhase?.(phase);
-    return runBenchmark({
-      environment: cfg.environment,
-      tasks,
-      worker: cfg.worker,
-      strategies,
-      budget,
-      concurrency,
-      ...cfg.onTask ? { onTask: (row, done, total) => cfg.onTask?.(phase, row, done, total) } : {},
-      ...cfg.hooks ? { hooks: cfg.hooks } : {}
-    });
-  };
-  const train = await cfg.tasks(0, cfg.trainN);
-  const probeTask = train[0];
-  if (!probeTask) throw new Error("runStrategyEvolution: empty train slice");
-  const probe = await cfg.environment.open(probeTask);
-  let toolCatalog;
-  try {
-    const tools = await cfg.environment.tools(probeTask, probe);
-    toolCatalog = tools.map(
-      (t) => `- ${t.function.name}${t.function.description ? ` \u2014 ${t.function.description.slice(0, 120)}` : ""}`
-    ).join("\n");
-  } finally {
-    await cfg.environment.close(probe);
-  }
-  const gen0 = ckpt?.gen0 ?? await bench("gen0", train, baselines);
-  const archive = ckpt?.archive ? [...ckpt.archive] : baselines.map((s) => ({
-    name: s.name,
-    source: "baseline",
-    generation: 0,
-    score: gen0.perStrategy[s.name]?.score ?? 0,
-    usd: gen0.perStrategy[s.name]?.usd ?? 0
-  }));
-  const gen0Champion = ckpt?.gen0Champion ?? selectChampion(
-    gen0,
-    baselines.map((s) => s.name),
-    policy,
-    epsilon
-  );
-  const generationRows = ckpt?.generations ? [...ckpt.generations] : [];
-  const trajectory = ckpt?.trajectory ? [...ckpt.trajectory] : [
-    {
-      generation: 0,
-      champion: gen0Champion.name,
-      score: gen0Champion.score,
-      usd: gen0Champion.usd
-    }
-  ];
-  for (const row of generationRows) {
-    for (const c of row.candidates) {
-      if (!c.file || c.error) continue;
-      const mod = await import(`file://${c.file}`);
-      if (!mod.default || typeof mod.default.driver !== "function") {
-        throw new Error(
-          `evolution resume: ${c.file} no longer exports a Strategy \u2014 cannot restore "${c.name}"`
-        );
-      }
-      byName.set(c.name, renameStrategy(mod.default, c.name));
-      codeByName.set(c.name, readFileSync(c.file, "utf8"));
-    }
-  }
-  let authoredOk = generationRows.reduce(
-    (n, row) => n + row.candidates.filter((c) => !c.error).length,
-    0
-  );
-  const lastRow = generationRows[generationRows.length - 1];
-  let incumbent = lastRow ? lastRow.champion : gen0Champion;
-  let latestReport = lastRow ? lastRow.report : gen0;
-  if (!ckpt) save({ gen0, gen0Champion, generations: generationRows, archive, trajectory });
-  for (let g = generationRows.length + 1; g <= generations; g += 1) {
-    const lossesJson = compactLosses(latestReport, cfg.lossesDetail ?? "exact");
-    const candidates = [];
-    const newStrategies = [];
-    for (let i = 0; i < populationSize; i += 1) {
-      const objectiveNote = cfg.objective === "cost" ? `
-
-YOUR OBJECTIVE: match or exceed the incumbent's SCORE while spending LESS (the losses include usd per task). Promotion requires proven score non-inferiority PLUS significant cost savings \u2014 a strategy that ties the score at half the cost WINS; a cheaper strategy that loses score by more than ${((cfg.scoreTolerance ?? 0.05) * 100).toFixed(0)}pp LOSES.` : "";
-      const contract = `${strategyAuthorContract}${objectiveNote}
-
-EXAMPLE TOOLS FROM ONE TASK (tool sets VARY per task on this domain \u2014 a strategy MUST select tool names from await listTools(handle) at runtime; hardcoding these example names will zero your score on most tasks):
-${toolCatalog}
-
-STRATEGIES ALREADY IN THE TOURNAMENT (author something MEANINGFULLY different \u2014 a new composition, not a rename):
-${fieldSummary(archive)}
-
-You are authoring candidate ${i + 1} of ${populationSize} this generation; explore a distinct region of the strategy space from your siblings.`;
-      try {
-        const authored = await authorStrategy({
-          chat: cfg.author.chat,
-          ...cfg.author.model ? { model: cfg.author.model } : {},
-          ...cfg.author.fallbackModel ? { fallbackModel: cfg.author.fallbackModel } : {},
-          ...cfg.author.temperature !== void 0 ? { temperature: cfg.author.temperature } : {},
-          ...cfg.author.maxTokens !== void 0 ? { maxTokens: cfg.author.maxTokens } : {},
-          contract,
-          environmentName: cfg.environment.name,
-          lossesJson,
-          budget,
-          outDir: cfg.outDir
-        });
-        const unique = byName.has(authored.strategy.name) ? `${authored.strategy.name}-g${g}c${i + 1}` : authored.strategy.name;
-        const strategy = renameStrategy(authored.strategy, unique);
-        byName.set(unique, strategy);
-        codeByName.set(unique, authored.code);
-        newStrategies.push(strategy);
-        archive.push({
-          name: unique,
-          source: "authored",
-          generation: g,
-          parent: incumbent.name,
-          gzipBits: gzipSync(Buffer.from(authored.code)).length * 8,
-          file: authored.file,
-          score: 0,
-          usd: 0
-        });
-        candidates.push({
-          name: unique,
-          file: authored.file,
-          gzipBits: gzipSync(Buffer.from(authored.code)).length * 8,
-          codeChars: authored.code.length
-        });
-        authoredOk += 1;
-      } catch (e) {
-        candidates.push({
-          name: `(author-failed g${g}c${i + 1})`,
-          error: e instanceof Error ? e.message.slice(0, 300) : String(e)
-        });
-      }
-    }
-    const incumbentStrategy = byName.get(incumbent.name);
-    if (!incumbentStrategy)
-      throw new Error(`evolution: incumbent "${incumbent.name}" missing from the field`);
-    const field = [incumbentStrategy, ...newStrategies];
-    const report = await bench(`gen${g}`, train, field);
-    for (const node of archive) {
-      const cell = report.perStrategy[node.name];
-      if (cell) {
-        node.score = cell.score;
-        node.usd = cell.usd;
-      }
-    }
-    const fieldNames = field.map((s) => s.name);
-    const means = cfg.band ? discriminatingMeans(report, fieldNames) ?? report.perStrategy : report.perStrategy;
-    const champion = pickChampion(means, fieldNames, policy, epsilon);
-    generationRows.push({ generation: g, candidates, report, champion });
-    trajectory.push({
-      generation: g,
-      champion: champion.name,
-      score: champion.score,
-      usd: champion.usd
-    });
-    incumbent = champion;
-    latestReport = report;
-    save({ gen0, gen0Champion, generations: generationRows, archive, trajectory });
-  }
-  if (authoredOk === 0) {
-    throw new Error(
-      "runStrategyEvolution: every author attempt failed across all generations \u2014 no search happened; see the candidates[].error entries"
-    );
-  }
-  const holdoutOffset = cfg.trainN + (cfg.holdoutOffset ?? 0);
-  let holdoutTasks = [];
-  let bandInfo;
-  if (ckpt?.holdout && ckpt.verdict) {
-    bandInfo = ckpt.band;
-    if (cfg.reproducerCheck && codeByName.has(incumbent.name)) {
-      const pool2 = await cfg.tasks(holdoutOffset, cfg.band?.holdoutPoolN ?? cfg.holdoutN);
-      const gateIds = new Set(ckpt.holdout.perTask.map((r) => r.taskId));
-      holdoutTasks = pool2.filter((t) => gateIds.has(t.id));
-    }
-  } else if (cfg.band) {
-    const maxRef = cfg.band.maxRefScore ?? 0.99;
-    const reference = baselines[0];
-    if (!reference)
-      throw new Error("evolution band: baselines[0] required as the screening reference");
-    const pool2 = await cfg.tasks(holdoutOffset, cfg.band.holdoutPoolN);
-    const screen = await bench("band-screen", pool2, [reference]);
-    const refScores = screen.perTask.filter((r) => r.cells?.[reference.name]).map((r) => ({ taskId: r.taskId, score: r.cells?.[reference.name]?.score ?? 0 }));
-    const inBandIds = new Set(refScores.filter((r) => r.score <= maxRef).map((r) => r.taskId));
-    const kept = pool2.filter((t) => inBandIds.has(t.id));
-    if (kept.length < cfg.holdoutN) {
-      throw new Error(
-        `evolution band: only ${kept.length}/${cfg.holdoutN} holdout tasks have headroom (pool ${cfg.band.holdoutPoolN}, reference "${reference.name}" \u2264 ${maxRef}) \u2014 widen holdoutPoolN or raise maxRefScore`
-      );
-    }
-    holdoutTasks = kept.slice(0, cfg.holdoutN);
-    bandInfo = { screened: refScores.length, inBand: kept.length, refScores };
-  } else {
-    holdoutTasks = await cfg.tasks(holdoutOffset, cfg.holdoutN);
-  }
-  let holdout;
-  let verdict;
-  if (ckpt?.holdout && ckpt.verdict) {
-    holdout = ckpt.holdout;
-    verdict = ckpt.verdict;
-  } else {
-    const finalists = [.../* @__PURE__ */ new Set([gen0Champion.name, incumbent.name])].map((n) => byName.get(n)).filter((s) => !!s);
-    holdout = await bench("holdout", holdoutTasks, finalists);
-    verdict = promotionGate({
-      report: holdout,
-      incumbent: gen0Champion.name,
-      candidate: incumbent.name,
-      ...cfg.objective === "cost" ? {
-        mode: "non-inferiority",
-        ...cfg.scoreTolerance !== void 0 ? { scoreTolerance: cfg.scoreTolerance } : {}
-      } : {},
-      ...cfg.minPairedTasks !== void 0 ? { minPairedTasks: cfg.minPairedTasks } : {}
-    });
-    save({
-      gen0,
-      gen0Champion,
-      generations: generationRows,
-      archive,
-      trajectory,
-      holdout,
-      verdict,
-      ...bandInfo ? { band: bandInfo } : {}
-    });
-  }
-  let reproduction;
-  const championCode = codeByName.get(incumbent.name);
-  if (cfg.reproducerCheck && championCode) {
-    const words = cfg.reproducerCheck.summaryMaxWords ?? 64;
-    const tolerance = cfg.reproducerCheck.tolerance ?? 0.05;
-    const championHoldoutScore = holdout.perStrategy[incumbent.name]?.score ?? 0;
-    try {
-      const summaryRes = await cfg.author.chat.chat({
-        ...cfg.author.model ? { model: cfg.author.model } : {},
-        temperature: 0.2,
-        maxTokens: 512,
-        messages: [
-          {
-            role: "system",
-            content: `Summarize the optimization strategy implemented by this code in at most ${words} words. Describe the COMPOSITION (shots, critique, artifact handling, restarts, stopping) \u2014 not the code. Output only the summary.`
-          },
-          { role: "user", content: championCode }
-        ]
-      });
-      const summary = summaryRes.content.trim();
-      const reproduced = await authorStrategy({
-        chat: cfg.author.chat,
-        ...cfg.author.model ? { model: cfg.author.model } : {},
-        ...cfg.author.fallbackModel ? { fallbackModel: cfg.author.fallbackModel } : {},
-        ...cfg.author.maxTokens !== void 0 ? { maxTokens: cfg.author.maxTokens } : {},
-        temperature: 0.2,
-        contract: `${strategyAuthorContract}
-
-IMPLEMENT EXACTLY THIS STRATEGY (a colleague's description \u2014 do not invent a different approach):
-${summary}`,
-        environmentName: cfg.environment.name,
-        lossesJson: "[]",
-        budget,
-        outDir: cfg.outDir
-      });
-      const reproStrategy = {
-        name: `${incumbent.name}-reproduced`,
-        driver: reproduced.strategy.driver
-      };
-      const reproReport = await bench("reproduce", holdoutTasks, [reproStrategy]);
-      const reproducedHoldoutScore = reproReport.perStrategy[reproStrategy.name]?.score ?? 0;
-      reproduction = {
-        summary,
-        reproducedName: reproStrategy.name,
-        file: reproduced.file,
-        championHoldoutScore,
-        reproducedHoldoutScore,
-        gap: championHoldoutScore - reproducedHoldoutScore,
-        reproducible: reproducedHoldoutScore >= championHoldoutScore - tolerance
-      };
-    } catch (e) {
-      reproduction = {
-        summary: "",
-        reproducedName: "",
-        championHoldoutScore,
-        reproducedHoldoutScore: 0,
-        gap: championHoldoutScore,
-        reproducible: false,
-        error: e instanceof Error ? e.message.slice(0, 300) : String(e)
-      };
-    }
-  }
-  return {
-    gen0,
-    gen0Champion,
-    generations: generationRows,
-    archive,
-    finalChampion: incumbent,
-    holdout,
-    verdict,
-    ...bandInfo ? { band: bandInfo } : {},
-    ...reproduction ? { reproduction } : {},
-    trajectory
-  };
-}
-
-// src/runtime/stream-agent-turn.ts
-import { scoreKnowledgeReadiness } from "@tangle-network/agent-eval";
-async function* streamAgentTurn(backend, prompt, opts = {}) {
-  const label = backend.kind === "chat" ? backend.backend.kind : backend.kind;
-  const task = { id: `turn-${crypto.randomUUID()}`, intent: prompt };
-  const acc = { deltaText: "", input: 0, output: 0, costUsd: 0 };
-  const deadline = deriveTurnSignal(opts.signal, opts.timeoutMs ?? 0);
-  let session;
-  try {
-    session = await startTurnSession(backend, task, prompt, deadline.signal, label);
-    yield { type: "backend_start", task, session, backend: label, timestamp: nowIso() };
-    const inner = backend.kind === "chat" ? driveChatTurn(backend.backend, task, session, prompt, deadline.signal, acc) : driveBoxTurn(
-      backend.kind === "executor" ? await inlineSandboxClient(backend.factory).create() : backend.box,
-      prompt,
-      deadline.signal,
-      backend.agentRunName ?? "agent",
-      acc,
-      {
-        mode: backend.kind === "box-task" ? "task" : "prompt",
-        ...backend.kind !== "executor" && backend.options ? { options: backend.options } : {},
-        preserveToolParts: opts.preserveToolParts === true,
-        ...opts.onRawEvent ? { onRawEvent: opts.onRawEvent } : {}
-      }
-    );
-    for await (const event of inner) {
-      yield event;
-      throwIfAborted(deadline.signal);
-    }
-    yield buildFinalEvent(task, session, acc, { status: "completed", reason: "turn completed" });
-  } catch (err) {
-    const callerAborted = opts.signal?.aborted === true;
-    const status = callerAborted ? "aborted" : "failed";
-    const message = err instanceof Error ? err.message : String(err);
-    const error = err instanceof BackendTransportError ? { kind: "transport", message, status: err.status, body: err.body } : { kind: "backend", message };
-    yield {
-      type: "backend_error",
-      task,
-      ...session ? { session } : {},
-      backend: label,
-      message,
-      recoverable: !callerAborted,
-      error,
-      timestamp: nowIso()
-    };
-    yield buildFinalEvent(task, session, acc, { status, reason: message, error });
-  } finally {
-    deadline.dispose();
-  }
-}
-async function collectAgentTurn(stream) {
-  const events = [];
-  for await (const event of stream) events.push(event);
-  const final = events.at(-1);
-  if (!final || final.type !== "final") {
-    throw new Error(
-      `collectAgentTurn: stream ended without a terminal 'final' event (last: ${final ? final.type : "none"})`
-    );
-  }
-  const metadata = final.metadata ?? {};
-  const tokenUsage = metadata.tokenUsage && typeof metadata.tokenUsage === "object" ? metadata.tokenUsage : {};
-  const usage = {
-    input: finiteNumber(tokenUsage.input) ?? 0,
-    output: finiteNumber(tokenUsage.output) ?? 0
-  };
-  const costUsd = finiteNumber(metadata.costUsd);
-  if (costUsd !== void 0) usage.costUsd = costUsd;
-  if (typeof metadata.model === "string" && metadata.model.length > 0) {
-    usage.model = metadata.model;
-  }
-  return {
-    finalText: final.text ?? "",
-    usage,
-    events,
-    status: final.status,
-    ...final.error ? { error: final.error } : {}
-  };
-}
-async function startTurnSession(backend, task, prompt, signal, label) {
-  if (backend.kind === "chat" && backend.backend.start) {
-    return backend.backend.start(
-      { task, message: prompt },
-      { task, knowledge: emptyReadiness(task), signal }
-    );
-  }
-  return newRuntimeSession(label);
-}
-async function* driveBoxTurn(box, prompt, signal, agentRunName, acc, cfg) {
-  const callOptions = { ...cfg.options ?? {}, signal };
-  const stream = cfg.mode === "task" ? box.streamTask(prompt, callOptions) : box.streamPrompt(prompt, callOptions);
-  const toolParts = cfg.preserveToolParts ? createSandboxToolPartState() : void 0;
-  for await (const event of stream) {
-    if (cfg.onRawEvent) await cfg.onRawEvent(event);
-    const terminalText = terminalTextFromSandboxEvent(event);
-    if (terminalText !== void 0) acc.terminalText = terminalText;
-    if (toolParts) {
-      for (const toolEvent of mapSandboxToolEvent(event, toolParts)) yield toolEvent;
-    }
-    const mapped = mapSandboxEvent(event, { agentRunName });
-    if (!mapped) continue;
-    foldEvent(mapped, acc, agentRunName);
-    yield mapped;
-  }
-}
-async function* driveChatTurn(backend, task, session, prompt, signal, acc) {
-  const input = { task, message: prompt };
-  const context = { task, knowledge: emptyReadiness(task), session, signal };
-  for await (const raw of backend.stream(input, context)) {
-    const event = normalizeBackendStreamEvent(raw, task, session);
-    foldEvent(event, acc);
-    yield event;
-  }
-}
-function foldEvent(event, acc, fallbackModelLabel) {
-  if (event.type === "text_delta") {
-    acc.deltaText += event.text;
-    return;
-  }
-  if (event.type === "llm_call") {
-    acc.input += event.tokensIn ?? 0;
-    acc.output += event.tokensOut ?? 0;
-    acc.costUsd += event.costUsd ?? 0;
-    if (event.model && event.model !== fallbackModelLabel) acc.model = event.model;
-  }
-}
-function terminalTextFromSandboxEvent(event) {
-  if (!event || typeof event !== "object") return void 0;
-  const type = String(event.type ?? "");
-  if (type !== "result" && type !== "done" && type !== "final") return void 0;
-  const data = event.data && typeof event.data === "object" ? event.data : {};
-  for (const key of ["finalText", "text", "response", "content"]) {
-    const value = data[key];
-    if (typeof value === "string") return value;
-  }
-  return void 0;
-}
-function buildFinalEvent(task, session, acc, outcome) {
-  const finalText = acc.terminalText ?? acc.deltaText;
-  return {
-    type: "final",
-    task,
-    ...session ? { session } : {},
-    status: outcome.status,
-    reason: outcome.reason,
-    ...finalText ? { text: finalText } : {},
-    metadata: {
-      tokenUsage: { input: acc.input, output: acc.output },
-      ...acc.costUsd > 0 ? { costUsd: acc.costUsd } : {},
-      ...acc.model ? { model: acc.model } : {}
-    },
-    ...outcome.error ? { error: outcome.error } : {},
-    timestamp: nowIso()
-  };
-}
-function emptyReadiness(task) {
-  return scoreKnowledgeReadiness({ taskId: task.id, requirements: [] });
-}
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function throwIfAborted(signal) {
-  if (!signal.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason));
-}
-function deriveTurnSignal(callerSignal, timeoutMs) {
-  const controller = new AbortController();
-  const timer = timeoutMs > 0 ? setTimeout(
-    () => controller.abort(new Error(`agent turn timed out after ${timeoutMs}ms`)),
-    timeoutMs
-  ) : void 0;
-  if (timer && typeof timer.unref === "function") {
-    ;
-    timer.unref();
-  }
-  const onCallerAbort = () => controller.abort(callerSignal?.reason ?? new Error("agent turn aborted"));
-  if (callerSignal) {
-    if (callerSignal.aborted) onCallerAbort();
-    else callerSignal.addEventListener("abort", onCallerAbort, { once: true });
-  }
-  return {
-    signal: controller.signal,
-    dispose: () => {
-      if (timer) clearTimeout(timer);
-      callerSignal?.removeEventListener("abort", onCallerAbort);
-    }
-  };
-}
-
-// src/runtime/supervise/patch-checks.ts
-var DEFAULT_MAX_DIFF_LINES = 400;
-var secretPathPattern = /(^|\/)(\.env(\.|$)|.*\.(pem|key|p12|pfx|keystore|wallet)|id_rsa|id_ed25519|secrets?\.json|credentials?\.json)$/i;
-function touchedPathsFromPatch(patch) {
-  const out = /* @__PURE__ */ new Set();
-  for (const line of patch.split(/\r?\n/)) {
-    if (line.startsWith("+++ ") || line.startsWith("--- ")) {
-      const rest = line.slice(4).trim();
-      if (rest === "/dev/null") continue;
-      const stripped = rest.startsWith("a/") || rest.startsWith("b/") ? rest.slice(2) : rest;
-      out.add(stripped);
-    }
-  }
-  return [...out];
-}
-function countDiffLines(patch) {
-  let count = 0;
-  for (const line of patch.split(/\r?\n/)) {
-    if ((line.startsWith("+") || line.startsWith("-")) && !line.startsWith("+++") && !line.startsWith("---")) {
-      count += 1;
-    }
-  }
-  return count;
-}
-function runCoderChecks(input, constraints = {}) {
-  const maxDiff = constraints.maxDiffLines ?? DEFAULT_MAX_DIFF_LINES;
-  const forbidden = constraints.forbiddenPaths ?? [];
-  const scores = {};
-  const notes = [];
-  let pass = true;
-  const touched = touchedPathsFromPatch(input.patch);
-  if (touched.length === 0 || input.patch.trim().length === 0) {
-    pass = false;
-    scores.nonEmpty = 0;
-    notes.push("empty patch \u2014 no files changed");
-  } else {
-    scores.nonEmpty = 1;
-  }
-  const touchedSecrets = touched.filter((p) => secretPathPattern.test(p));
-  if (touchedSecrets.length > 0) {
-    pass = false;
-    scores.noSecrets = 0;
-    notes.push(`touched secret-shaped paths: ${touchedSecrets.join(", ")}`);
-  } else {
-    scores.noSecrets = 1;
-  }
-  const touchedForbidden = forbidden.filter((path) => {
-    const prefix = path.endsWith("/") ? path : `${path}/`;
-    const exact = prefix.slice(0, -1);
-    return touched.some((p) => p === exact || p.startsWith(prefix));
-  });
-  if (touchedForbidden.length > 0) {
-    pass = false;
-    scores.forbiddenPath = 0;
-    notes.push(`touched forbidden paths: ${touchedForbidden.join(", ")}`);
-  } else {
-    scores.forbiddenPath = 1;
-  }
-  const diffLines = countDiffLines(input.patch);
-  if (diffLines > maxDiff) {
-    pass = false;
-    scores.diffSize = 0;
-    notes.push(`diff ${diffLines} lines exceeds cap ${maxDiff}`);
-  } else {
-    scores.diffSize = maxDiff === 0 ? 0 : Math.max(0, 1 - diffLines / maxDiff);
-  }
-  scores.tests = input.testsPassed ? 1 : 0;
-  scores.typecheck = input.typecheckPassed ? 1 : 0;
-  if (!input.testsPassed) {
-    pass = false;
-    notes.push("tests failed");
-  }
-  if (!input.typecheckPassed) {
-    pass = false;
-    notes.push("typecheck failed");
-  }
-  const score = 0.5 * scores.tests + 0.3 * scores.typecheck + 0.2 * scores.diffSize;
-  const verdict = {
-    valid: pass,
-    score: Number.isFinite(score) ? score : 0,
-    scores
-  };
-  if (notes.length > 0) verdict.notes = notes.join("; ");
-  return verdict;
-}
-
-// src/runtime/supervise/patch-deliverable.ts
-function patchDelivered(options = {}) {
-  const require2 = new Set(options.require ?? []);
-  const constraints = {
-    ...options.maxDiffLines !== void 0 ? { maxDiffLines: options.maxDiffLines } : {},
-    ...options.forbiddenPaths !== void 0 ? { forbiddenPaths: options.forbiddenPaths } : {}
-  };
-  return {
-    describe: "patch: no-op/secret/forbidden/diff-size + required test/typecheck pass",
-    check(artifact) {
-      const input = {
-        patch: artifact.patch,
-        testsPassed: signalPass(artifact.checks?.tests?.passed, require2.has("tests")),
-        typecheckPassed: signalPass(artifact.checks?.typecheck?.passed, require2.has("typecheck"))
-      };
-      return runCoderChecks(input, constraints).valid === true;
-    }
-  };
-}
-function signalPass(value, required) {
-  if (value !== void 0) return value;
-  return !required;
-}
-
-// src/runtime/supervise/trajectory-recorder.ts
-import { buildTrajectory, InMemoryTraceStore } from "@tangle-network/agent-eval";
-import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelines";
-async function analyzeTrace(source, runId = "worker") {
-  const spans = await source.collect();
-  const store = new InMemoryTraceStore();
-  const laneSpanId = `${runId}-session-lane`;
-  if (spans.length > 0) {
-    const startedAt = Math.min(...spans.map((span) => span.startedAt));
-    const endedAt = Math.max(...spans.map((span) => span.endedAt ?? span.startedAt));
-    const agentSpanId = `${runId}-agent`;
-    await store.appendSpan({
-      spanId: agentSpanId,
-      runId,
-      kind: "agent",
-      name: "trace-source-agent",
-      startedAt,
-      endedAt
-    });
-    await store.appendSpan({
-      spanId: laneSpanId,
-      parentSpanId: agentSpanId,
-      runId,
-      kind: "custom",
-      name: "trace-source-session",
-      startedAt,
-      endedAt
-    });
-  }
-  for (let i = 0; i < spans.length; i += 1) {
-    const s = spans[i];
-    if (s) {
-      await store.appendSpan({
-        ...s,
-        runId,
-        spanId: `${runId}-t${i}`,
-        parentSpanId: laneSpanId
-      });
-    }
-  }
-  const [trajectory, stuckLoop, toolWaste] = await Promise.all([
-    buildTrajectory(store, runId),
-    stuckLoopView(store, { runId, maxInterveningToolCalls: 1 }),
-    toolWasteView(store, { runId })
-  ]);
-  return { trajectory, stuckLoop, toolWaste };
-}
-
-// src/runtime/supervise/worktree-fanout.ts
-function worktreeFanout(options) {
-  const deliverable = options.deliverable ?? patchDelivered({
-    ...options.maxDiffLines !== void 0 ? { maxDiffLines: options.maxDiffLines } : {},
-    ...options.forbiddenPaths !== void 0 ? { forbiddenPaths: options.forbiddenPaths } : {},
-    ...options.require !== void 0 ? { require: options.require } : {}
-  });
-  const itemSpec = (item) => {
-    const executor = gateOnDeliverable(
-      createWorktreeCliExecutor({
-        repoRoot: options.repoRoot,
-        profile: item.profile,
-        harness: item.harness,
-        taskPrompt: options.taskPrompt,
-        ...item.runId ? { runId: item.runId } : {},
-        ...item.baseRef ? { baseRef: item.baseRef } : {},
-        ...options.testCmd !== void 0 ? { testCmd: options.testCmd } : {},
-        ...options.typecheckCmd !== void 0 ? { typecheckCmd: options.typecheckCmd } : {},
-        ...options.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: options.harnessTimeoutMs } : {},
-        ...options.runGit ? { runGit: options.runGit } : {},
-        ...options.runHarness ? { runHarness: options.runHarness } : {},
-        ...options.runCommand ? { runCommand: options.runCommand } : {}
-      }),
-      deliverable
-    );
-    return { profile: item.profile, harness: null, executor };
-  };
-  const selectWinner = selectValidWinner({
-    strategy: options.winnerStrategy ?? "highest-score",
-    sizeOf: (a) => a.stats.insertions + a.stats.deletions
-  });
-  return fanout(options.harnesses, {
-    itemTask: () => options.taskPrompt,
-    label: (item, i) => `${item.name}:${i}`,
-    itemSpec: (item) => itemSpec(item),
-    selectWinner
-  });
-}
-
-// src/runtime/supervise-surface.ts
-function captureFailures(base) {
-  let lastReport = "";
-  const surface = {
-    name: base.name,
-    open: (t) => base.open(t),
-    tools: (t, h) => base.tools(t, h),
-    async call(h, name, args) {
-      const out = await base.call(h, name, args);
-      if (name === "run_tests") lastReport = out;
-      return out;
-    },
-    score: (t, h) => base.score(t, h),
-    close: (h) => base.close(h)
-  };
-  const failing = () => {
-    const body = /FAILING:\s*(.+)/i.exec(lastReport)?.[1];
-    return body ? body.split(",").map((s) => s.trim()).filter(Boolean) : [];
-  };
-  return { surface, failing };
-}
-function failuresAnalyst() {
-  return {
-    kinds: [
-      {
-        id: "failures",
-        description: "Surface the worker's still-failing tests so the driver targets them next.",
-        area: "progress"
-      }
-    ],
-    run: async (_kindId, trace) => {
-      const w = trace ?? {};
-      if (!(typeof w === "object" && w !== null && "resolved" in w))
-        return { summary: `worker produced: ${JSON.stringify(trace).slice(0, 300)}` };
-      if (w.resolved) return { summary: "worker RESOLVED \u2014 every check passed; stop." };
-      const failing = w.failing ?? [];
-      const head = `worker did NOT resolve \u2014 score ${(100 * (w.score ?? 0)).toFixed(0)}%, ${w.shots ?? "?"} shot(s)`;
-      return {
-        summary: failing.length ? `${head}. STILL FAILING (${failing.length}): ${failing.slice(0, 12).join(", ")}. Spawn the next worker to fix exactly these; if a test keeps failing across workers, give it concrete guidance about that case.` : `${head}. (no failing-test list available this round)`
-      };
-    }
-  };
-}
-function surfaceWorkerExecutor(surface, task, worker, strategy) {
-  let artifact;
-  return {
-    runtime: "surface-worker",
-    async execute(brief) {
-      const guidance = typeof brief === "string" ? brief.trim() : brief ? JSON.stringify(brief) : "";
-      const attemptTask = guidance ? {
-        ...task,
-        systemPrompt: `${task.systemPrompt ?? ""}
-
-\u2014 Supervisor guidance for THIS attempt (incorporate it; do not just repeat a prior approach) \u2014
-${guidance}`
-      } : task;
-      const cap = captureFailures(surface);
-      const r = await runAgentic({
-        surface: cap.surface,
-        task: attemptTask,
-        strategy,
-        budget: worker.budget ?? 1,
-        routerBaseUrl: worker.routerBaseUrl,
-        routerKey: worker.routerKey,
-        model: worker.model,
-        ...worker.maxTokens !== void 0 ? { maxTokens: worker.maxTokens } : {},
-        ...worker.innerTurns !== void 0 ? { innerTurns: worker.innerTurns } : {}
-      });
-      const out = {
-        resolved: r.resolved,
-        score: r.score,
-        shots: r.shots,
-        summary: `${strategy.name} ${r.shots} shot(s) \u2192 ${(100 * r.score).toFixed(0)}% (${r.resolved ? "resolved" : "unresolved"})`,
-        failing: r.resolved ? [] : cap.failing()
-      };
-      const spent = { iterations: r.completions, tokens: r.tokens, usd: r.usd, ms: r.ms };
-      artifact = {
-        outRef: `surface-worker:${task.id}:${r.shots}:${r.resolved ? "ok" : "no"}`,
-        out,
-        verdict: { valid: r.resolved, score: r.score },
-        spent
-      };
-      return artifact;
-    },
-    teardown: () => Promise.resolve({ destroyed: true }),
-    resultArtifact() {
-      if (!artifact) throw new Error("surfaceWorkerExecutor: resultArtifact before execute");
-      return artifact;
-    }
-  };
-}
-async function superviseSurface(profile, task, opts) {
-  const strategy = opts.strategy ?? refine;
-  const innerTurns = opts.worker.innerTurns ?? 6;
-  const router = opts.router ?? {
-    routerBaseUrl: opts.worker.routerBaseUrl,
-    routerKey: opts.worker.routerKey,
-    model: opts.worker.model
-  };
-  const budget = opts.budget ?? {
-    maxIterations: (innerTurns + 2) * 5 + 16,
-    maxTokens: (opts.worker.maxTokens ?? 4e3) * 8
-  };
-  const makeWorkerAgent = (rawProfile) => {
-    const p = rawProfile ?? {};
-    const name = typeof p.name === "string" && p.name.length > 0 ? p.name : "surface-worker";
-    const spec = {
-      profile: rawProfile,
-      harness: null,
-      executor: surfaceWorkerExecutor(
-        opts.surface,
-        task,
-        opts.worker,
-        strategy
-      )
-    };
-    return { name, act: async () => "", executorSpec: spec };
-  };
-  const deliverable = {
-    describe: `resolve the surface task ${task.id} (every required check passes)`,
-    check: (out2) => out2?.resolved === true
-  };
-  const analysts = opts.analysts === null ? void 0 : opts.analysts ?? failuresAnalyst();
-  const result = await supervise(profile, task, {
-    makeWorkerAgent,
-    deliverable,
-    budget,
-    maxLiveWorkers: opts.maxLiveWorkers ?? 1,
-    // A SMALL per-worker reservation so MULTIPLE workers fit the pool (the default reserves the whole pool
-    // per worker → only one ever spawns, defeating the spawn-a-targeted-worker steering).
-    perWorker: { maxIterations: innerTurns + 2, maxTokens: opts.worker.maxTokens ?? 4e3 },
-    router,
-    ...analysts ? { analysts, analyzeOnSettle: analysts.kinds.map((k) => k.id) } : {}
-  });
-  const out = result.kind === "winner" ? result.out : void 0;
-  const sp = result.spentTotal;
-  return {
-    resolved: out?.resolved ?? false,
-    score: out?.score ?? 0,
-    usd: sp.usd,
-    tokensIn: sp.tokens.input,
-    tokensOut: sp.tokens.output,
-    ms: sp.ms,
-    completions: sp.iterations
-  };
-}
-
-// src/runtime/verifier-environment.ts
-var submitTool = {
-  type: "function",
-  function: {
-    name: "submit_answer",
-    description: "Submit your answer for evaluation. You may submit more than once \u2014 the best-scoring submission counts. Submit the COMPLETE final answer, not a fragment.",
-    parameters: {
-      type: "object",
-      properties: { answer: { type: "string", description: "The complete final answer." } },
-      required: ["answer"]
-    }
-  }
-};
-function createVerifierEnvironment(opts) {
-  if (opts.extraTools?.length && !opts.callExtra) {
-    throw new Error(`${opts.name}: extraTools requires callExtra`);
-  }
-  const states = /* @__PURE__ */ new Map();
-  let seq = 0;
-  return {
-    name: opts.name,
-    async open(task) {
-      seq += 1;
-      const handle = { id: `${opts.name}-${seq}`, surface: opts.name };
-      states.set(handle.id, { task, submissions: [] });
-      return handle;
-    },
-    async tools() {
-      return [submitTool, ...opts.extraTools ?? []];
-    },
-    async call(handle, name, args) {
-      const state = states.get(handle.id);
-      if (!state) return "ERROR: workspace closed";
-      if (name === "submit_answer") {
-        const answer = String(args.answer ?? "").trim();
-        if (!answer) return "ERROR: empty answer";
-        state.submissions.push(answer);
-        return `submission ${state.submissions.length} recorded`;
-      }
-      if (opts.callExtra && opts.extraTools?.some((t) => t.function.name === name)) {
-        try {
-          return await opts.callExtra(state.task, name, args);
-        } catch (e) {
-          return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
-        }
-      }
-      return `ERROR: unknown tool ${name}`;
-    },
-    // Keep-best across submissions — the measured law (workers reach correct answers,
-    // then revise past them; final-state scoring undersells every strategy).
-    async score(task, handle) {
-      const state = states.get(handle.id);
-      if (!state || state.submissions.length === 0) return { passes: 0, total: 1, errored: 0 };
-      let best = { passes: 0, total: 1, errored: 0 };
-      const ratio = (s) => s.total > 0 ? s.passes / s.total : 0;
-      for (const answer of state.submissions) {
-        const s = await opts.check(task, answer);
-        if (ratio(s) > ratio(best)) best = s;
-      }
-      return best;
-    },
-    async close(handle) {
-      states.delete(handle.id);
-    }
-  };
-}
-
-// src/runtime/waterfall.ts
-function createWaterfallCollector() {
-  let spans = /* @__PURE__ */ new Map();
-  const onEvent = (event) => {
-    if (event.target === "agent.spawn") {
-      const p = event.payload ?? {};
-      const id = p.childId ?? event.id;
-      spans.set(id, {
-        id,
-        label: p.label ?? id,
-        runId: event.runId,
-        ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
-        startMs: event.timestamp,
-        status: "running",
-        usd: 0,
-        tokens: { input: 0, output: 0 }
-      });
-      return;
-    }
-    if (event.target === "agent.child") {
-      const p = event.payload ?? {};
-      const id = p.childId;
-      if (!id) return;
-      const span = spans.get(id);
-      if (!span) return;
-      span.endMs = event.timestamp;
-      span.status = p.status === "down" ? "down" : "done";
-      span.usd = p.spent?.usd ?? 0;
-      span.tokens = {
-        input: p.spent?.tokens?.input ?? 0,
-        output: p.spent?.tokens?.output ?? 0
-      };
-      if (typeof p.score === "number") span.score = p.score;
-    }
-  };
-  const report = () => {
-    const all = [...spans.values()].sort((a, b) => a.startMs - b.startMs);
-    const start = all[0]?.startMs ?? 0;
-    const end = Math.max(start, ...all.map((s) => s.endMs ?? s.startMs));
-    const byKind = {};
-    let totalUsd = 0;
-    const totalTokens = { input: 0, output: 0 };
-    for (const s of all) {
-      totalUsd += s.usd;
-      totalTokens.input += s.tokens.input;
-      totalTokens.output += s.tokens.output;
-      const kind = s.label.includes(":") ? s.label.split(":")[0] : s.label;
-      let k = byKind[kind];
-      if (!k) {
-        k = { count: 0, ms: 0, usd: 0, tokens: { input: 0, output: 0 } };
-        byKind[kind] = k;
-      }
-      k.count += 1;
-      k.ms += (s.endMs ?? s.startMs) - s.startMs;
-      k.usd += s.usd;
-      k.tokens.input += s.tokens.input;
-      k.tokens.output += s.tokens.output;
-    }
-    return { spans: all, totalMs: end - start, totalUsd, totalTokens, byKind };
-  };
-  const render = (opts) => {
-    const { spans: all, totalMs, totalUsd, byKind } = report();
-    if (all.length === 0) return "(no spans observed)";
-    const width = opts?.width ?? 48;
-    const maxRows = opts?.maxRows ?? 60;
-    const start = all[0]?.startMs ?? 0;
-    const scale = totalMs > 0 ? width / totalMs : 0;
-    const lines = [];
-    const labelWidth = Math.min(24, Math.max(...all.map((s) => s.label.length)) + 1);
-    for (const s of all.slice(0, maxRows)) {
-      const offset = Math.round((s.startMs - start) * scale);
-      const dur = (s.endMs ?? s.startMs) - s.startMs;
-      const len = Math.max(1, Math.round(dur * scale));
-      const bar = `${" ".repeat(Math.min(offset, width))}${(s.status === "down" ? "\u2591" : "\u2588").repeat(Math.max(1, Math.min(len, width - Math.min(offset, width) + 1)))}`;
-      const mark = s.status === "down" ? " DOWN" : s.score !== void 0 ? ` ${(s.score * 100).toFixed(0)}%` : "";
-      lines.push(
-        `${s.label.padEnd(labelWidth)}|${bar.padEnd(width + 1)}| ${(dur / 1e3).toFixed(1)}s $${s.usd.toFixed(4)} ${s.tokens.input}/${s.tokens.output}tok${mark}`
-      );
-    }
-    if (all.length > maxRows) lines.push(`\u2026 ${all.length - maxRows} more spans`);
-    lines.push("\u2014".repeat(labelWidth + width + 2));
-    for (const [kind, k] of Object.entries(byKind)) {
-      lines.push(
-        `${kind.padEnd(labelWidth)} \xD7${k.count}  ${(k.ms / 1e3).toFixed(1)}s busy  $${k.usd.toFixed(4)}  ${k.tokens.input}/${k.tokens.output}tok`
-      );
-    }
-    lines.push(
-      `TOTAL${" ".repeat(labelWidth - 5)} ${(totalMs / 1e3).toFixed(1)}s wall  $${totalUsd.toFixed(4)}`
-    );
-    return lines.join("\n");
-  };
-  return {
-    hooks: { onEvent },
-    report,
-    render,
-    reset: () => {
-      spans = /* @__PURE__ */ new Map();
-    }
-  };
-}
-
-// src/runtime/workspace.ts
-function localShell() {
-  return async (args, cwd) => {
-    const { execFile } = await import("child_process");
-    const [bin, ...rest] = args;
-    return new Promise((resolve) => {
-      execFile(
-        bin ?? "",
-        rest,
-        { cwd, encoding: "utf-8", maxBuffer: 64 * 1024 * 1024 },
-        (err, stdout, stderr) => {
-          resolve({
-            stdout: stdout ?? "",
-            stderr: stderr ?? "",
-            code: err ? err.code ?? 1 : 0
-          });
-        }
-      );
-    });
-  };
-}
-function gitWorkspace(opts) {
-  const shell = opts.shell ?? localShell();
-  const branch = opts.branch ?? "main";
-  const cfg = opts.noHooks === false ? [] : ["-c", "core.hooksPath=/dev/null"];
-  const ident = ["-c", "user.email=workspace@tangle.local", "-c", "user.name=workspace"];
-  const run = async (args, cwd) => {
-    const res = await shell(["git", ...cfg, ...ident, ...args], cwd);
-    if (res.code !== 0) {
-      throw new Error(
-        `git ${args.join(" ")} failed (${res.code}): ${tail(res.stderr || res.stdout)}`
-      );
-    }
-    return res.stdout;
-  };
-  return {
-    ref: opts.ref,
-    materialize: (dir) => run(["clone", "--branch", branch, opts.ref, dir]).then(() => {
-    }),
-    async commit(dir, message) {
-      await run(["add", "-A"], dir);
-      const status = await run(["status", "--porcelain"], dir);
-      if (!status.trim()) return { ok: true, rev: (await run(["rev-parse", "HEAD"], dir)).trim() };
-      await run(["commit", "-m", message], dir);
-      const pull = await shell(["git", ...cfg, ...ident, "pull", "--rebase", "origin", branch], dir);
-      if (pull.code !== 0) {
-        await shell(["git", ...cfg, "rebase", "--abort"], dir).catch(() => {
-        });
-        return { ok: false, conflict: tail(pull.stderr || pull.stdout) };
-      }
-      const push = await shell(["git", ...cfg, ...ident, "push", "origin", branch], dir);
-      if (push.code !== 0) return { ok: false, conflict: tail(push.stderr || push.stdout) };
-      return { ok: true, rev: (await run(["rev-parse", "HEAD"], dir)).trim() };
-    },
-    async head() {
-      const out = await run(["ls-remote", opts.ref, `refs/heads/${branch}`]);
-      return out.split(/\s+/)[0] ?? "";
-    }
-  };
-}
-function jjWorkspace(opts) {
-  const shell = opts.shell ?? localShell();
-  const branch = opts.branch ?? "main";
-  const ident = [
-    "--config-toml",
-    'user.name="workspace"',
-    "--config-toml",
-    'user.email="workspace@tangle.local"'
-  ];
-  const jj = async (args, cwd) => {
-    const res = await shell(["jj", ...ident, ...args], cwd);
-    if (res.code !== 0) {
-      throw new Error(
-        `jj ${args.join(" ")} failed (${res.code}): ${tail(res.stderr || res.stdout)}`
-      );
-    }
-    return res.stdout;
-  };
-  return {
-    ref: opts.ref,
-    // Colocated clone: jj manages history, git holds the durable remote.
-    materialize: (dir) => jj(["git", "clone", "--colocate", opts.ref, dir]).then(() => {
-    }),
-    async commit(dir, message) {
-      await jj(["describe", "-m", message], dir);
-      await jj(["new"], dir);
-      const push = await shell(["jj", ...ident, "git", "push", "--branch", branch], dir);
-      if (push.code !== 0) return { ok: false, conflict: tail(push.stderr || push.stdout) };
-      const rev = (await jj(["log", "--no-graph", "-r", "@-", "-T", "commit_id"], dir)).trim();
-      return { ok: true, rev };
-    },
-    async head() {
-      const out = await shell(["git", "ls-remote", opts.ref, `refs/heads/${branch}`]);
-      return out.stdout.split(/\s+/)[0] ?? "";
-    }
-  };
-}
-async function runInWorkspace(ws, body, opts = {}) {
-  const { mkdtempSync: mkdtempSync2, rmSync: rmSync2 } = await import("fs");
-  const { tmpdir: tmpdir3 } = await import("os");
-  const { join: join4 } = await import("path");
-  const dir = mkdtempSync2(join4(tmpdir3(), opts.tmpPrefix ?? "ws-run-"));
-  try {
-    await ws.materialize(dir);
-    const r = await body(dir);
-    if (r.valid || opts.commitOnInvalid) {
-      const message = r.message ?? (r.valid ? "worker: delivered" : "worker: wip");
-      const commit = await ws.commit(dir, message);
-      return { valid: r.valid, value: r.value, commit };
-    }
-    return { valid: r.valid, value: r.value };
-  } finally {
-    rmSync2(dir, { recursive: true, force: true });
-  }
-}
-function tail(s) {
-  return s.slice(-400);
-}
-
-export {
-  envKeyProvider,
-  mcpSecretEnvMetadataKey,
-  secretEnvOfMcpServer,
-  resolveSecretEnv,
-  sanitizeMcpToolSchema,
-  createMcpEnvironment,
-  McpSpawnFault,
-  connectStdioMcp,
-  materializeLocalMcp,
-  defaultAuditorInstruction,
-  auditIntent,
-  leaderboard,
-  pairwiseSignificance,
-  renderLeaderboardMarkdown,
-  renderPairwiseMarkdown,
-  renderLeaderboardSvg,
-  renderLeaderboardHtml,
-  completionAuthorizes,
-  stopSentinel,
-  sentinelCompletion,
-  deterministicCompletion,
-  loopCampaignDispatch,
-  loopDispatch,
-  inlineSandboxClient,
-  localSandboxClient,
-  resolveSandboxClient,
-  naiveDriver,
-  dumbDriver,
-  defineLeaderboard,
-  harvestCorpus,
-  inProcessSandboxClient,
-  assertTraceDerivedFindings,
-  createScopeAnalyst,
-  registryScopeAnalyst,
-  buildSteerContext,
-  selectValidWinner,
-  pipeline,
-  fanout,
-  loopUntil,
-  panel,
-  verify,
-  widen,
-  flatWidenGate,
-  InMemoryCorpus,
-  FileCorpus,
-  renderCorpusToInstructions,
-  createShapeRegistry,
-  builtinShapes,
-  registerShape,
-  definePersona,
-  runPersonified,
-  trajectoryReport,
-  equalKOnCost,
-  promotionGate,
-  reportLoopUsage,
-  runBenchmark,
-  printBenchmarkReport,
-  SandboxRunAbortError,
-  openSandboxRun,
-  strategyAuthorContract,
-  assertStrategyContract,
-  authorStrategy,
-  discriminatingMeans,
-  pickChampion,
-  selectChampion,
-  runStrategyEvolution,
-  streamAgentTurn,
-  collectAgentTurn,
-  runCoderChecks,
-  patchDelivered,
-  analyzeTrace,
-  worktreeFanout,
-  failuresAnalyst,
-  superviseSurface,
-  createVerifierEnvironment,
-  createWaterfallCollector,
-  localShell,
-  gitWorkspace,
-  jjWorkspace,
-  runInWorkspace,
-  computeFindingId,
-  makeFinding
-};
-//# sourceMappingURL=chunk-WRTOVNN4.js.map