@tangle-network/agent-runtime 0.46.0 → 0.48.0

package/dist/{chunk-65FQLI4V.js → chunk-IW2LMLK6.js}

@@ -426,6 +426,83 @@ function isNoEntError(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
+// 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 +751,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 +780,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;
@@ -1024,6 +1309,7 @@ function createSandboxLineage(client, capabilities, options = {}) {
     if (signal.aborted) throwAbort();
     const opts = buildBackendOptions(spec.profile, spec.sandboxOverrides);
     const box = await acquireSandbox(client, opts, { signal });
+    await spec.prepareBox?.(box, { signal });
     owned.push(box);
     return box;
   };
@@ -1052,6 +1338,7 @@ function createSandboxLineage(client, capabilities, options = {}) {
         if (checkpointId !== void 0) {
           const box2 = await forkFromCheckpoint(parent.box, checkpointId, signal);
           owned.push(box2);
+          await spec.prepareBox?.(box2, { signal });
           const sessionId2 = mintSessionId();
           return {
             handle: { box: box2, sessionId: sessionId2 },
@@ -1475,6 +1762,7 @@ async function executeIteration(args) {
     if (args.validator) {
       slot.verdict = await args.validator.validate(slot.output, {
         iteration: args.item.index,
+        ...box ? { box } : {},
         signal: args.signal,
         traceEmitter: args.ctx.traceEmitter
       });
@@ -1571,7 +1859,9 @@ function readSandboxId(box) {
 async function createSandboxForSpec(client, spec, signal) {
   const opts = buildBackendOptions(spec.profile, spec.sandboxOverrides);
   if (signal.aborted) throwAbort();
-  return acquireSandbox(client, opts, { signal });
+  const box = await acquireSandbox(client, opts, { signal });
+  await spec.prepareBox?.(box, { signal });
+  return box;
 }
 function finalize(args) {
   const winner = args.options.selectWinner ? args.options.selectWinner(args.iterations) : args.options.driver.selectWinner?.(args.iterations) ?? defaultSelectWinner(args.iterations);
@@ -1646,8 +1936,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];
@@ -1732,6 +2022,98 @@ function loopDispatch(opts) {
   return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
 }
 
+// src/runtime/mcp-environment.ts
+async function rpc(endpoint, body) {
+  let lastErr;
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    try {
+      const r = await fetch(endpoint.url, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...endpoint.headers ?? {} },
+        body: JSON.stringify(body)
+      });
+      const text = await r.text();
+      const dataLines = text.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim());
+      const payload = dataLines.length ? dataLines[dataLines.length - 1] : text;
+      try {
+        return { status: r.status, json: JSON.parse(payload ?? "null") };
+      } catch {
+        return { status: r.status, json: text };
+      }
+    } catch (err) {
+      lastErr = err;
+      await new Promise((res) => setTimeout(res, 1e3 * (attempt + 1)));
+    }
+  }
+  throw new Error(
+    `mcp rpc ${endpoint.url} failed after 4 attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+  );
+}
+function sanitizeSchema(s) {
+  const o = s && typeof s === "object" ? s : {};
+  const banned = o.oneOf || o.anyOf || o.allOf || o.not || o.enum;
+  if (o.type === "object" && !banned && o.properties && typeof o.properties === "object") {
+    return {
+      type: "object",
+      properties: o.properties,
+      ...Array.isArray(o.required) ? { required: o.required } : {}
+    };
+  }
+  return { type: "object", properties: {} };
+}
+function createMcpEnvironment(opts) {
+  const endpoints = /* @__PURE__ */ new Map();
+  const maxChars = opts.maxResultChars ?? 1500;
+  return {
+    name: opts.name,
+    async open(task) {
+      const { handle, endpoint } = await opts.open(task);
+      endpoints.set(handle.id, endpoint);
+      return handle;
+    },
+    async tools(task, handle) {
+      const endpoint = endpoints.get(handle.id);
+      if (!endpoint) throw new Error(`${opts.name}: tools() before open() for ${handle.id}`);
+      const { json } = await rpc(endpoint, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/list",
+        params: {}
+      });
+      const all = (json.result?.tools ?? []).map(
+        (t) => ({
+          type: "function",
+          function: {
+            name: t.name,
+            description: (t.description ?? "").slice(0, 1e3),
+            parameters: sanitizeSchema(t.inputSchema)
+          }
+        })
+      );
+      return opts.selectTools ? opts.selectTools(task, all) : all;
+    },
+    async call(handle, name, args) {
+      const endpoint = endpoints.get(handle.id);
+      if (!endpoint) return "ERROR: workspace closed";
+      const { json } = await rpc(endpoint, {
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: { name, arguments: args }
+      });
+      const result = json ?? {};
+      if (result.error) return `ERROR: ${JSON.stringify(result.error).slice(0, 300)}`;
+      const text = result.result?.content?.map((c) => c.text ?? "").join("\n") ?? JSON.stringify(result.result ?? json);
+      return text.slice(0, maxChars);
+    },
+    score: (task, handle) => opts.score(task, handle),
+    async close(handle) {
+      endpoints.delete(handle.id);
+      await opts.close?.(handle);
+    }
+  };
+}
+
 // src/runtime/supervise/scope.ts
 function createScope(args) {
   const children = /* @__PURE__ */ new Map();
@@ -1962,22 +2344,22 @@ 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) => {
+  const reconcileOnce = (spend2) => {
     if (reconciled) return;
     reconciled = true;
-    pool.reconcile(ticket, clampSpend(spend, opts.budget));
+    pool2.reconcile(ticket, clampSpend(spend2, opts.budget));
   };
   try {
     live.status = "running";
     const ran = executor.execute(task, childAbort.signal);
     let artifact;
     if (isAsyncIterable2(ran)) {
-      const spend = await foldStream(ran);
-      live.spent = spend;
+      const spend2 = await foldStream(ran);
+      live.spent = spend2;
       artifact = executor.resultArtifact();
-      reconcileOnce(spend);
+      reconcileOnce(spend2);
     } else {
       const terminal = await ran;
       live.spent = terminal.spent;
@@ -2066,21 +2448,21 @@ async function foldStream(stream) {
   }
   return { iterations, tokens, usd, ms: 0 };
 }
-function clampSpend(spend, budget) {
-  const totalTokens2 = spend.tokens.input + spend.tokens.output;
+function clampSpend(spend2, budget) {
+  const totalTokens2 = spend2.tokens.input + spend2.tokens.output;
   const tokensOk = totalTokens2 <= budget.maxTokens;
-  const itersOk = spend.iterations <= budget.maxIterations;
-  const usdOk = budget.maxUsd === void 0 || spend.usd <= budget.maxUsd;
-  if (tokensOk && itersOk && usdOk) return spend;
+  const itersOk = spend2.iterations <= budget.maxIterations;
+  const usdOk = budget.maxUsd === void 0 || spend2.usd <= budget.maxUsd;
+  if (tokensOk && itersOk && usdOk) return spend2;
   const ratio = !tokensOk && totalTokens2 > 0 ? budget.maxTokens / totalTokens2 : 1;
   return {
-    iterations: Math.min(spend.iterations, budget.maxIterations),
+    iterations: Math.min(spend2.iterations, budget.maxIterations),
     tokens: ratio < 1 ? {
-      input: Math.floor(spend.tokens.input * ratio),
-      output: Math.floor(spend.tokens.output * ratio)
-    } : spend.tokens,
-    usd: budget.maxUsd === void 0 ? spend.usd : Math.min(spend.usd, budget.maxUsd),
-    ms: spend.ms
+      input: Math.floor(spend2.tokens.input * ratio),
+      output: Math.floor(spend2.tokens.output * ratio)
+    } : spend2.tokens,
+    usd: budget.maxUsd === void 0 ? spend2.usd : Math.min(spend2.usd, budget.maxUsd),
+    ms: spend2.ms
   };
 }
 async function teardownSafe(executor, grace) {
@@ -2714,6 +3096,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 ?? 4;
+  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");
@@ -3007,6 +3501,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":
@@ -3240,7 +3736,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",
@@ -3266,7 +3762,7 @@ function createSupervisor() {
     const scope = createScope({
       parentId: opts.runId,
       root: opts.runId,
-      pool,
+      pool: pool2,
       journal,
       blobs: opts.blobs,
       executors: opts.executors,
@@ -3294,7 +3790,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);
@@ -3308,7 +3804,7 @@ function createSupervisor() {
     }
     return {
       kind: "no-winner",
-      reason: classifyNoWinner(controller, pool, opts, breaker),
+      reason: classifyNoWinner(controller, pool2, opts, breaker),
       tree,
       downCount: breaker.downCount()
     };
@@ -3413,14 +3909,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) {
@@ -3556,13 +4052,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) {
@@ -3732,12 +4228,12 @@ function countStatuses(reported) {
 function zeroSpend4() {
   return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
 }
-function cloneSpend(spend) {
+function cloneSpend(spend2) {
   return {
-    iterations: spend.iterations,
-    tokens: { input: spend.tokens.input, output: spend.tokens.output },
-    usd: spend.usd,
-    ms: spend.ms
+    iterations: spend2.iterations,
+    tokens: { input: spend2.tokens.input, output: spend2.tokens.output },
+    usd: spend2.usd,
+    ms: spend2.ms
   };
 }
 function addSpend(acc, delta) {
@@ -3791,13 +4287,682 @@ function requireNode2(nodes, id, root) {
   return node;
 }
 function requireSpend(rolled, id, root) {
-  const spend = rolled.get(id);
-  if (!spend) {
+  const spend2 = rolled.get(id);
+  if (!spend2) {
     throw new Error(
       `trajectoryReport: node '${id}' was never rolled up in tree '${root}' (unreachable from root)`
     );
   }
-  return spend;
+  return spend2;
+}
+
+// src/runtime/promotion-gate.ts
+import { heldoutSignificance } from "@tangle-network/agent-eval/campaign";
+function promotionGate(opts) {
+  if (opts.candidate === opts.incumbent) {
+    return {
+      promoted: false,
+      reason: "identical-champion",
+      n: 0,
+      lift: { mean: 0, median: 0, low: 0, high: 0 }
+    };
+  }
+  const before = [];
+  const after = [];
+  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);
+    cellIds.push(row.taskId);
+  }
+  if (before.length === 0) {
+    throw new Error(
+      `promotionGate: no holdout task carried cells for both "${opts.incumbent}" and "${opts.candidate}" \u2014 the report must come from a run that included both strategies`
+    );
+  }
+  const sig = heldoutSignificance(
+    { before, after, cellIds },
+    {
+      deltaThreshold: opts.deltaThreshold ?? 0,
+      minProductiveRuns: opts.minPairedTasks ?? 6,
+      statistic: opts.statistic ?? "mean",
+      ...opts.seed !== void 0 ? { seed: opts.seed } : {},
+      ...opts.resamples !== void 0 ? { resamples: opts.resamples } : {}
+    }
+  );
+  const lift = {
+    mean: sig.bootstrap.mean,
+    median: sig.bootstrap.median,
+    low: sig.bootstrap.low,
+    high: sig.bootstrap.high
+  };
+  if (sig.fewRuns) return { promoted: false, reason: "few-tasks", n: sig.n, lift };
+  return sig.significant ? { promoted: true, reason: "significant", n: sig.n, lift } : { promoted: false, reason: "no-margin", n: sig.n, lift };
+}
+
+// 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
+      })
+    });
+    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 };
+}
+async function analyze(task, messages, opts) {
+  const trajectory = 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);
+  const analystModel = opts.analystModel ?? opts.model;
+  const chat = createChatClient({
+    transport: "router",
+    apiKey: opts.routerKey,
+    baseUrl: opts.routerBaseUrl,
+    defaultModel: analystModel
+  });
+  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 || "COMPLETE";
+}
+var spend = (iterations) => ({
+  iterations,
+  tokens: { input: 0, output: 0 },
+  usd: 0,
+  ms: 0
+});
+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 tools = await surface.tools(t.task, handle);
+        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 findings = await analyze(t.task, t.messages, opts);
+      artifact = { outRef: `analyst:${findings.length}`, out: findings, spent: spend(1) };
+      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 ctx = {
+          // Narrowed to open/close — the body gets no raw call()/score() access.
+          surface: {
+            name: surface.name,
+            open: (t) => surface.open(t),
+            close: (h) => 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
+              },
+              { 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 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;
+          }
+        };
+        const r = await run(ctx);
+        return {
+          kind: "done",
+          deliverable: { mode: name, ...r, 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 = {};
+    let row;
+    try {
+      for (const s of strategies) {
+        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
+        };
+      }
+      row = { taskId: task.id, cells };
+    } 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
@@ -4028,6 +5193,486 @@ 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? }): 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.
+    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.
+
+  surface.open(task) / surface.close(handle)
+    Open a persistent artifact you manage yourself (remember to close in a finally).
+
+Rules:
+- 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 }) => {
+  // your composition
+})
+`;
+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 { gzipSync } from "zlib";
+function selectChampion(report, fieldOrder, policy, epsilon) {
+  const entries = fieldOrder.map((name) => ({ name, summary: report.perStrategy[name] })).filter((e) => !!e.summary);
+  if (entries.length === 0)
+    throw new Error("selectChampion: report 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("selectChampion: empty pick (unreachable)");
+  return { name: pick.name, score: pick.summary.score, usd: pick.summary.usd };
+}
+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) => {
+  const r2 = (x) => Math.round(x * 100) / 100;
+  const rows = report.perTask.map(
+    (row) => row.cells ? {
+      task: row.taskId,
+      cells: Object.fromEntries(
+        Object.entries(row.cells).map(([name, c]) => [
+          name,
+          { score: r2(c.score), resolved: c.resolved, progression: c.progression.map(r2) }
+        ])
+      )
+    } : { task: row.taskId, error: row.error?.slice(0, 80) }
+  );
+  return JSON.stringify(rows).slice(0, 12e3);
+};
+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 ?? 0.01;
+  const byName = new Map(baselines.map((s) => [s.name, s]));
+  const bench = (phase, tasks, strategies) => 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 gen0 = await bench("gen0", train, baselines);
+  const 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 = selectChampion(
+    gen0,
+    baselines.map((s) => s.name),
+    policy,
+    epsilon
+  );
+  let incumbent = gen0Champion;
+  let latestReport = gen0;
+  const generationRows = [];
+  const trajectory = [
+    {
+      generation: 0,
+      champion: gen0Champion.name,
+      score: gen0Champion.score,
+      usd: gen0Champion.usd
+    }
+  ];
+  let authoredOk = 0;
+  for (let g = 1; g <= generations; g += 1) {
+    const lossesJson = compactLosses(latestReport);
+    const candidates = [];
+    const newStrategies = [];
+    for (let i = 0; i < populationSize; i += 1) {
+      const contract = `${strategyAuthorContract}
+
+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 = unique === authored.strategy.name ? authored.strategy : {
+          name: unique,
+          driver: (s, t, o, b) => {
+            const agent = authored.strategy.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 };
+              }
+            };
+          }
+        };
+        byName.set(unique, strategy);
+        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 champion = selectChampion(
+      report,
+      field.map((s) => s.name),
+      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;
+  }
+  if (authoredOk === 0) {
+    throw new Error(
+      "runStrategyEvolution: every author attempt failed across all generations \u2014 no search happened; see the candidates[].error entries"
+    );
+  }
+  const holdoutTasks = await cfg.tasks(cfg.trainN + (cfg.holdoutOffset ?? 0), cfg.holdoutN);
+  const finalists = [.../* @__PURE__ */ new Set([gen0Champion.name, incumbent.name])].map((n) => byName.get(n)).filter((s) => !!s);
+  const holdout = await bench("holdout", holdoutTasks, finalists);
+  const verdict = promotionGate({
+    report: holdout,
+    incumbent: gen0Champion.name,
+    candidate: incumbent.name,
+    ...cfg.minPairedTasks !== void 0 ? { minPairedTasks: cfg.minPairedTasks } : {}
+  });
+  return {
+    gen0,
+    gen0Champion,
+    generations: generationRows,
+    archive,
+    finalChampion: incumbent,
+    holdout,
+    verdict,
+    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/workspace.ts
+function localShell() {
+  return async (args, cwd) => {
+    const { execFile } = await import("child_process");
+    const [bin, ...rest] = args;
+    return new Promise((resolve) => {
+      execFile(
+        bin ?? "",
+        rest,
+        { cwd, encoding: "utf-8", maxBuffer: 64 * 1024 * 1024 },
+        (err, stdout, stderr) => {
+          resolve({
+            stdout: stdout ?? "",
+            stderr: stderr ?? "",
+            code: err ? err.code ?? 1 : 0
+          });
+        }
+      );
+    });
+  };
+}
+function gitWorkspace(opts) {
+  const shell = opts.shell ?? localShell();
+  const branch = opts.branch ?? "main";
+  const cfg = opts.noHooks === false ? [] : ["-c", "core.hooksPath=/dev/null"];
+  const ident = ["-c", "user.email=workspace@tangle.local", "-c", "user.name=workspace"];
+  const run = async (args, cwd) => {
+    const res = await shell(["git", ...cfg, ...ident, ...args], cwd);
+    if (res.code !== 0) {
+      throw new Error(
+        `git ${args.join(" ")} failed (${res.code}): ${tail(res.stderr || res.stdout)}`
+      );
+    }
+    return res.stdout;
+  };
+  return {
+    ref: opts.ref,
+    materialize: (dir) => run(["clone", "--branch", branch, opts.ref, dir]).then(() => {
+    }),
+    async commit(dir, message) {
+      await run(["add", "-A"], dir);
+      const status = await run(["status", "--porcelain"], dir);
+      if (!status.trim()) return { ok: true, rev: (await run(["rev-parse", "HEAD"], dir)).trim() };
+      await run(["commit", "-m", message], dir);
+      const pull = await shell(["git", ...cfg, ...ident, "pull", "--rebase", "origin", branch], dir);
+      if (pull.code !== 0) {
+        await shell(["git", ...cfg, "rebase", "--abort"], dir).catch(() => {
+        });
+        return { ok: false, conflict: tail(pull.stderr || pull.stdout) };
+      }
+      const push = await shell(["git", ...cfg, ...ident, "push", "origin", branch], dir);
+      if (push.code !== 0) return { ok: false, conflict: tail(push.stderr || push.stdout) };
+      return { ok: true, rev: (await run(["rev-parse", "HEAD"], dir)).trim() };
+    },
+    async head() {
+      const out = await run(["ls-remote", opts.ref, `refs/heads/${branch}`]);
+      return out.split(/\s+/)[0] ?? "";
+    }
+  };
+}
+function jjWorkspace(opts) {
+  const shell = opts.shell ?? localShell();
+  const branch = opts.branch ?? "main";
+  const ident = [
+    "--config-toml",
+    'user.name="workspace"',
+    "--config-toml",
+    'user.email="workspace@tangle.local"'
+  ];
+  const jj = async (args, cwd) => {
+    const res = await shell(["jj", ...ident, ...args], cwd);
+    if (res.code !== 0) {
+      throw new Error(
+        `jj ${args.join(" ")} failed (${res.code}): ${tail(res.stderr || res.stdout)}`
+      );
+    }
+    return res.stdout;
+  };
+  return {
+    ref: opts.ref,
+    // Colocated clone: jj manages history, git holds the durable remote.
+    materialize: (dir) => jj(["git", "clone", "--colocate", opts.ref, dir]).then(() => {
+    }),
+    async commit(dir, message) {
+      await jj(["describe", "-m", message], dir);
+      await jj(["new"], dir);
+      const push = await shell(["jj", ...ident, "git", "push", "--branch", branch], dir);
+      if (push.code !== 0) return { ok: false, conflict: tail(push.stderr || push.stdout) };
+      const rev = (await jj(["log", "--no-graph", "-r", "@-", "-T", "commit_id"], dir)).trim();
+      return { ok: true, rev };
+    },
+    async head() {
+      const out = await shell(["git", "ls-remote", opts.ref, `refs/heads/${branch}`]);
+      return out.stdout.split(/\s+/)[0] ?? "";
+    }
+  };
+}
+function tail(s) {
+  return s.slice(-400);
+}
+
 export {
   contentAddress,
   InMemoryResultBlobStore,
@@ -4036,6 +5681,8 @@ export {
   FileSpawnJournal,
   replaySpawnTree,
   materializeTreeView,
+  defaultAuditorInstruction,
+  auditIntent,
   completionAuthorizes,
   stopSentinel,
   sentinelCompletion,
@@ -4045,6 +5692,10 @@ export {
   buildSteerContext,
   createDriver,
   renderAnalyses,
+  defaultAnalystInstruction,
+  observe,
+  renderReport,
+  harvestCorpus,
   inlineSandboxClient,
   reportLoopUsage,
   defineRuntimeHooks,
@@ -4059,6 +5710,7 @@ export {
   createSandboxForSpec,
   defaultSelectWinner,
   loopDispatch,
+  createMcpEnvironment,
   createScope,
   settledToIteration,
   pipeline,
@@ -4084,6 +5736,26 @@ export {
   runPersonified,
   trajectoryReport,
   equalKOnCost,
-  openSandboxRun
+  promotionGate,
+  depthDriver,
+  breadthDriver,
+  sample,
+  refine,
+  defineStrategy,
+  adaptiveRefine,
+  sampleThenRefine,
+  runAgentic,
+  runBenchmark,
+  printBenchmarkReport,
+  openSandboxRun,
+  strategyAuthorContract,
+  assertStrategyContract,
+  authorStrategy,
+  selectChampion,
+  runStrategyEvolution,
+  createVerifierEnvironment,
+  localShell,
+  gitWorkspace,
+  jjWorkspace
 };
-//# sourceMappingURL=chunk-65FQLI4V.js.map
+//# sourceMappingURL=chunk-IW2LMLK6.js.map