@tangle-network/agent-runtime 0.71.1 → 0.73.0

package/dist/chunk-HPYWEFVY.js

@@ -0,0 +1,4039 @@
+import {
+  InMemoryResultBlobStore,
+  InMemorySpawnJournal,
+  addTokenUsage,
+  createExecutorRegistry,
+  createSandboxLineage,
+  createSupervisor,
+  createWorktreeCliExecutor,
+  defaultSelectWinner,
+  gateOnDeliverable,
+  isAbortError,
+  notifyRuntimeHookEvent,
+  probeSandboxCapabilities,
+  randomSuffix,
+  routerToolLoop,
+  runLoop,
+  settledToIteration,
+  sleep,
+  stringifySafe,
+  withDriverExecutor,
+  zeroTokenUsage
+} from "./chunk-NCH4XUZ7.js";
+import {
+  AnalystError,
+  PlannerError,
+  ValidationError
+} from "./chunk-NBV35BR6.js";
+
+// src/runtime/index.ts
+import { computeFindingId, makeFinding as makeFinding2 } from "@tangle-network/agent-eval";
+
+// src/runtime/anytime.ts
+var median = (xs) => {
+  if (xs.length === 0) return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const mid = Math.floor(s.length / 2);
+  return s.length % 2 === 1 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+};
+function anytimeReport(spans, opts) {
+  const targets = opts?.targets ?? [1];
+  const byRun = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    if (!s.label.startsWith("shot:")) continue;
+    const list = byRun.get(s.runId) ?? [];
+    list.push(s);
+    byRun.set(s.runId, list);
+  }
+  const perTask = [];
+  for (const [runId, shots] of byRun) {
+    const m = runId.match(/^agentic:(.+):(.+)$/);
+    const strategy = m?.[1] ?? runId;
+    const taskId = m?.[2] ?? runId;
+    const ordered = [...shots].sort((a, b) => (a.endMs ?? a.startMs) - (b.endMs ?? b.startMs));
+    const t0 = Math.min(...ordered.map((s) => s.startMs));
+    const taskTargets = opts?.targetFor ? [opts.targetFor(taskId)] : targets;
+    let best = 0;
+    let cumUsd = 0;
+    const points = [];
+    const hits = {};
+    for (const t of taskTargets) hits[String(t)] = null;
+    for (const s of ordered) {
+      cumUsd += s.usd;
+      if (typeof s.score === "number" && s.score > best) best = s.score;
+      const elapsedMs = (s.endMs ?? s.startMs) - t0;
+      points.push({ elapsedMs, cumUsd, best });
+      for (const t of taskTargets) {
+        if (hits[String(t)] === null && best >= t) {
+          hits[String(t)] = { ms: elapsedMs, shots: points.length, usd: cumUsd };
+        }
+      }
+    }
+    perTask.push({ taskId, strategy, points, hits });
+  }
+  const byStrategy = /* @__PURE__ */ new Map();
+  for (const t of perTask) {
+    const list = byStrategy.get(t.strategy) ?? [];
+    list.push(t);
+    byStrategy.set(t.strategy, list);
+  }
+  const perStrategy = [];
+  for (const [strategy, tasks] of byStrategy) {
+    const totalMs = tasks.reduce((s, t) => s + (t.points[t.points.length - 1]?.elapsedMs ?? 0), 0);
+    const totalUsd = tasks.reduce((s, t) => s + (t.points[t.points.length - 1]?.cumUsd ?? 0), 0);
+    const maxShots = Math.max(0, ...tasks.map((t) => t.points.length));
+    const curveByShot = [];
+    for (let i = 0; i < maxShots; i += 1) {
+      const vals = tasks.map(
+        (t) => t.points[Math.min(i, t.points.length - 1)].best
+      );
+      curveByShot.push(vals.reduce((s, v) => s + v, 0) / vals.length);
+    }
+    const auc = curveByShot.length > 0 ? curveByShot.reduce((s, v) => s + v, 0) / curveByShot.length : 0;
+    const summaryTargets = opts?.targetFor ? [Number.NaN] : targets;
+    for (const t of summaryTargets) {
+      const key = (taskCurve) => opts?.targetFor ? Object.values(taskCurve.hits)[0] ?? null : taskCurve.hits[String(t)] ?? null;
+      const reached = tasks.filter((x) => key(x) !== null);
+      perStrategy.push({
+        strategy,
+        target: t,
+        tasks: tasks.length,
+        reachedTarget: reached.length,
+        medianTttMs: median(reached.map((x) => key(x).ms)),
+        medianShotsToTarget: median(reached.map((x) => key(x).shots)),
+        ertMs: reached.length > 0 ? totalMs / reached.length : null,
+        erUsd: reached.length > 0 ? totalUsd / reached.length : null,
+        curveByShot,
+        auc
+      });
+    }
+  }
+  perStrategy.sort((a, b) => a.strategy.localeCompare(b.strategy) || a.target - b.target);
+  return { targets, perTask, perStrategy };
+}
+function renderAnytimeTable(report) {
+  const lines = [
+    `anytime metrics \xB7 satisficing targets [${report.targets.join(", ")}] \xB7 ERT = \u03A3 all wall-time / #successes (COCO)`,
+    "strategy            \u2265tgt   reach   med-TTT   med-shots   ERT(all-in)   $/success   AUC   curve"
+  ];
+  for (const s of report.perStrategy) {
+    const curve = s.curveByShot.map((v) => "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588"[Math.min(7, Math.floor(v * 8))]).join("");
+    const tgt = Number.isNaN(s.target) ? "task" : s.target.toFixed(2);
+    lines.push(
+      `${s.strategy.padEnd(19)} ${tgt.padStart(4)} ${String(s.reachedTarget).padStart(4)}/${String(s.tasks).padEnd(3)} ${s.medianTttMs === null ? "      \u2014" : `${(s.medianTttMs / 1e3).toFixed(1).padStart(6)}s`}   ${s.medianShotsToTarget === null ? "    \u2014" : String(s.medianShotsToTarget).padStart(5)}   ${s.ertMs === null ? "         \u2014" : `${(s.ertMs / 1e3).toFixed(1).padStart(9)}s`}   ${s.erUsd === null ? "       \u2014" : `$${s.erUsd.toFixed(4)}`}   ${s.auc.toFixed(2)}   ${curve}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// 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/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/observe.ts
+import { makeFinding } from "@tangle-network/agent-eval";
+var observerId = "observe/trace";
+var defaultAnalystInstruction = "You are a third-person OBSERVER watching an AI agent work. You see its TRACE (what it did), not its grader. From the trace, name SPECIFIC, behavior-grounded findings: wasted/duplicated tool calls, thrash/retries, token/cost waste, missing verification, failure patterns. For each, a concrete recommended_action, and whether the AGENT (fix its skills/prompt/tools) or the OPERATOR (fix framing/decomposition/config) should act. Only claim what the trace shows. No findings if the run was clean.";
+function summarizeTrace(trace, maxLines) {
+  const lines = [];
+  for (const ev of trace) {
+    const e = ev;
+    const t = (e.type ?? "").toLowerCase();
+    const d = e.data ?? {};
+    const part = d.part ?? {};
+    if (part.type === "tool")
+      lines.push(`tool:${part.tool}${part.state?.status ? `(${part.state.status})` : ""}`);
+    else if (t.includes("error"))
+      lines.push(`ERROR: ${String(d.message ?? d.detail ?? "").slice(0, 200)}`);
+    else if (t === "status" && typeof d.status === "string") lines.push(`status:${d.status}`);
+    else if (t.includes("tool")) lines.push(`tool-event:${t}`);
+  }
+  const out = [];
+  for (const ln of lines) {
+    const prev = out[out.length - 1];
+    const m = prev?.match(/^(.*?)(?: x(\d+))?$/);
+    if (m && m[1] === ln) out[out.length - 1] = `${ln} x${(Number(m[2]) || 1) + 1}`;
+    else out.push(ln);
+  }
+  return out.slice(0, maxLines).join("\n") || "(no tool/error events in trace)";
+}
+var findingsSchema = {
+  name: "observer_findings",
+  schema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      findings: {
+        type: "array",
+        items: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            area: {
+              type: "string",
+              description: "tool-use | cost | verification | process | failure | latency"
+            },
+            severity: { type: "string", enum: ["critical", "high", "medium", "low", "info"] },
+            claim: {
+              type: "string",
+              description: "what you OBSERVED in the trace (a fact, with the evidence)"
+            },
+            recommended_action: {
+              type: "string",
+              description: "the concrete change for the agent or operator"
+            },
+            audience: {
+              type: "string",
+              enum: ["agent", "operator"],
+              description: "who should act on this"
+            },
+            confidence: { type: "number" }
+          },
+          required: ["area", "severity", "claim", "recommended_action", "audience", "confidence"]
+        }
+      }
+    },
+    required: ["findings"]
+  }
+};
+async function observe(input, opts) {
+  const traceSummary = summarizeTrace(input.trace, opts.maxTraceLines ?? 80);
+  const res = await opts.chat.chat(
+    {
+      ...opts.model ? { model: opts.model } : {},
+      jsonSchema: findingsSchema,
+      messages: [
+        {
+          role: "system",
+          content: opts.analystInstruction ?? defaultAnalystInstruction
+        },
+        {
+          role: "user",
+          content: `TASK: ${input.task}
+
+OUTCOME: ${input.outcome ?? "unknown"}
+
+FINAL OUTPUT (truncated):
+${input.output.slice(0, 1200)}
+
+TRACE (in order; "xN" = repeated):
+${traceSummary}`
+        }
+      ]
+    },
+    { ...opts.signal ? { signal: opts.signal } : {} }
+  );
+  const parsed = parseFindings(res.content);
+  const producedAt = input.runId ? `${input.runId}` : observerId;
+  const findings = parsed.map(
+    (f) => makeFinding({
+      analyst_id: observerId,
+      area: `${f.area}`,
+      severity: f.severity,
+      claim: f.claim,
+      recommended_action: f.recommended_action,
+      confidence: typeof f.confidence === "number" ? f.confidence : 0.5,
+      evidence_refs: [],
+      // The observer reads BEHAVIOR, never the judge verdict — firewall provenance.
+      derived_from_judge: false,
+      metadata: { audience: f.audience },
+      ...input.runId ? { subject: input.runId } : {}
+    })
+  );
+  const learned = [];
+  if (opts.corpus) {
+    for (const f of findings) {
+      const record = {
+        schemaVersion: "1.0.0",
+        id: f.finding_id,
+        runId: input.runId ?? observerId,
+        producedAt: f.produced_at ?? producedAt,
+        area: f.area,
+        claim: f.recommended_action ?? f.claim,
+        ...f.claim ? { rationale: f.claim } : {},
+        tags: [...opts.tags ?? [], `audience:${f.metadata?.audience ?? "agent"}`],
+        confidence: f.confidence,
+        evidence: [{ kind: "finding", uri: f.finding_id }]
+      };
+      const r = await opts.corpus.append(record);
+      if (r.succeeded) learned.push(record);
+    }
+  }
+  return { findings, learned, report: renderReport(findings) };
+}
+function parseFindings(content) {
+  let obj2;
+  try {
+    obj2 = JSON.parse(content);
+  } catch {
+    const m = content.match(/\{[\s\S]*\}/);
+    obj2 = m ? JSON.parse(m[0]) : { findings: [] };
+  }
+  const arr = obj2.findings;
+  return Array.isArray(arr) ? arr : [];
+}
+function renderReport(findings) {
+  if (findings.length === 0) return "\u2713 clean run \u2014 the observer found nothing to change.";
+  const audience = (f) => f.metadata?.audience ?? "agent";
+  const forAgent = findings.filter((f) => audience(f) === "agent");
+  const forOperator = findings.filter((f) => audience(f) === "operator");
+  const block = (title, fs) => fs.length === 0 ? "" : `**${title}**
+${fs.map((f) => `- [${f.severity}] ${f.claim}
+  \u2192 ${f.recommended_action ?? ""}`).join("\n")}
+`;
+  return [
+    block("For the agent (fix skills / prompt / tools)", forAgent),
+    block("For you (the operator)", forOperator)
+  ].filter(Boolean).join("\n");
+}
+
+// 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/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++}`;
+      return {
+        id,
+        async *streamPrompt(message) {
+          const controller = new AbortController();
+          const spec = { profile: { name: id }, harness: null };
+          const exec = factory(spec, { signal: controller.signal, seams: {} });
+          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 {
+            await exec.teardown("brutalKill").catch(() => {
+            });
+          }
+        },
+        async delete() {
+        }
+      };
+    }
+  };
+}
+
+// src/runtime/report-usage.ts
+function reportLoopUsage(cost, result, source = "loop") {
+  cost.observe(result.costUsd, source);
+  cost.observeTokens(result.tokenUsage);
+}
+
+// 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);
+  const result = await runLoop({
+    ...loopOptions,
+    ctx: {
+      sandboxClient: opts.sandboxClient,
+      signal: ctx.signal,
+      traceEmitter: opts.forwardTrace === false ? void 0 : campaignTraceToLoopEmitter(ctx.trace)
+    }
+  });
+  reportLoopUsage(ctx.cost, result, opts.costSource ?? "loop");
+  const toArtifact = opts.toArtifact ?? ((r) => r.winner?.output);
+  return toArtifact(result);
+}
+function loopDispatch(opts) {
+  return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
+}
+
+// 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 sanitizeSchema(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: sanitizeSchema(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/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 = [];
+      let opened = 0;
+      for (const [i, item] of items.entries()) {
+        const label = opts.label ? opts.label(item, i) : `item:${i}`;
+        const spec = opts.itemSpec ? opts.itemSpec(item, i, ctx) : ctx.persona.root;
+        const child = ctx.spawnChild(label, spec);
+        const res = scope.spawn(child, opts.itemTask(item, i, ctx), {
+          budget: ctx.budget.perChild,
+          label
+        });
+        if (res.ok) opened += 1;
+        else rejected.push(`${label}: not admitted (${res.reason})`);
+      }
+      if (opened === 0) {
+        return blocked(
+          rejected.length > 0 ? rejected : ["fanout: budget admitted no item (fanout fully rejected)"]
+        );
+      }
+      const drained = await drain(scope);
+      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" };
+    }
+  };
+}
+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 perChild2 = 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: perChild2, 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(isSpawned).sort(bySeq);
+  const closes = events.filter((ev) => ev.kind !== "spawned" && 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,
+      runtime: ev.runtime,
+      status: "pending",
+      ownSpend: zeroSpend(),
+      children: []
+    });
+  }
+  for (const ev of closes) {
+    const node = requireNode(nodes, ev.id, root);
+    if (ev.kind === "cancelled") {
+      node.status = "cancelled";
+      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
+  };
+  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,
+    ms: a.ms + b.ms
+  };
+}
+function cloneSpend(spend) {
+  return {
+    iterations: spend.iterations,
+    tokens: { input: spend.tokens.input, output: spend.tokens.output },
+    usd: spend.usd,
+    ms: spend.ms
+  };
+}
+function addSpend(acc, delta) {
+  acc.iterations += delta.iterations;
+  addTokenUsage(acc.tokens, delta.tokens);
+  acc.usd += delta.usd;
+  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 median2 = medianOf(values);
+  if (median2 === 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 / median2;
+}
+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 isSpawned(ev) {
+  return ev.kind === "spawned";
+}
+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/run-benchmark.ts
+import { pairedBootstrap, paretoFrontier } from "@tangle-network/agent-eval";
+
+// src/runtime/strategy.ts
+import { createChatClient, estimateCost, isModelPriced } from "@tangle-network/agent-eval";
+var taskNudge = "Use the available tools to bring the artifact to the required final state. Address EVERY distinct change the request implies. After each tool result, check what remains and continue. Re-read the values you set to confirm they took. Reply DONE only once every required change is made and verified.";
+async function runShot(surface, _task, handle, tools, messages, opts, modelOverride) {
+  let toolErrors = 0;
+  const execute = async (name, args) => {
+    try {
+      const out = await surface.call(handle, name, args);
+      if (out.startsWith("ERROR:")) toolErrors += 1;
+      return out;
+    } catch (e) {
+      toolErrors += 1;
+      return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  };
+  const r = await routerToolLoop(
+    {
+      routerBaseUrl: opts.routerBaseUrl,
+      routerKey: opts.routerKey,
+      model: modelOverride ?? opts.model
+    },
+    "",
+    "",
+    tools,
+    execute,
+    {
+      maxTurns: opts.innerTurns ?? 4,
+      temperature: opts.temperature ?? 0.7,
+      initialMessages: messages,
+      ...opts.maxTokens ? { maxTokens: opts.maxTokens } : {}
+    }
+  );
+  return {
+    messages: r.messages,
+    completions: r.turns,
+    toolCalls: r.toolCalls,
+    toolErrors,
+    tokens: r.usage
+  };
+}
+function compactTrajectory(messages) {
+  return messages.filter((m) => m.role === "assistant" || m.role === "tool").map((m) => {
+    if (m.role === "tool") return `RESULT ${String(m.content).slice(0, 280)}`;
+    const calls = m.tool_calls?.map((c) => `${c.function.name}(${c.function.arguments})`).join(", ");
+    return calls ? `CALL ${calls}` : `SAY ${String(m.content).slice(0, 200)}`;
+  }).join("\n").slice(0, 7e3);
+}
+async function consultAnalyst(task, messages, instruction, opts) {
+  const trajectory = compactTrajectory(messages);
+  const analystModel = opts.analystModel ?? opts.model;
+  const chat = createChatClient({
+    transport: "router",
+    apiKey: opts.routerKey,
+    baseUrl: opts.routerBaseUrl,
+    defaultModel: analystModel
+  });
+  const res = await chat.chat({
+    model: analystModel,
+    temperature: 0.2,
+    maxTokens: 1024,
+    messages: [
+      { role: "system", content: instruction },
+      {
+        role: "user",
+        content: `TASK: ${task.userPrompt.slice(0, 1500)}
+
+TRAJECTORY:
+${trajectory}`
+      }
+    ]
+  });
+  const usage = res.usage;
+  return {
+    steer: res.content.trim(),
+    tokens: {
+      input: usage?.promptTokens ?? usage?.prompt_tokens ?? 0,
+      output: usage?.completionTokens ?? usage?.completion_tokens ?? 0
+    }
+  };
+}
+async function analyze(task, messages, opts) {
+  const trajectory = compactTrajectory(messages);
+  const analystModel = opts.analystModel ?? opts.model;
+  const inner = createChatClient({
+    transport: "router",
+    apiKey: opts.routerKey,
+    baseUrl: opts.routerBaseUrl,
+    defaultModel: analystModel
+  });
+  const tokens = { input: 0, output: 0 };
+  const chat = {
+    ...inner,
+    chat: async (req, callOpts) => {
+      const res = await inner.chat(req, callOpts);
+      const u = res.usage;
+      if (u) {
+        tokens.input += u.promptTokens ?? u.prompt_tokens ?? 0;
+        tokens.output += u.completionTokens ?? u.completion_tokens ?? 0;
+      }
+      return res;
+    }
+  };
+  const obs = await observe(
+    {
+      task: task.userPrompt,
+      output: trajectory,
+      trace: messages,
+      outcome: "failed",
+      runId: task.id
+    },
+    {
+      chat,
+      model: analystModel,
+      ...opts.analystInstruction ? { analystInstruction: opts.analystInstruction } : {},
+      ...opts.corpus ? { corpus: opts.corpus, tags: opts.corpusTags ?? [] } : {}
+    }
+  );
+  const steer = obs.findings.map((f) => f.recommended_action).filter((a) => typeof a === "string" && a.trim().length > 0).join("\n").trim();
+  return { steer: steer || "COMPLETE", tokens };
+}
+function shotExecutor(surface, opts) {
+  let artifact;
+  return {
+    runtime: "agentic-shot",
+    async execute(task) {
+      const t = task;
+      const own = !t.handle;
+      const handle = t.handle ?? await surface.open(t.task);
+      try {
+        const allTools = await surface.tools(t.task, handle);
+        let tools = allTools;
+        if (t.tools) {
+          const known = new Set(allTools.map((tool) => tool.function.name));
+          const unknown = t.tools.filter((name) => !known.has(name));
+          if (unknown.length > 0) {
+            throw new Error(
+              `shot tools: unknown tool name(s) ${unknown.join(", ")} \u2014 domain offers: ${[...known].join(", ")}`
+            );
+          }
+          const want = new Set(t.tools);
+          tools = allTools.filter((tool) => want.has(tool.function.name));
+        }
+        const messages = t.messages?.length ? t.messages : [
+          { role: "system", content: t.persona?.systemPrompt ?? t.task.systemPrompt },
+          { role: "user", content: `${t.task.userPrompt}
+
+${taskNudge}` }
+        ];
+        if (t.messages?.length && t.persona?.systemPrompt) {
+          messages.push({
+            role: "user",
+            content: `[hand-off] You are now acting as: ${t.persona.systemPrompt}`
+          });
+        }
+        if (t.steer) messages.push({ role: "user", content: t.steer });
+        const shot = await runShot(surface, t.task, handle, tools, messages, opts, t.persona?.model);
+        const s = await surface.score(t.task, handle);
+        const score = s.total > 0 ? s.passes / s.total : 0;
+        const out = {
+          messages: shot.messages,
+          score,
+          passes: s.passes,
+          total: s.total,
+          completions: shot.completions,
+          toolErrors: shot.toolErrors
+        };
+        artifact = {
+          outRef: `shot:${handle.id}:${shot.completions}:${s.passes}/${s.total}`,
+          out,
+          verdict: { valid: s.total > 0 && s.passes === s.total, score },
+          // Real usage to the conserved pool: tokens from the router responses; usd only
+          // when the model is in the price table (never a fabricated number).
+          spent: {
+            iterations: shot.completions,
+            tokens: shot.tokens,
+            usd: isModelPriced(opts.model) ? estimateCost(shot.tokens.input, shot.tokens.output, opts.model) : 0,
+            ms: 0
+          }
+        };
+        return artifact;
+      } finally {
+        if (own) await surface.close(handle);
+      }
+    },
+    teardown: () => Promise.resolve({ destroyed: true }),
+    resultArtifact() {
+      if (!artifact) throw new Error("shotExecutor: resultArtifact before execute");
+      return artifact;
+    }
+  };
+}
+function analystExecutor(opts) {
+  let artifact;
+  return {
+    runtime: "agentic-analyst",
+    async execute(task) {
+      const t = task;
+      const { steer, tokens } = t.rawInstruction ? await consultAnalyst(t.task, t.messages, t.rawInstruction, opts) : await analyze(t.task, t.messages, opts);
+      const analystModel = opts.analystModel ?? opts.model;
+      artifact = {
+        outRef: `analyst:${steer.length}`,
+        out: steer,
+        spent: {
+          iterations: 1,
+          tokens,
+          usd: isModelPriced(analystModel) ? estimateCost(tokens.input, tokens.output, analystModel) : 0,
+          ms: 0
+        }
+      };
+      return artifact;
+    },
+    teardown: () => Promise.resolve({ destroyed: true }),
+    resultArtifact() {
+      if (!artifact) throw new Error("analystExecutor: resultArtifact before execute");
+      return artifact;
+    }
+  };
+}
+function agenticRegistry(surface, opts) {
+  const leaves = {
+    register() {
+      throw new Error("agenticRegistry: register unsupported");
+    },
+    resolve(spec) {
+      const role = spec.profile.metadata?.role;
+      const factory = (_s, _ctx) => role === "analyst" ? analystExecutor(opts) : shotExecutor(surface, opts);
+      return { succeeded: true, value: factory };
+    }
+  };
+  return withDriverExecutor(leaves);
+}
+function leaf(name, role) {
+  const agent = {
+    name,
+    executorSpec: { profile: { name, metadata: { role } }, harness: null },
+    act() {
+      throw new Error(`agentic: spawned child "${name}" was run directly (the executor drives it)`);
+    }
+  };
+  return agent;
+}
+async function drainOne2(scope) {
+  const s = await scope.next();
+  if (!s) throw new Error("agentic: spawned child never settled");
+  return s;
+}
+var perChild = (innerTurns) => ({
+  maxIterations: innerTurns + 1,
+  maxTokens: 1e6
+});
+function depthStrategy(surface, task, opts, cfg) {
+  const innerTurns = opts.innerTurns ?? 4;
+  let pendingSteer;
+  return {
+    name: "depth",
+    async act(_t, scope) {
+      const handle = await surface.open(task);
+      const progression = [];
+      let messages;
+      let completions = 0;
+      let shots = 0;
+      try {
+        for (shots = 0; shots < cfg.maxShots; shots += 1) {
+          const child = leaf(`shot:${shots}`, "shot");
+          const steer = shots === 0 ? void 0 : pendingSteer;
+          const res = scope.spawn(child, { task, handle, messages, steer }, {
+            budget: perChild(innerTurns),
+            label: `shot:${shots}`
+          });
+          if (!res.ok) break;
+          const settled = await drainOne2(scope);
+          if (settled.kind === "down") break;
+          const out = settled.out;
+          messages = out.messages;
+          completions += out.completions;
+          progression.push(out.score);
+          if (out.score >= 1 || shots === cfg.maxShots - 1) break;
+          const aChild = leaf(`analyst:${shots}`, "analyst");
+          const aRes = scope.spawn(
+            aChild,
+            { task, messages },
+            { budget: perChild(1), label: `analyst:${shots}` }
+          );
+          if (!aRes.ok) break;
+          const aSettled = await drainOne2(scope);
+          completions += 1;
+          if (aSettled.kind === "down") break;
+          const findings = aSettled.out;
+          if (/^\s*COMPLETE\b/i.test(findings)) break;
+          pendingSteer = `A reviewer flagged unfinished items:
+${findings}
+
+Address each with the tools, verify they took, then continue.`;
+        }
+        const final = await surface.score(task, handle);
+        const score = final.total > 0 ? final.passes / final.total : 0;
+        return {
+          kind: "done",
+          deliverable: {
+            mode: "depth",
+            score,
+            resolved: final.total > 0 && final.passes === final.total,
+            completions,
+            progression,
+            shots: shots + 1
+          }
+        };
+      } finally {
+        await surface.close(handle);
+      }
+    }
+  };
+}
+function breadthStrategy(_surface, task, opts, cfg) {
+  const innerTurns = opts.innerTurns ?? 4;
+  return {
+    name: "breadth",
+    async act(_t, scope) {
+      let opened = 0;
+      for (let k = 0; k < cfg.width; k += 1) {
+        const res = scope.spawn(leaf(`rollout:${k}`, "shot"), { task }, {
+          budget: perChild(innerTurns),
+          label: `rollout:${k}`
+        });
+        if (res.ok) opened += 1;
+      }
+      if (opened === 0) return { kind: "blocked", blockers: ["breadth: pool admitted no rollout"] };
+      let best = -1;
+      let bestResolved = false;
+      let completions = 0;
+      const progression = [];
+      for (let s = await scope.next(); s !== null; s = await scope.next()) {
+        if (s.kind === "down") continue;
+        const out = s.out;
+        completions += out.completions;
+        if (out.score > best) best = out.score;
+        if (out.total > 0 && out.passes === out.total) bestResolved = true;
+        progression.push(best);
+      }
+      if (best < 0) return { kind: "blocked", blockers: ["breadth: every rollout went down"] };
+      return {
+        kind: "done",
+        deliverable: {
+          mode: "breadth",
+          score: best,
+          resolved: bestResolved,
+          completions,
+          progression,
+          shots: opened
+        }
+      };
+    }
+  };
+}
+var sample = {
+  name: "sample",
+  driver: (surface, task, opts, budget) => breadthStrategy(surface, task, opts, { width: budget })
+};
+var refine = {
+  name: "refine",
+  driver: (surface, task, opts, budget) => depthStrategy(surface, task, opts, { maxShots: budget })
+};
+function defineStrategy(name, run) {
+  return {
+    name,
+    driver: (surface, task, opts, budget) => ({
+      name,
+      async act(_t, scope) {
+        let seq = 0;
+        const innerTurns = opts.innerTurns ?? 4;
+        let verifiedBest = 0;
+        let verifiedResolved = false;
+        const openHandles = /* @__PURE__ */ new Set();
+        const ctx = {
+          // Narrowed to open/close — the body gets no raw call()/score() access.
+          surface: {
+            name: surface.name,
+            open: async (t) => {
+              const h = await surface.open(t);
+              openHandles.add(h.id);
+              return h;
+            },
+            close: async (h) => {
+              if (!h || !openHandles.has(h.id)) return;
+              openHandles.delete(h.id);
+              await surface.close(h);
+            }
+          },
+          task,
+          opts,
+          budget,
+          scope,
+          async shot(spec) {
+            const child = leaf(`shot:${seq}`, "shot");
+            seq += 1;
+            const res = scope.spawn(
+              child,
+              {
+                task,
+                handle: spec?.handle,
+                messages: spec?.messages,
+                steer: spec?.steer,
+                persona: spec?.persona,
+                tools: spec?.tools
+              },
+              { budget: perChild(innerTurns), label: child.name }
+            );
+            if (!res.ok) return null;
+            const settled = await drainOne2(scope);
+            if (settled.kind === "down") return null;
+            const out = settled.out;
+            if (out.score > verifiedBest) verifiedBest = out.score;
+            if (out.total > 0 && out.passes === out.total) verifiedResolved = true;
+            return out;
+          },
+          async listTools(handle) {
+            const tools = await surface.tools(task, handle);
+            return tools.map((t) => ({
+              name: t.function.name,
+              ...t.function.description ? { description: t.function.description } : {}
+            }));
+          },
+          async critique(messages) {
+            const child = leaf(`analyst:${seq}`, "analyst");
+            seq += 1;
+            const res = scope.spawn(
+              child,
+              { task, messages },
+              { budget: perChild(1), label: child.name }
+            );
+            if (!res.ok) return null;
+            const settled = await drainOne2(scope);
+            if (settled.kind === "down") return null;
+            const findings = settled.out;
+            return /^\s*COMPLETE\b/i.test(findings) ? null : findings;
+          },
+          async consult(messages, instruction) {
+            const child = leaf(`analyst:${seq}`, "analyst");
+            seq += 1;
+            const res = scope.spawn(
+              child,
+              { task, messages, rawInstruction: instruction },
+              { budget: perChild(1), label: child.name }
+            );
+            if (!res.ok) return null;
+            const settled = await drainOne2(scope);
+            if (settled.kind === "down") return null;
+            return settled.out;
+          }
+        };
+        const r = await run(ctx);
+        return {
+          kind: "done",
+          deliverable: {
+            mode: name,
+            ...r,
+            progression: Array.isArray(r.progression) ? r.progression : [],
+            completions: typeof r.completions === "number" ? r.completions : 0,
+            shots: typeof r.shots === "number" ? r.shots : 0,
+            score: verifiedBest,
+            resolved: verifiedResolved
+          }
+        };
+      }
+    })
+  };
+}
+var adaptiveRefine = defineStrategy(
+  "adaptiveRefine",
+  async ({ surface, task, budget, shot, critique }) => {
+    let handle = await surface.open(task);
+    const progression = [];
+    let messages;
+    let steer;
+    let completions = 0;
+    let best = -1;
+    let shots = 0;
+    try {
+      for (shots = 0; shots < budget; shots += 1) {
+        const out = await shot({ handle, messages, steer });
+        if (!out) break;
+        completions += out.completions;
+        progression.push(out.score);
+        if (out.score >= 1) break;
+        if (out.score <= best) {
+          await surface.close(handle);
+          handle = await surface.open(task);
+          messages = void 0;
+          steer = void 0;
+          continue;
+        }
+        best = out.score;
+        messages = out.messages;
+        const findings = await critique(out.messages);
+        completions += 1;
+        if (!findings) break;
+        steer = `A reviewer flagged unfinished items:
+${findings}
+
+Address each with the tools, verify they took, then continue.`;
+      }
+      const score = progression.length ? Math.max(...progression) : 0;
+      return { score, resolved: score >= 1, completions, progression, shots };
+    } finally {
+      await surface.close(handle);
+    }
+  }
+);
+var sampleThenRefine = defineStrategy(
+  "sampleThenRefine",
+  async ({ surface, task, budget, shot, critique }) => {
+    const explore = Math.max(1, Math.ceil(budget / 2));
+    const open = /* @__PURE__ */ new Set();
+    const progression = [];
+    let completions = 0;
+    let shots = 0;
+    try {
+      let best;
+      for (let i = 0; i < explore; i += 1) {
+        const handle = await surface.open(task);
+        open.add(handle);
+        const out = await shot({ handle });
+        if (!out) continue;
+        shots += 1;
+        completions += out.completions;
+        progression.push(out.score);
+        if (!best || out.score > best.out.score) best = { handle, out };
+        if (out.score >= 1) break;
+      }
+      if (!best) return { score: 0, resolved: false, completions, progression, shots };
+      for (const h of [...open]) {
+        if (h !== best.handle) {
+          await surface.close(h);
+          open.delete(h);
+        }
+      }
+      let messages = best.out.messages;
+      let topScore = best.out.score;
+      for (let i = explore; i < budget && topScore < 1; i += 1) {
+        const findings = await critique(messages);
+        completions += 1;
+        if (!findings) break;
+        const out = await shot({
+          handle: best.handle,
+          messages,
+          steer: `A reviewer flagged unfinished items:
+${findings}
+
+Address each with the tools, verify they took, then continue.`
+        });
+        if (!out) break;
+        shots += 1;
+        completions += out.completions;
+        progression.push(out.score);
+        messages = out.messages;
+        if (out.score > topScore) topScore = out.score;
+      }
+      const score = progression.length ? Math.max(...progression) : 0;
+      return { score, resolved: score >= 1, completions, progression, shots };
+    } finally {
+      for (const h of open) await surface.close(h);
+    }
+  }
+);
+async function runAgentic(opts) {
+  const strategy = opts.strategy ?? (opts.mode === "breadth" ? sample : refine);
+  const driver = strategy.driver(opts.surface, opts.task, opts, opts.budget);
+  const supervisor = createSupervisor();
+  const root = opts.rootBudget ?? {
+    maxIterations: opts.budget * ((opts.innerTurns ?? 4) + 2),
+    maxTokens: 1e9
+  };
+  const started = Date.now();
+  const result = await supervisor.run(driver, void 0, {
+    budget: root,
+    runId: `agentic:${strategy.name}:${opts.task.id}`,
+    journal: new InMemorySpawnJournal(),
+    blobs: new InMemoryResultBlobStore(),
+    executors: agenticRegistry(opts.surface, opts),
+    maxDepth: 3,
+    ...opts.hooks ? { hooks: opts.hooks } : {}
+  });
+  if (result.kind !== "winner" || result.out.kind !== "done") {
+    const reason = result.kind === "winner" ? `blocked: ${result.out.blockers?.join("; ")}` : `no-winner: ${result.reason}`;
+    throw new Error(`runAgentic(${strategy.name}) produced no result \u2014 ${reason}`);
+  }
+  const core = result.out.deliverable;
+  return {
+    ...core,
+    usd: result.spentTotal.usd,
+    tokens: result.spentTotal.tokens,
+    ms: Date.now() - started
+  };
+}
+
+// src/runtime/run-benchmark.ts
+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 mean = (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: mean(cells.map((c) => c.score)),
+      resolved: mean(cells.map((c) => c.resolved ? 1 : 0)),
+      usd: mean(cells.map((c) => c.usd)),
+      ms: mean(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 = pairedBootstrap(
+      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 pct = (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)} ${pct(v.score).padStart(7)} ${pct(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
+        );
+        handle = r.handle;
+        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)
+        );
+        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, writeFileSync } from "fs";
+import { join } 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 engineer authoring optimization strategies for agent loops. 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}):
+${opts.lossesJson}
+
+Author ONE new strategy that you expect to beat the baselines on THIS environment at the same budget. Use the losses to target the observed failure mode. 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);
+  mkdirSync(opts.outDir, { recursive: true });
+  const file = join(opts.outDir, `authored-${Date.now()}.mts`);
+  writeFileSync(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 writeFileSync2 } 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)
+      writeFileSync2(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/supervise/detector-monitor.ts
+import {
+  argHash,
+  errorStreakDetector,
+  observeAll,
+  repeatedActionDetector
+} from "@tangle-network/agent-eval";
+function defaultToolDetectors() {
+  return [repeatedActionDetector({ maxRepeated: 3 }), errorStreakDetector({ maxErrors: 3 })];
+}
+function watchTrace(source, opts = {}) {
+  const detectors = opts.detectors ?? defaultToolDetectors();
+  return source.onSpan((span) => {
+    let fingerprint;
+    try {
+      fingerprint = `${span.toolName}|${argHash(span.args)}`;
+    } catch {
+      fingerprint = `${span.toolName}|<unhashable>`;
+    }
+    const signals = observeAll(detectors, {
+      actionFingerprint: fingerprint,
+      ...span.status ? { status: span.status } : {},
+      label: span.toolName
+    });
+    for (const s of signals) void opts.onSignal?.(s, span);
+  });
+}
+
+// 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/trace-source.ts
+function toToolSpan(input, runId, seq, at) {
+  const startedAt = typeof input.startedAt === "number" ? input.startedAt : at;
+  const endedAt = typeof input.endedAt === "number" ? input.endedAt : startedAt;
+  return {
+    spanId: `${runId}-t${seq}`,
+    runId,
+    kind: "tool",
+    name: input.toolName,
+    toolName: input.toolName,
+    args: input.args,
+    status: input.status ?? "ok",
+    startedAt,
+    endedAt,
+    ...input.result !== void 0 ? { result: input.result } : {}
+  };
+}
+var obj = (v) => v && typeof v === "object" ? v : void 0;
+var str = (v) => typeof v === "string" && v ? v : void 0;
+var decodeOpencodePart = (raw) => {
+  if (str(raw.type)?.toLowerCase() !== "tool" || !str(raw.tool)) return void 0;
+  const part = raw;
+  const state = obj(part.state);
+  const status = state?.status;
+  if (!status || status === "pending" || status === "running") return void 0;
+  return {
+    toolName: part.tool,
+    args: state?.input ?? {},
+    // ToolStateError carries 'error' OR 'failed' — the reverse-engineered decoder missed 'failed'.
+    status: status === "error" || status === "failed" ? "error" : "ok",
+    ...str(part.callID) ? { callId: part.callID } : {}
+  };
+};
+var decodeAnthropicPart = (p) => {
+  if (str(p.type)?.toLowerCase() !== "tool_use") return void 0;
+  const name = str(p.name) ?? str(p.tool);
+  if (!name) return void 0;
+  const id = str(p.id) ?? str(p.tool_use_id);
+  return {
+    toolName: name,
+    args: p.input ?? {},
+    ...id ? { callId: id } : {}
+  };
+};
+var decodeOpenAiPart = (p) => {
+  const type = str(p.type)?.toLowerCase();
+  const fn = obj(p.function);
+  if (type !== "function" && type !== "tool_call") return void 0;
+  const name = str(fn?.name) ?? str(p.name);
+  if (!name) return void 0;
+  const rawArgs = fn?.arguments ?? p.arguments;
+  return {
+    toolName: name,
+    args: typeof rawArgs === "string" ? safeParse(rawArgs) : rawArgs ?? {},
+    ...str(p.id) ? { callId: p.id } : str(fn?.id) ? { callId: fn?.id } : {}
+  };
+};
+var toolPartDecoders = {
+  opencode: decodeOpencodePart,
+  "claude-code": decodeAnthropicPart,
+  anthropic: decodeAnthropicPart,
+  codex: decodeOpenAiPart,
+  openai: decodeOpenAiPart,
+  router: decodeOpenAiPart,
+  kimi: decodeOpenAiPart
+};
+function decodeToolPart(part, harness) {
+  const p = obj(part);
+  if (!p) return void 0;
+  const specific = harness ? toolPartDecoders[harness] : void 0;
+  if (specific) return specific(p);
+  for (const decode of new Set(Object.values(toolPartDecoders))) {
+    const step = decode(p);
+    if (step) return step;
+  }
+  return void 0;
+}
+function safeParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}
+var runSeq = 0;
+function createPushTraceSource(opts = {}) {
+  const runId = opts.runId ?? `push-${runSeq++}`;
+  const now = opts.now ?? Date.now;
+  const spans = [];
+  const subs = /* @__PURE__ */ new Set();
+  return {
+    record(input) {
+      const span = toToolSpan(input, runId, spans.length, now());
+      spans.push(span);
+      for (const fn of subs) {
+        try {
+          fn(span);
+        } catch {
+        }
+      }
+      return span;
+    },
+    source: {
+      onSpan(handler) {
+        subs.add(handler);
+        return () => subs.delete(handler);
+      },
+      collect: () => Promise.resolve([...spans])
+    }
+  };
+}
+function createPartsTraceSource(opts) {
+  const runId = opts.runId ?? `parts-${runSeq++}`;
+  const now = opts.now ?? Date.now;
+  const subs = /* @__PURE__ */ new Set();
+  const seenLive = /* @__PURE__ */ new Set();
+  let liveSeq = 0;
+  let unsub;
+  const startLive = () => {
+    if (unsub || !opts.subscribeParts) return;
+    unsub = opts.subscribeParts((part) => {
+      const step = decodeToolPart(part, opts.harness);
+      if (!step) return;
+      if (step.callId) {
+        if (seenLive.has(step.callId)) return;
+        seenLive.add(step.callId);
+      }
+      const span = toToolSpan(step, runId, liveSeq++, now());
+      for (const fn of subs) {
+        try {
+          fn(span);
+        } catch {
+        }
+      }
+    });
+  };
+  return {
+    onSpan(handler) {
+      subs.add(handler);
+      startLive();
+      return () => {
+        subs.delete(handler);
+        if (subs.size === 0 && unsub) {
+          unsub();
+          unsub = void 0;
+        }
+      };
+    },
+    async collect() {
+      const parts = await opts.collectParts();
+      const spans = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const part of parts) {
+        const step = decodeToolPart(part, opts.harness);
+        if (!step) continue;
+        if (step.callId) {
+          if (seen.has(step.callId)) continue;
+          seen.add(step.callId);
+        }
+        spans.push(toToolSpan(step, runId, spans.length, now()));
+      }
+      return spans;
+    }
+  };
+}
+function sandboxSessionTraceSource(box, sessionId, opts = {}) {
+  return createPartsTraceSource({
+    collectParts: async () => {
+      const msgs = await box.messages({ sessionId });
+      return msgs.flatMap((m) => m.parts ? [...m.parts] : []);
+    },
+    ...opts.harness ? { harness: opts.harness } : {},
+    ...opts.subscribeParts ? { subscribeParts: opts.subscribeParts } : {},
+    runId: opts.runId ?? `box-${sessionId}`,
+    ...opts.now ? { now: opts.now } : {}
+  });
+}
+
+// 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();
+  for (let i = 0; i < spans.length; i += 1) {
+    const s = spans[i];
+    if (s) await store.appendSpan({ ...s, runId, spanId: `${runId}-t${i}` });
+  }
+  const [trajectory, stuckLoop, toolWaste] = await Promise.all([
+    buildTrajectory(store, runId),
+    stuckLoopView(store, { runId }),
+    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/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, rmSync } = await import("fs");
+  const { tmpdir } = await import("os");
+  const { join: join2 } = await import("path");
+  const dir = mkdtempSync(join2(tmpdir(), 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 {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+function tail(s) {
+  return s.slice(-400);
+}
+
+export {
+  anytimeReport,
+  renderAnytimeTable,
+  defaultAuditorInstruction,
+  auditIntent,
+  completionAuthorizes,
+  stopSentinel,
+  sentinelCompletion,
+  deterministicCompletion,
+  defaultAnalystInstruction,
+  observe,
+  renderReport,
+  harvestCorpus,
+  inlineSandboxClient,
+  reportLoopUsage,
+  loopDispatch,
+  createMcpEnvironment,
+  assertTraceDerivedFindings,
+  createScopeAnalyst,
+  registryScopeAnalyst,
+  buildSteerContext,
+  selectValidWinner,
+  pipeline,
+  fanout,
+  loopUntil,
+  panel,
+  verify,
+  widen,
+  flatWidenGate,
+  InMemoryCorpus,
+  FileCorpus,
+  renderCorpusToInstructions,
+  createShapeRegistry,
+  builtinShapes,
+  registerShape,
+  definePersona,
+  runPersonified,
+  trajectoryReport,
+  equalKOnCost,
+  promotionGate,
+  depthStrategy,
+  breadthStrategy,
+  sample,
+  refine,
+  defineStrategy,
+  adaptiveRefine,
+  sampleThenRefine,
+  runAgentic,
+  runBenchmark,
+  printBenchmarkReport,
+  SandboxRunAbortError,
+  openSandboxRun,
+  strategyAuthorContract,
+  assertStrategyContract,
+  authorStrategy,
+  discriminatingMeans,
+  pickChampion,
+  selectChampion,
+  runStrategyEvolution,
+  defaultToolDetectors,
+  watchTrace,
+  runCoderChecks,
+  patchDelivered,
+  decodeToolPart,
+  createPushTraceSource,
+  sandboxSessionTraceSource,
+  analyzeTrace,
+  worktreeFanout,
+  createVerifierEnvironment,
+  createWaterfallCollector,
+  localShell,
+  gitWorkspace,
+  jjWorkspace,
+  runInWorkspace,
+  computeFindingId,
+  makeFinding2 as makeFinding
+};
+//# sourceMappingURL=chunk-HPYWEFVY.js.map