@tangle-network/agent-runtime 0.47.0 → 0.49.0

package/dist/{chunk-72JQCHOZ.js → chunk-PXUTIMGJ.js}

@@ -426,6 +426,180 @@ function isNoEntError(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
+// 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;
@@ -674,8 +848,8 @@ function validateMove(move, maxFanout) {
       );
   }
 }
-async function runAnalyze(analyze, task, history) {
-  const findings = await analyze({ task, history });
+async function runAnalyze(analyze2, task, history) {
+  const findings = await analyze2({ task, history });
   if (!Array.isArray(findings)) {
     throw new PlannerError(
       `createDriver: analyze hook must return AnalystFinding[], got ${stringifySafe(findings)}`
@@ -703,6 +877,214 @@ function renderAnalyses(findings) {
 ${rows.join("\n")}`;
 }
 
+// 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 obj;
+  try {
+    obj = JSON.parse(content);
+  } catch {
+    const m = content.match(/\{[\s\S]*\}/);
+    obj = m ? JSON.parse(m[0]) : { findings: [] };
+  }
+  const arr = obj.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;
@@ -1651,8 +2033,8 @@ function defaultSelectWinner(iterations) {
   const candidates = iterations.filter((iter) => iter.output !== void 0 && !iter.error);
   if (candidates.length === 0) return void 0;
   const valid = candidates.filter((iter) => iter.verdict?.valid === true);
-  const pool = valid.length > 0 ? valid : candidates;
-  const sorted = [...pool].sort(
+  const pool2 = valid.length > 0 ? valid : candidates;
+  const sorted = [...pool2].sort(
     (a, b) => (b.verdict?.score ?? 0) - (a.verdict?.score ?? 0) || a.index - b.index
   );
   const top = sorted[0];
@@ -1737,160 +2119,96 @@ function loopDispatch(opts) {
   return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
 }
 
-// src/runtime/observe.ts
-import { makeFinding } from "@tangle-network/agent-eval";
-var observerId = "observe/trace";
-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}`);
+// 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)));
+    }
   }
-  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);
+  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 out.slice(0, maxLines).join("\n") || "(no tool/error events in trace)";
+  return { type: "object", properties: {} };
 }
-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"]
-        }
-      }
+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;
     },
-    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: "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."
-        },
-        {
-          role: "user",
-          content: `TASK: ${input.task}
-
-OUTCOME: ${input.outcome ?? "unknown"}
-
-FINAL OUTPUT (truncated):
-${input.output.slice(0, 1200)}
-
-TRACE (in order; "xN" = repeated):
-${traceSummary}`
-        }
-      ]
+    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;
     },
-    { ...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);
+    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);
     }
-  }
-  return { findings, learned, report: renderReport(findings) };
-}
-function parseFindings(content) {
-  let obj;
-  try {
-    obj = JSON.parse(content);
-  } catch {
-    const m = content.match(/\{[\s\S]*\}/);
-    obj = m ? JSON.parse(m[0]) : { findings: [] };
-  }
-  const arr = obj.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/supervise/scope.ts
@@ -2123,12 +2441,12 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
     seq
   };
 }
-async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs) {
+async function runChild(live, executor, childAbort, task, opts, pool2, ticket, blobs) {
   let reconciled = false;
   const reconcileOnce = (spend) => {
     if (reconciled) return;
     reconciled = true;
-    pool.reconcile(ticket, clampSpend(spend, opts.budget));
+    pool2.reconcile(ticket, clampSpend(spend, opts.budget));
   };
   try {
     live.status = "running";
@@ -2875,6 +3193,118 @@ var routerInlineExecutor = (spec, ctx) => {
     }
   };
 };
+var routerToolsSeamKey = "router-tools";
+var routerToolsInlineExecutor = (spec, ctx) => {
+  const seam = readSeam(ctx, routerToolsSeamKey, "router-tools");
+  const model = seam.model ?? spec.profile.model?.default;
+  if (!model) {
+    throw new ValidationError(
+      "routerToolsInlineExecutor: no model \u2014 set RouterToolsSeam.model or AgentProfile.model.default"
+    );
+  }
+  if (!seam.routerBaseUrl || !seam.routerKey) {
+    throw new ValidationError(
+      "routerToolsInlineExecutor: RouterToolsSeam.routerBaseUrl + routerKey required"
+    );
+  }
+  const maxTurns = seam.maxTurns ?? 200;
+  const controller = new AbortController();
+  const abortIfSignalled = () => {
+    if (ctx.signal.aborted) controller.abort();
+  };
+  abortIfSignalled();
+  if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+  let artifact;
+  return {
+    runtime: "router",
+    async execute(task, signal) {
+      const started = Date.now();
+      const linked = linkSignals(signal, controller.signal);
+      const messages = [
+        ...taskToMessages(task, spec)
+      ];
+      const tokens = zeroTokenUsage();
+      let turns = 0;
+      let lastText = "";
+      for (let t = 0; t < maxTurns; t += 1) {
+        turns += 1;
+        const res = await fetch(`${seam.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${seam.routerKey}`
+          },
+          body: JSON.stringify({
+            model,
+            messages,
+            tools: seam.tools,
+            tool_choice: "auto",
+            temperature: 0.2
+          }),
+          ...linked ? { signal: linked } : {}
+        });
+        if (!res.ok) {
+          throw new ValidationError(
+            `routerToolsInlineExecutor: router ${res.status}: ${(await res.text()).slice(0, 200)}`
+          );
+        }
+        const data = await res.json();
+        const u = data.usage;
+        if (u && typeof u.prompt_tokens === "number" && typeof u.completion_tokens === "number") {
+          tokens.input += u.prompt_tokens;
+          tokens.output += u.completion_tokens;
+        }
+        const msg = data.choices?.[0]?.message;
+        if (msg?.content) lastText = msg.content;
+        const toolCalls = msg?.tool_calls ?? [];
+        if (toolCalls.length === 0) break;
+        messages.push({
+          role: "assistant",
+          content: msg?.content ?? "",
+          tool_calls: toolCalls.map((tc, i) => ({
+            id: tc.id ?? `call_${i}`,
+            type: "function",
+            function: { name: tc.function?.name ?? "", arguments: tc.function?.arguments ?? "{}" }
+          }))
+        });
+        for (let i = 0; i < toolCalls.length; i += 1) {
+          const tc = toolCalls[i];
+          const id = tc?.id ?? `call_${i}`;
+          let args = {};
+          try {
+            args = JSON.parse(tc?.function?.arguments ?? "{}");
+          } catch {
+            messages.push({
+              role: "tool",
+              tool_call_id: id,
+              content: "error: tool arguments were not valid JSON"
+            });
+            continue;
+          }
+          const result = await seam.executeToolCall(tc?.function?.name ?? "", args, task);
+          messages.push({ role: "tool", tool_call_id: id, content: result });
+        }
+      }
+      const usd = isModelPriced(model) ? estimateCost(tokens.input, tokens.output, model) : 0;
+      const spent = { iterations: turns, tokens, usd, ms: Date.now() - started };
+      const out = { content: lastText };
+      artifact = { outRef: contentRef("router-tools", { model, content: lastText }), out, spent };
+      return artifact;
+    },
+    teardown(_grace) {
+      controller.abort();
+      return Promise.resolve({ destroyed: true });
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError(
+          "routerToolsInlineExecutor: resultArtifact() read before execute()"
+        );
+      }
+      return { ...artifact, spent: artifact.spent };
+    }
+  };
+};
 var sandboxExecutor = (spec, ctx) => {
   if (spec.harness === null) {
     throw new ValidationError("sandboxExecutor: harness is null (router/inline) \u2014 wrong executor");
@@ -3168,6 +3598,8 @@ function createExecutor(config) {
     switch (config.backend) {
       case "router":
         return routerInlineExecutor(spec, seamed);
+      case "router-tools":
+        return routerToolsInlineExecutor(spec, seamed);
       case "bridge":
         return bridgeExecutor(spec, seamed);
       case "cli":
@@ -3401,7 +3833,7 @@ function createSupervisor() {
   let attached;
   async function run(root, task, opts) {
     const now = opts.now ?? Date.now;
-    const pool = createBudgetPool(opts.budget, now);
+    const pool2 = createBudgetPool(opts.budget, now);
     await opts.journal.beginTree(opts.runId, new Date(now()).toISOString());
     await opts.journal.appendEvent(opts.runId, {
       kind: "spawned",
@@ -3427,7 +3859,7 @@ function createSupervisor() {
     const scope = createScope({
       parentId: opts.runId,
       root: opts.runId,
-      pool,
+      pool: pool2,
       journal,
       blobs: opts.blobs,
       executors: opts.executors,
@@ -3455,7 +3887,7 @@ function createSupervisor() {
     }
     const tree = scope.view;
     if (actOutcome.ok) {
-      pool.assertNoOpenTickets();
+      pool2.assertNoOpenTickets();
       const out = actOutcome.out;
       const outRef = contentAddress(out);
       await opts.blobs.put(outRef, out);
@@ -3469,7 +3901,7 @@ function createSupervisor() {
     }
     return {
       kind: "no-winner",
-      reason: classifyNoWinner(controller, pool, opts, breaker),
+      reason: classifyNoWinner(controller, pool2, opts, breaker),
       tree,
       downCount: breaker.downCount()
     };
@@ -3574,14 +4006,14 @@ async function drainCursor(scope) {
     if (settled === null) return;
   }
 }
-function classifyNoWinner(controller, pool, opts, breaker) {
+function classifyNoWinner(controller, pool2, opts, breaker) {
   if (breaker.tripped()) return "all-children-down";
   if (controller.signal.aborted) return "aborted";
-  if (poolExhausted(pool, opts)) return "budget-exhausted";
+  if (poolExhausted(pool2, opts)) return "budget-exhausted";
   return "all-children-down";
 }
-function poolExhausted(pool, opts) {
-  const r = pool.readout();
+function poolExhausted(pool2, opts) {
+  const r = pool2.readout();
   if (r.tokensLeft <= 0) return true;
   if (opts.budget.maxUsd !== void 0 && r.usdLeft <= 0) return true;
   if (opts.budget.deadlineMs !== void 0 && r.deadlineMs > 0 && (opts.now ?? Date.now)() >= r.deadlineMs) {
@@ -3717,13 +4149,13 @@ function shapeName(shape, _resolved) {
 }
 function resolveShapeBudget(root, over) {
   const fanout2 = over?.fanout ?? defaultFanout;
-  const perChild = over?.perChild ?? {
+  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, fanout: fanout2 };
+  return { perChild: perChild2, fanout: fanout2 };
 }
 var defaultFanout = 3;
 function personaRegistry(persona) {
@@ -3914,13 +4346,13 @@ function spreadOf(values) {
 function fractionalSpread(values) {
   const spread = spreadOf(values);
   if (spread === 0) return 0;
-  const median = medianOf(values);
-  if (median === 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 / median;
+  return spread / median2;
 }
 function medianOf(values) {
   if (values.length === 0) {
@@ -3961,75 +4393,951 @@ function requireSpend(rolled, id, root) {
   return spend;
 }
 
-// src/runtime/sandbox-run.ts
-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 }
+// 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 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 = [];
-    for await (const ev of events) collected.push(ev);
-    if (deliverable.kind === "events") {
-      return { out: deliverable.fromEvents(collected), events: collected };
+  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 } : {}
     }
-    throwIfAborted(options.signal);
-    let raw = "";
-    let readError;
-    const readAttempts = 4;
-    const readDelayMs = options.readRetryDelayMs ?? 1e3;
-    for (let attempt = 0; attempt < readAttempts; attempt += 1) {
-      throwIfAborted(options.signal);
-      try {
-        raw = await box.fs.read(deliverable.path);
-        readError = void 0;
-        break;
-      } catch (err) {
+  );
+  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 as estimateCost2, isModelPriced as isModelPriced2 } 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) {
+  const innerTurns = opts.innerTurns ?? 4;
+  let completions = 0;
+  let toolCalls = 0;
+  let toolErrors = 0;
+  const tokens = { input: 0, output: 0 };
+  for (let t = 0; t < innerTurns; t += 1) {
+    const res = await fetch(`${opts.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${opts.routerKey}` },
+      body: JSON.stringify({
+        model: modelOverride ?? opts.model,
+        messages,
+        tools,
+        tool_choice: "auto",
+        temperature: opts.temperature ?? 0.7,
+        ...opts.maxTokens ? { max_tokens: opts.maxTokens } : {}
+      })
+    });
+    if (!res.ok) throw new Error(`router ${res.status}: ${(await res.text()).slice(0, 200)}`);
+    completions += 1;
+    const data = await res.json();
+    if (typeof data.usage?.prompt_tokens === "number") tokens.input += data.usage.prompt_tokens;
+    if (typeof data.usage?.completion_tokens === "number")
+      tokens.output += data.usage.completion_tokens;
+    const msg = data.choices?.[0]?.message;
+    if (!msg) break;
+    const calls = msg.tool_calls ?? [];
+    messages.push({
+      role: "assistant",
+      content: msg.content ?? "",
+      ...calls.length ? { tool_calls: calls } : {}
+    });
+    if (calls.length === 0) break;
+    for (const call of calls) {
+      toolCalls += 1;
+      let args = {};
+      try {
+        args = JSON.parse(call.function.arguments || "{}");
+      } catch {
+        toolErrors += 1;
+      }
+      let out;
+      try {
+        out = await surface.call(handle, call.function.name, args);
+        if (out.startsWith("ERROR:")) toolErrors += 1;
+      } catch (e) {
+        toolErrors += 1;
+        out = `ERROR: ${e instanceof Error ? e.message : String(e)}`;
+      }
+      messages.push({ role: "tool", tool_call_id: call.id, content: out });
+    }
+  }
+  return { messages, completions, toolCalls, toolErrors, tokens };
+}
+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: isModelPriced2(opts.model) ? estimateCost2(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: isModelPriced2(analystModel) ? estimateCost2(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) {
+  return {
+    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 };
+    }
+  };
+}
+function leaf(name, role) {
+  const agent = {
+    name,
+    executorSpec: { profile: { name, metadata: { role } }, harness: null },
+    act() {
+      throw new Error(`agentic: spawned leaf "${name}" run as a driver`);
+    }
+  };
+  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 depthDriver(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 breadthDriver(_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) => breadthDriver(surface, task, opts, { width: budget })
+};
+var refine = {
+  name: "refine",
+  driver: (surface, task, opts, budget) => depthDriver(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
+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 = [];
+    for await (const ev of events) collected.push(ev);
+    if (deliverable.kind === "events") {
+      return { out: deliverable.fromEvents(collected), events: collected };
+    }
+    throwIfAborted(options.signal);
+    let raw = "";
+    let readError;
+    const readAttempts = 4;
+    const readDelayMs = options.readRetryDelayMs ?? 1e3;
+    for (let attempt = 0; attempt < readAttempts; attempt += 1) {
+      throwIfAborted(options.signal);
+      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);
@@ -4189,6 +5497,710 @@ 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/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 totalTokens2 = { input: 0, output: 0 };
+    for (const s of all) {
+      totalUsd += s.usd;
+      totalTokens2.input += s.tokens.input;
+      totalTokens2.output += s.tokens.output;
+      const kind = s.label.includes(":") ? s.label.split(":")[0] : s.label;
+      const k = byKind[kind] ??= { count: 0, ms: 0, usd: 0, tokens: { input: 0, output: 0 } };
+      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: totalTokens2, 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) => {
@@ -4249,11 +6261,52 @@ function gitWorkspace(opts) {
     }
   };
 }
+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] ?? "";
+    }
+  };
+}
 function tail(s) {
   return s.slice(-400);
 }
 
 export {
+  deleteBoxSafe,
+  throwAbort,
+  throwIfAborted,
+  sleep,
   contentAddress,
   InMemoryResultBlobStore,
   FileResultBlobStore,
@@ -4261,6 +6314,10 @@ export {
   FileSpawnJournal,
   replaySpawnTree,
   materializeTreeView,
+  anytimeReport,
+  renderAnytimeTable,
+  defaultAuditorInstruction,
+  auditIntent,
   completionAuthorizes,
   stopSentinel,
   sentinelCompletion,
@@ -4270,6 +6327,10 @@ export {
   buildSteerContext,
   createDriver,
   renderAnalyses,
+  defaultAnalystInstruction,
+  observe,
+  renderReport,
+  harvestCorpus,
   inlineSandboxClient,
   reportLoopUsage,
   defineRuntimeHooks,
@@ -4284,8 +6345,7 @@ export {
   createSandboxForSpec,
   defaultSelectWinner,
   loopDispatch,
-  observe,
-  renderReport,
+  createMcpEnvironment,
   createScope,
   settledToIteration,
   pipeline,
@@ -4311,8 +6371,29 @@ export {
   runPersonified,
   trajectoryReport,
   equalKOnCost,
+  promotionGate,
+  depthDriver,
+  breadthDriver,
+  sample,
+  refine,
+  defineStrategy,
+  adaptiveRefine,
+  sampleThenRefine,
+  runAgentic,
+  runBenchmark,
+  printBenchmarkReport,
   openSandboxRun,
+  strategyAuthorContract,
+  assertStrategyContract,
+  authorStrategy,
+  discriminatingMeans,
+  pickChampion,
+  selectChampion,
+  runStrategyEvolution,
+  createVerifierEnvironment,
+  createWaterfallCollector,
   localShell,
-  gitWorkspace
+  gitWorkspace,
+  jjWorkspace
 };
-//# sourceMappingURL=chunk-72JQCHOZ.js.map
+//# sourceMappingURL=chunk-PXUTIMGJ.js.map