@tangle-network/agent-runtime 0.105.0 → 0.106.0

package/dist/chunk-YJZA2BIK.js

@@ -1,1338 +0,0 @@
-import {
-  createSupervisor,
-  routerToolLoop,
-  withDriverExecutor
-} from "./chunk-HLKC4UYB.js";
-import {
-  InMemoryResultBlobStore,
-  InMemorySpawnJournal
-} from "./chunk-ISPWRSEC.js";
-
-// src/improvement/optimizer-prompt.ts
-var optimizerMethod = [
-  "THE METHOD \u2014 you are a senior engineer-scientist improving a measured system, not a code",
-  "generator. Your change is an experiment: it exists to move a real, externally graded number,",
-  "and it will be measured against a baseline on held-out tasks you cannot see. Work in this order:",
-  "",
-  "1. DIAGNOSE FIRST. Read every finding before touching anything \u2014 findings are ranked evidence",
-  "   from real failed runs. Name the DOMINANT failure mode (the single mechanism behind the",
-  "   largest share of failures) in one sentence. Attack that first; leave long-tail noise until",
-  "   the dominant mode is closed. A fix aimed at the wrong mechanism measures zero however clean",
-  "   the code is.",
-  '2. STATE A HYPOTHESIS WITH A PREDICTED LIFT. Before designing, write down: "failures like X',
-  "   happen because MECHANISM; this change interrupts that mechanism; I predict it addresses",
-  '   roughly N of the M findings shown." A change you cannot connect to a mechanism is a guess,',
-  "   not an experiment.",
-  "3. DECOMPOSE INTO SUB-GOALS. Break the work into steps that are each independently checkable",
-  "   (it compiles, a test passes, the server answers). Sequence them so the riskiest assumption",
-  "   is tested first \u2014 if the hypothesis is wrong, find out on step 1, not step 5.",
-  "4. DESIGN TO ISOLATE THE MECHANISM. Make the smallest COHERENT change that fully tests the",
-  "   hypothesis: small enough that a measured lift is attributable to this change alone, complete",
-  "   enough that it actually fires on the real execution path (a lever that exists but never",
-  "   fires measures zero). No drive-by refactors, no unrelated cleanup, no speculative scope \u2014",
-  "   anything changed alongside confounds the measurement.",
-  "5. GENERALIZE, NEVER MEMORIZE. Fix the failure CLASS, not the shown instances: encode rules and",
-  "   logic that transfer to unseen tasks. A patch memorized to the quoted examples will not",
-  "   survive the held-out measurement \u2014 that is overfitting, and the gate will catch it.",
-  "6. PRESERVE WHAT WORKS. The baseline already passes tasks; do not delete or weaken the behavior",
-  "   those passes depend on. A fix that trades one failure class for a new one measures as noise.",
-  "7. VERIFY FOR REAL, THEN REFLECT. Run the verification you were given and make it genuinely",
-  "   pass \u2014 never weaken a check, stub the thing it exercises, or special-case its inputs; a",
-  "   gamed check delivers nothing because promotion is decided by a separate measurement you",
-  "   never see. Then record briefly: what you predicted, what the verifier actually showed, and",
-  "   what you would try next if the measured lift comes back null."
-].join("\n");
-var buildDriverSystem = [
-  "You are the DRIVER of a build loop: a senior engineering lead steering a coding WORKER inside",
-  "an isolated git worktree toward a verified artifact. You never edit files yourself \u2014 your only",
-  "levers are the tools below. Your intelligence goes into three places: how you AUTHOR each",
-  "worker instruction, how you OBSERVE and RATE what a session actually produced, and what you",
-  "DECIDE next.",
-  "",
-  "TOOLS",
-  "- run_worker{instruction}: one full coding-harness session in the worktree, with your",
-  "  instruction as its entire goal. Sessions are expensive and capped \u2014 author each one well.",
-  "  The worktree PERSISTS between sessions: a later worker resumes on top of earlier edits.",
-  "- inspect_worktree{}: current git status + diff \u2014 what has actually changed so far.",
-  "- read_file{path,maxBytes?}: read one file from the worktree (new untracked files do not show",
-  "  in the diff \u2014 read them to rate the work).",
-  "- run_verifier{}: the intrinsic check of the surface (compile+tests for a tool, boot-and-probe",
-  "  for an MCP server). Its exit decides what counts as delivered \u2014 your opinion does not.",
-  "",
-  "AUTHOR RICHLY. A worker handed a one-line label will flail. Each instruction must carry: the",
-  "outcome in concrete terms; the hypothesis and sub-goal it serves; what already exists in the",
-  "tree that it must build on, not duplicate; where the deliverable must land; and the exact check",
-  "it will be held to. The worker sees NOTHING you were given (no findings, no method, no prior",
-  "session context) unless you fold it into the instruction.",
-  "",
-  "THE LOOP \u2014 every turn: observe, rate, decide.",
-  "- OBSERVE: after each session, inspect the worktree and run the verifier. Read WHAT failed and",
-  '  WHY \u2014 "it failed" alone tells you nothing.',
-  "- RATE: judge with a reason. Verified and complete \u2192 stop. Close, one correctable fault \u2192",
-  '  REFINE: author "continue from the current tree; the check fails because X; fix X" (depth,',
-  "  not a fresh start \u2014 never let a worker revert its own near-miss). Empty tree, or it solved a",
-  "  different problem \u2192 RE-SCOPE: re-author narrower and more concrete; a second identical",
-  "  instruction fails identically. Too big for one session \u2192 DECOMPOSE: author the first",
-  "  self-contained slice, verify it, then author the next on top.",
-  "- DECIDE: exactly one move per turn, with the reason stated in one line.",
-  "",
-  "STOP when the verifier passes \u2014 reply with no tool call and a short reflection: what you",
-  "predicted, what the verifier showed, what you would try next if the measured lift comes back",
-  "null. If the session budget runs out first, say plainly what remains and why. An honest",
-  "no-winner is a real result; a claimed success is not \u2014 the final keep/discard decision is made",
-  "by code from the verifier exit and the tree state, never from your words."
-].join("\n");
-var researchDriverNote = [
-  "RESEARCH \u2014 ADOPT BEFORE BUILD. A research{query} tool is provisioned for this run. Before",
-  "authoring a from-scratch build, spend one turn researching whether an EXISTING external MCP",
-  "server already provides the missing capability \u2014 registries and vendor docs list maintained",
-  "servers for most common gaps (web search, fetch, GitHub, filesystems, databases).",
-  "- If a maintained server fits, ADOPT it: report in your final reflection its endpoint or",
-  "  launch command and the API key it needs BY NAME (e.g. EXA_API_KEY) \u2014 never a key value \u2014",
-  "  so the dispatch can emit a connection candidate with provisioned secrets. Adopting a fit",
-  "  server beats rebuilding it: less code to verify, maintained upstream, same measured gate.",
-  "- If nothing fits (unmaintained, wrong tool surface, heavier than the gap), build \u2014 and state",
-  "  in one line why adoption lost."
-].join("\n");
-var strategyAuthorMethod = [
-  "Work as a senior researcher, in this order:",
-  "1. DIAGNOSE: read the per-task losses above and name the DOMINANT failure mode in one sentence",
-  "   \u2014 the single mechanism behind the largest share of lost score (e.g. first attempts near-miss",
-  "   and never get corrected; fresh retries discard progress; one persona plateaus).",
-  '2. HYPOTHESIS + PREDICTED LIFT: state "these losses happen because MECHANISM; the composition',
-  '   below interrupts it; I predict roughly +N on this environment at the same budget."',
-  "3. DESIGN TO ISOLATE THE MECHANISM: change ONE coordination mechanism relative to the baselines",
-  "   (carry vs fresh, where the critique lands, a persona split, a tool restriction) so any",
-  "   measured lift is attributable to it. Do not stack three clever ideas \u2014 a tangled win teaches",
-  "   nothing and a tangled loss cannot be debugged.",
-  "4. DECOMPOSE THE BUDGET: plan how the shots divide across explore / attempt / critique / repair",
-  "   before writing code, and spend the whole budget \u2014 an early stop on a mid score is a loss.",
-  "5. GENERALIZE: the strategy runs on unseen tasks from this environment. Read tools via",
-  "   listTools(handle), never hardcode task specifics from the losses shown.",
-  "6. PREDICT, THEN REFLECT: put the hypothesis, the mechanism, and the predicted lift in a",
-  "   comment at the top of the module \u2014 the holdout verdict will be read against it."
-].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/strategy.ts
-import { createChatClient, estimateCost, isModelPriced } from "@tangle-network/agent-eval";
-var taskNudge = "Use the available tools to bring the artifact to the required final state. Address EVERY distinct change the request implies. After each tool result, check what remains and continue. Re-read the values you set to confirm they took. Reply DONE only once every required change is made and verified.";
-async function runShot(surface, _task, handle, tools, messages, opts, modelOverride) {
-  let toolErrors = 0;
-  const execute = async (name, args) => {
-    try {
-      const out = await surface.call(handle, name, args);
-      if (out.startsWith("ERROR:")) toolErrors += 1;
-      return out;
-    } catch (e) {
-      toolErrors += 1;
-      return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
-    }
-  };
-  const r = await routerToolLoop(
-    {
-      routerBaseUrl: opts.routerBaseUrl,
-      routerKey: opts.routerKey,
-      model: modelOverride ?? opts.model,
-      ...opts.complete ? { complete: opts.complete } : {}
-    },
-    "",
-    "",
-    tools,
-    execute,
-    {
-      maxTurns: opts.innerTurns ?? 4,
-      temperature: opts.temperature ?? 0.7,
-      initialMessages: messages,
-      ...opts.maxTokens ? { maxTokens: opts.maxTokens } : {}
-    }
-  );
-  return {
-    messages: r.messages,
-    completions: r.turns,
-    toolCalls: r.toolCalls,
-    toolErrors,
-    tokens: r.usage
-  };
-}
-function compactTrajectory(messages) {
-  return messages.filter((m) => m.role === "assistant" || m.role === "tool").map((m) => {
-    if (m.role === "tool") return `RESULT ${String(m.content).slice(0, 280)}`;
-    const calls = m.tool_calls?.map((c) => `${c.function.name}(${c.function.arguments})`).join(", ");
-    return calls ? `CALL ${calls}` : `SAY ${String(m.content).slice(0, 200)}`;
-  }).join("\n").slice(0, 7e3);
-}
-function analystChat(opts, defaultModel) {
-  if (!opts.complete) {
-    return createChatClient({
-      transport: "router",
-      apiKey: opts.routerKey,
-      baseUrl: opts.routerBaseUrl,
-      defaultModel
-    });
-  }
-  const complete = opts.complete;
-  return createChatClient({
-    transport: "mock",
-    defaultModel,
-    handler: async (req) => {
-      const raw = await complete({
-        model: req.model ?? defaultModel,
-        messages: req.messages,
-        ...req.temperature !== void 0 ? { temperature: req.temperature } : {},
-        ...req.maxTokens !== void 0 ? { max_tokens: req.maxTokens } : {}
-      });
-      const content = raw.choices?.[0]?.message?.content ?? "";
-      const promptTokens = raw.usage?.prompt_tokens ?? 0;
-      const completionTokens = raw.usage?.completion_tokens ?? 0;
-      return {
-        content,
-        usage: {
-          promptTokens,
-          completionTokens,
-          totalTokens: promptTokens + completionTokens
-        },
-        costUsd: null,
-        model: req.model ?? defaultModel,
-        durationMs: 0,
-        finishReason: raw.choices?.[0]?.finish_reason ?? null,
-        contentEmpty: content.trim().length === 0,
-        raw
-      };
-    }
-  });
-}
-async function consultAnalyst(task, messages, instruction, opts) {
-  const trajectory = compactTrajectory(messages);
-  const analystModel = opts.analystModel ?? opts.model;
-  const chat = analystChat(opts, analystModel);
-  const consultMessages = trajectory ? [
-    { role: "system", content: instruction },
-    {
-      role: "user",
-      content: `TASK: ${task.userPrompt.slice(0, 1500)}
-
-TRAJECTORY:
-${trajectory}`
-    }
-  ] : [
-    {
-      role: "user",
-      content: `${instruction}
-
-TASK:
-${task.userPrompt.slice(0, 1500)}`
-    }
-  ];
-  const res = await chat.chat({
-    model: analystModel,
-    temperature: 0.2,
-    maxTokens: 1024,
-    messages: consultMessages
-  });
-  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 = analystChat(opts, 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 };
-}
-async function renderCorpusReadback(opts) {
-  if (!opts.corpus || !opts.corpusReadback) return "";
-  const maxFacts = opts.corpusReadback.maxFacts ?? 3;
-  if (!Number.isInteger(maxFacts) || maxFacts < 0) {
-    throw new Error(`corpusReadback.maxFacts must be a non-negative integer, got ${maxFacts}`);
-  }
-  if (maxFacts === 0) return "";
-  const tags = [
-    ...opts.corpusTags ?? [],
-    ...opts.corpusReadback.tags ?? [],
-    ...opts.corpusReadback.includeOperatorFacts ? [] : ["audience:agent"]
-  ];
-  const facts = await opts.corpus.query({
-    ...tags.length > 0 ? { tags } : {},
-    minConfidence: opts.corpusReadback.minConfidence ?? 0.7,
-    limit: maxFacts
-  });
-  if (facts.length === 0) return "";
-  const rendered = facts.map(
-    (fact) => fact.rationale ? `- ${fact.claim} (${fact.rationale})` : `- ${fact.claim}`
-  );
-  return `Relevant learned facts from prior attempts:
-${rendered.join("\n")}`;
-}
-function shotExecutor(surface, opts) {
-  let artifact;
-  return {
-    runtime: "agentic-shot",
-    async execute(task) {
-      const t = task;
-      const own = !t.handle;
-      const handle = t.handle ?? await surface.open(t.task);
-      try {
-        const allTools = await surface.tools(t.task, handle);
-        let tools = allTools;
-        if (t.tools) {
-          const known = new Set(allTools.map((tool) => tool.function.name));
-          const unknown = t.tools.filter((name) => !known.has(name));
-          if (unknown.length > 0) {
-            throw new Error(
-              `shot tools: unknown tool name(s) ${unknown.join(", ")} \u2014 domain offers: ${[...known].join(", ")}`
-            );
-          }
-          const want = new Set(t.tools);
-          tools = allTools.filter((tool) => want.has(tool.function.name));
-        }
-        const messages = t.messages?.length ? t.messages : [
-          { role: "system", content: t.persona?.systemPrompt ?? t.task.systemPrompt },
-          { role: "user", content: `${t.task.userPrompt}
-
-${taskNudge}` }
-        ];
-        if (t.messages?.length && t.persona?.systemPrompt) {
-          messages.push({
-            role: "user",
-            content: `[hand-off] You are now acting as: ${t.persona.systemPrompt}`
-          });
-        }
-        if (t.steer) messages.push({ role: "user", content: t.steer });
-        const shot = await runShot(surface, t.task, handle, tools, messages, opts, t.persona?.model);
-        const s = await surface.score(t.task, handle);
-        const score = s.total > 0 ? s.passes / s.total : 0;
-        const out = {
-          messages: shot.messages,
-          score,
-          passes: s.passes,
-          total: s.total,
-          completions: shot.completions,
-          toolErrors: shot.toolErrors
-        };
-        artifact = {
-          outRef: `shot:${handle.id}:${shot.completions}:${s.passes}/${s.total}`,
-          out,
-          verdict: { valid: s.total > 0 && s.passes === s.total, score },
-          // Real usage to the conserved pool: tokens from the router responses; usd only
-          // when the model is in the price table (never a fabricated number).
-          spent: {
-            iterations: shot.completions,
-            tokens: shot.tokens,
-            usd: isModelPriced(opts.model) ? estimateCost(shot.tokens.input, shot.tokens.output, opts.model) : 0,
-            ms: 0
-          }
-        };
-        return artifact;
-      } finally {
-        if (own) await surface.close(handle);
-      }
-    },
-    teardown: () => Promise.resolve({ destroyed: true }),
-    resultArtifact() {
-      if (!artifact) throw new Error("shotExecutor: resultArtifact before execute");
-      return artifact;
-    }
-  };
-}
-function analystExecutor(opts) {
-  let artifact;
-  return {
-    runtime: "agentic-analyst",
-    async execute(task) {
-      const t = task;
-      const { steer, tokens } = t.rawInstruction ? await consultAnalyst(t.task, t.messages, t.rawInstruction, opts) : await analyze(t.task, t.messages, opts);
-      const analystModel = opts.analystModel ?? opts.model;
-      artifact = {
-        outRef: `analyst:${steer.length}`,
-        out: steer,
-        spent: {
-          iterations: 1,
-          tokens,
-          usd: isModelPriced(analystModel) ? estimateCost(tokens.input, tokens.output, analystModel) : 0,
-          ms: 0
-        }
-      };
-      return artifact;
-    },
-    teardown: () => Promise.resolve({ destroyed: true }),
-    resultArtifact() {
-      if (!artifact) throw new Error("analystExecutor: resultArtifact before execute");
-      return artifact;
-    }
-  };
-}
-function agenticRegistry(surface, opts) {
-  const leaves = {
-    register() {
-      throw new Error("agenticRegistry: register unsupported");
-    },
-    resolve(spec) {
-      const role = spec.profile.metadata?.role;
-      const factory = (_s, _ctx) => role === "analyst" ? analystExecutor(opts) : shotExecutor(surface, opts);
-      return { succeeded: true, value: factory };
-    }
-  };
-  return withDriverExecutor(leaves);
-}
-function leaf(name, role) {
-  const agent = {
-    name,
-    executorSpec: { profile: { name, metadata: { role } }, harness: null },
-    act() {
-      throw new Error(`agentic: spawned child "${name}" was run directly (the executor drives it)`);
-    }
-  };
-  return agent;
-}
-async function drainOne(scope) {
-  const s = await scope.next();
-  if (!s) throw new Error("agentic: spawned child never settled");
-  return s;
-}
-var perChild = (innerTurns) => ({
-  maxIterations: innerTurns + 1,
-  maxTokens: 1e6
-});
-function depthStrategy(surface, task, opts, cfg) {
-  const innerTurns = opts.innerTurns ?? 4;
-  let pendingSteer;
-  return {
-    name: "depth",
-    async act(_t, scope) {
-      const handle = await surface.open(task);
-      const progression = [];
-      let messages;
-      let completions = 0;
-      let shots = 0;
-      try {
-        for (shots = 0; shots < cfg.maxShots; shots += 1) {
-          const child = leaf(`shot:${shots}`, "shot");
-          const memorySteer = await renderCorpusReadback(opts);
-          const steer = [shots === 0 ? void 0 : pendingSteer, memorySteer].filter((part) => typeof part === "string" && part.trim().length > 0).join("\n\n");
-          const res = scope.spawn(child, { task, handle, messages, steer }, {
-            budget: perChild(innerTurns),
-            label: `shot:${shots}`
-          });
-          if (!res.ok) break;
-          const settled = await drainOne(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 drainOne(scope);
-          completions += 1;
-          if (aSettled.kind === "down") break;
-          const findings = aSettled.out;
-          if (/^\s*COMPLETE\b/i.test(findings)) break;
-          pendingSteer = `A reviewer flagged unfinished items:
-${findings}
-
-Address each with the tools, verify they took, then continue.`;
-        }
-        const final = await surface.score(task, handle);
-        const score = final.total > 0 ? final.passes / final.total : 0;
-        return {
-          kind: "done",
-          deliverable: {
-            mode: "depth",
-            score,
-            resolved: final.total > 0 && final.passes === final.total,
-            completions,
-            progression,
-            shots: shots + 1
-          }
-        };
-      } finally {
-        await surface.close(handle);
-      }
-    }
-  };
-}
-function breadthStrategy(_surface, task, opts, cfg) {
-  const innerTurns = opts.innerTurns ?? 4;
-  return {
-    name: "breadth",
-    async act(_t, scope) {
-      let opened = 0;
-      for (let k = 0; k < cfg.width; k += 1) {
-        const res = scope.spawn(leaf(`rollout:${k}`, "shot"), { task }, {
-          budget: perChild(innerTurns),
-          label: `rollout:${k}`
-        });
-        if (res.ok) opened += 1;
-      }
-      if (opened === 0) return { kind: "blocked", blockers: ["breadth: pool admitted no rollout"] };
-      let best = -1;
-      let bestResolved = false;
-      let completions = 0;
-      const progression = [];
-      for (let s = await scope.next(); s !== null; s = await scope.next()) {
-        if (s.kind === "down") continue;
-        const out = s.out;
-        completions += out.completions;
-        if (out.score > best) best = out.score;
-        if (out.total > 0 && out.passes === out.total) bestResolved = true;
-        progression.push(best);
-      }
-      if (best < 0) return { kind: "blocked", blockers: ["breadth: every rollout went down"] };
-      return {
-        kind: "done",
-        deliverable: {
-          mode: "breadth",
-          score: best,
-          resolved: bestResolved,
-          completions,
-          progression,
-          shots: opened
-        }
-      };
-    }
-  };
-}
-var sample = {
-  name: "sample",
-  driver: (surface, task, opts, budget) => breadthStrategy(surface, task, opts, { width: budget })
-};
-var refine = {
-  name: "refine",
-  driver: (surface, task, opts, budget) => depthStrategy(surface, task, opts, { maxShots: budget })
-};
-function defineStrategy(name, run) {
-  return {
-    name,
-    driver: (surface, task, opts, budget) => ({
-      name,
-      async act(_t, scope) {
-        let seq = 0;
-        const innerTurns = opts.innerTurns ?? 4;
-        let verifiedBest = 0;
-        let verifiedResolved = false;
-        const openHandles = /* @__PURE__ */ new Set();
-        const ctx = {
-          // Narrowed to open/close — the body gets no raw call()/score() access.
-          surface: {
-            name: surface.name,
-            open: async (t) => {
-              const h = await surface.open(t);
-              openHandles.add(h.id);
-              return h;
-            },
-            close: async (h) => {
-              if (!h || !openHandles.has(h.id)) return;
-              openHandles.delete(h.id);
-              await surface.close(h);
-            }
-          },
-          task,
-          opts,
-          budget,
-          scope,
-          async shot(spec) {
-            const child = leaf(`shot:${seq}`, "shot");
-            seq += 1;
-            const res = scope.spawn(
-              child,
-              {
-                task,
-                handle: spec?.handle,
-                messages: spec?.messages,
-                steer: spec?.steer,
-                persona: spec?.persona,
-                tools: spec?.tools
-              },
-              { budget: perChild(innerTurns), label: child.name }
-            );
-            if (!res.ok) return null;
-            const settled = await drainOne(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 drainOne(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 drainOne(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/structural-rollout.ts
-import { randomBytes } from "crypto";
-var defaultStructuralRolloutPolicy = {
-  k: 5,
-  repairRounds: 2,
-  testgen: 6
-};
-function resolvePolicy(overrides) {
-  const policy = { ...defaultStructuralRolloutPolicy, ...overrides };
-  if (!Number.isInteger(policy.k) || policy.k < 1) {
-    throw new Error(`structuralRollout: policy.k must be an integer >= 1, got ${policy.k}`);
-  }
-  if (!Number.isInteger(policy.repairRounds) || policy.repairRounds < 0) {
-    throw new Error(
-      `structuralRollout: policy.repairRounds must be an integer >= 0, got ${policy.repairRounds}`
-    );
-  }
-  if (!Number.isInteger(policy.testgen) || policy.testgen < 0) {
-    throw new Error(
-      `structuralRollout: policy.testgen must be an integer >= 0, got ${policy.testgen}`
-    );
-  }
-  return policy;
-}
-var authorInstruction = (count, entry) => `Read the task below. Write exactly ${count} single-line assert statements that test the function \`${entry}\`, based ONLY on the behavior the task itself describes. Each assert must be one physical line of the form \`assert ${entry}(...) == expected\` (or a True/False check). Do NOT implement the function. Do NOT copy shown examples verbatim if you can test other cases too. Output ONLY the assert lines inside a single \`\`\`python code block.`;
-function filterAuthoredAsserts(reply, entrySymbol, count) {
-  const fences = [...reply.matchAll(/```(?:python|py)?\s*\n([\s\S]*?)```/gi)].map(
-    (m) => (m[1] ?? "").trim()
-  );
-  const block = fences.length > 0 ? fences.join("\n") : reply;
-  const balanced = (s) => {
-    let d = 0;
-    for (const ch of s) {
-      if (ch === "(" || ch === "[" || ch === "{") d += 1;
-      else if (ch === ")" || ch === "]" || ch === "}") d -= 1;
-      if (d < 0) return false;
-    }
-    return d === 0;
-  };
-  return block.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("assert ") && l.includes(entrySymbol) && balanced(l)).slice(0, count);
-}
-function modelAuthoredChecks(overrides = {}) {
-  return {
-    async generate(_task, ctx) {
-      const count = overrides.count ?? ctx.count;
-      if (count <= 0 || !ctx.entrySymbol) return [];
-      const entry = ctx.entrySymbol;
-      const reply = await ctx.consult(authorInstruction(count, entry));
-      if (!reply) return [];
-      return filterAuthoredAsserts(reply, entry, count).map((code) => ({
-        code,
-        kind: "authored"
-      }));
-    }
-  };
-}
-function officialChecksFromMeta(key = "visibleChecks") {
-  return {
-    async generate(task) {
-      const raw = task.meta?.[key];
-      if (!Array.isArray(raw)) return [];
-      return raw.filter((c) => typeof c === "string" && c.trim().length > 0).map((code) => ({ code, kind: "official" }));
-    }
-  };
-}
-function composeCheckSources(...sources) {
-  return {
-    async generate(task, ctx) {
-      const all = [];
-      for (const source of sources) all.push(...await source.generate(task, ctx));
-      return all;
-    }
-  };
-}
-function resolveEntrySymbol(task) {
-  const meta = task.meta?.entryPoint;
-  if (typeof meta === "string" && meta.trim().length > 0) return meta.trim();
-  const defs = [...task.userPrompt.matchAll(/(?:^|\n)\s*def\s+([A-Za-z_]\w*)\s*\(/g)];
-  const last = defs[defs.length - 1];
-  return last?.[1];
-}
-function buildCheckProgram(candidate, official, authored, nonce) {
-  const officialB64 = Buffer.from(JSON.stringify(official), "utf8").toString("base64");
-  const authoredB64 = Buffer.from(JSON.stringify(authored), "utf8").toString("base64");
-  return `${candidate}
-
-import base64 as _b64, json as _json, sys as _sys
-_official = _json.loads(_b64.b64decode("${officialB64}").decode("utf8"))
-_authored = _json.loads(_b64.b64decode("${authoredB64}").decode("utf8"))
-_lines = []
-def _run(_tests):
-    _att, _fail = 0, 0
-    for _t in _tests:
-        _att += 1
-        try:
-            exec(_t, dict(globals()))
-        except Exception as _e:
-            _fail += 1
-            _lines.append("CHECK FAILED: %s -> %s: %s" % (_t.strip()[:200], type(_e).__name__, str(_e)[:200]))
-    return _att, _fail
-_o_att, _o_fail = _run(_official)
-_a_att, _a_fail = _run(_authored)
-print("SRCK-${nonce} official=%d/%d authored=%d/%d" % (_o_att - _o_fail, _o_att, _a_att - _a_fail, _a_att))
-_sys.stdout.write("\\n".join(_lines)[-1500:])
-_sys.exit(0 if (_o_fail + _a_fail) == 0 and (_o_att + _a_att) > 0 else 1)
-`;
-}
-function sandboxCheckRunner(options = {}) {
-  const python = options.python ?? "python3";
-  const timeoutMs = options.timeoutMs ?? 2e4;
-  return {
-    async run(candidate, checks, ctx) {
-      if (checks.length === 0) {
-        return {
-          passedOfficial: 0,
-          totalOfficial: 0,
-          passedAuthored: 0,
-          totalAuthored: 0,
-          failureOutput: ""
-        };
-      }
-      const box = ctx.box ?? options.box;
-      if (!box) {
-        throw new Error(
-          "sandboxCheckRunner: no execution channel \u2014 bind one via sandboxCheckRunner({ box }) or CheckRunContext.box (ValidationCtx.box / a sandbox instance). Refusing to score without executing: a silent 0 would poison selection."
-        );
-      }
-      const nonce = randomBytes(8).toString("hex");
-      const official = checks.filter((c) => c.kind === "official").map((c) => c.code);
-      const authored = checks.filter((c) => c.kind === "authored").map((c) => c.code);
-      const program = buildCheckProgram(candidate, official, authored, nonce);
-      const b64 = Buffer.from(program, "utf8").toString("base64");
-      const r = await box.exec(`printf '%s' '${b64}' | base64 -d | ${python} -`, { timeoutMs });
-      const summary = new RegExp(
-        `SRCK-${nonce} official=(\\d+)/(\\d+) authored=(\\d+)/(\\d+)`
-      ).exec(r.stdout);
-      if (!summary) {
-        const detail = (r.stderr || r.stdout).slice(-1500) || "no output (crashed or timed out before the checks could run)";
-        return {
-          passedOfficial: 0,
-          totalOfficial: 0,
-          passedAuthored: 0,
-          totalAuthored: 0,
-          failureOutput: detail,
-          crashed: true
-        };
-      }
-      const failureOutput = r.stdout.replace(summary[0], "").slice(-1500).trim();
-      return {
-        passedOfficial: Number(summary[1]),
-        totalOfficial: Number(summary[2]),
-        passedAuthored: Number(summary[3]),
-        totalAuthored: Number(summary[4]),
-        failureOutput
-      };
-    }
-  };
-}
-var frac = (passed, total) => total > 0 ? passed / total : 0;
-function compareCheckOutcomes(a, b) {
-  const aCrashed = a.crashed === true;
-  const bCrashed = b.crashed === true;
-  if (aCrashed !== bCrashed) return aCrashed ? -1 : 1;
-  if (aCrashed) return 0;
-  const official = frac(a.passedOfficial, a.totalOfficial) - frac(b.passedOfficial, b.totalOfficial);
-  if (official !== 0) return official;
-  return frac(a.passedAuthored, a.totalAuthored) - frac(b.passedAuthored, b.totalAuthored);
-}
-function visibleCheckScore(o) {
-  if (o.crashed) return -1;
-  return frac(o.passedOfficial, o.totalOfficial) + 1e-3 * frac(o.passedAuthored, o.totalAuthored);
-}
-function selectBestIndex(outcomes) {
-  let best = 0;
-  for (let i = 1; i < outcomes.length; i += 1) {
-    if (compareCheckOutcomes(outcomes[i], outcomes[best]) > 0) {
-      best = i;
-    }
-  }
-  return best;
-}
-function canDisplace(challenger, incumbent) {
-  if (challenger.crashed === true) return false;
-  if (challenger.passedOfficial < incumbent.passedOfficial) return false;
-  return compareCheckOutcomes(challenger, incumbent) > 0;
-}
-var totalChecks = (o) => o.totalOfficial + o.totalAuthored;
-var passesAllChecks = (o) => o.crashed !== true && totalChecks(o) > 0 && o.passedOfficial === o.totalOfficial && o.passedAuthored === o.totalAuthored;
-function defaultExtractCandidate(messages) {
-  for (let i = messages.length - 1; i >= 0; i -= 1) {
-    const calls = messages[i]?.tool_calls;
-    if (!calls) continue;
-    for (let j = calls.length - 1; j >= 0; j -= 1) {
-      const call = calls[j];
-      if (call?.function?.name !== "submit_answer") continue;
-      try {
-        const args = JSON.parse(call.function.arguments ?? "{}");
-        if (typeof args.answer === "string" && args.answer.trim()) return args.answer.trim();
-      } catch {
-      }
-    }
-  }
-  const contents = [];
-  for (const m of messages) {
-    if (m.role === "assistant" && typeof m.content === "string" && m.content.trim()) {
-      contents.push(m.content);
-    }
-  }
-  const fencesOf = (text) => [...text.matchAll(/```(?:python|py)?\s*\n([\s\S]*?)```/gi)].map((m) => (m[1] ?? "").trim());
-  for (let i = contents.length - 1; i >= 0; i -= 1) {
-    const fences = fencesOf(contents[i]);
-    for (let j = fences.length - 1; j >= 0; j -= 1) {
-      if (/(^|\n)\s*def\s+\w+/.test(fences[j])) return fences[j];
-    }
-  }
-  for (let i = contents.length - 1; i >= 0; i -= 1) {
-    const fences = fencesOf(contents[i]);
-    if (fences.length > 0) return fences[fences.length - 1];
-  }
-  return (contents[contents.length - 1] ?? "").trim();
-}
-var DIVERSE_LENSES = [
-  "Answer directly and decisively from what you already know. State the single best answer without hedging.",
-  "Decompose the question into the sub-facts it depends on. Establish each sub-fact explicitly, then compose them into the answer.",
-  "Reason from first principles. Ignore the most obvious or popular guess; derive the answer from underlying facts and relationships.",
-  "Name the most plausible WRONG answer and the trap that makes it tempting. Rule it out, then commit to the answer that survives."
-];
-function slotLens(slot) {
-  const lens = DIVERSE_LENSES[slot % DIVERSE_LENSES.length];
-  const tag = slot < DIVERSE_LENSES.length ? "" : ` (variant ${Math.floor(slot / DIVERSE_LENSES.length) + 1})`;
-  return `${lens}${tag}`;
-}
-function repairSteer(outcome) {
-  return [
-    "Your latest solution failed some of the task-visible checks.",
-    "Result of running the visible checks against it:",
-    "```",
-    outcome.failureOutput.trim() || "(the code crashed before the checks could run)",
-    "```",
-    "Fix the solution so the visible checks pass. Provide the COMPLETE corrected solution the",
-    "same way you provided the original (same tool or format) \u2014 not a fragment or a diff."
-  ].join("\n");
-}
-function describeOutcome(label, o) {
-  if (o.crashed) return `${label}: crashed before the checks could run`;
-  return `${label}: official ${o.passedOfficial}/${o.totalOfficial}, authored ${o.passedAuthored}/${o.totalAuthored}`;
-}
-function structuralRollout(config = {}) {
-  const policy = resolvePolicy(config.policy);
-  const checkSource = config.checkSource ?? composeCheckSources(officialChecksFromMeta(), modelAuthoredChecks());
-  const checkRunner = config.checkRunner ?? sandboxCheckRunner();
-  const extract = config.extractCandidate ?? defaultExtractCandidate;
-  const inner = defineStrategy(
-    "structuralRollout",
-    async (ctx) => {
-      const { task, shot } = ctx;
-      const progression = [];
-      const receipts = [];
-      let completions = 0;
-      let shots = 0;
-      const consult = async (instruction) => {
-        const reply = await ctx.consult([], instruction);
-        completions += 1;
-        return reply;
-      };
-      const entrySymbol = resolveEntrySymbol(task);
-      const checks = await checkSource.generate(task, {
-        count: policy.testgen,
-        ...entrySymbol ? { entrySymbol } : {},
-        consult
-      });
-      const officialChecks = checks.filter((c) => c.kind === "official").length;
-      const authoredChecks = checks.length - officialChecks;
-      const runCtx = { task, ...config.box ? { box: config.box } : {} };
-      const candidates = [];
-      for (let i = 0; i < policy.k; i += 1) {
-        const out = await shot(policy.diverse ? { steer: slotLens(i) } : void 0);
-        if (!out) break;
-        shots += 1;
-        completions += out.completions;
-        progression.push(out.score);
-        const outcome = await checkRunner.run(extract(out.messages), checks, runCtx);
-        candidates.push({
-          index: candidates.length,
-          messages: out.messages,
-          outcome,
-          shotScore: out.score,
-          shotResolved: out.total > 0 && out.passes === out.total
-        });
-      }
-      if (candidates.length === 0) {
-        return {
-          score: 0,
-          resolved: false,
-          completions,
-          progression,
-          shots,
-          selection: receipts,
-          repairStop: "no-candidates",
-          officialChecks,
-          authoredChecks
-        };
-      }
-      let best = candidates[selectBestIndex(candidates.map((c) => c.outcome))];
-      for (const c of candidates) {
-        receipts.push({
-          candidateIndex: c.index,
-          selected: false,
-          score: visibleCheckScore(c.outcome),
-          reason: describeOutcome("sample", c.outcome),
-          selector: "driver"
-        });
-      }
-      let seq = candidates.length;
-      let repairStop = "already-passing";
-      if (!passesAllChecks(best.outcome)) {
-        if (best.outcome.crashed !== true && totalChecks(best.outcome) === 0) {
-          repairStop = "no-signal";
-        } else {
-          repairStop = "rounds-exhausted";
-          for (let r = 0; r < policy.repairRounds; r += 1) {
-            const out = await shot({ messages: best.messages, steer: repairSteer(best.outcome) });
-            if (!out) break;
-            shots += 1;
-            completions += out.completions;
-            progression.push(out.score);
-            const outcome = await checkRunner.run(extract(out.messages), checks, runCtx);
-            const displaced = canDisplace(outcome, best.outcome);
-            const label = displaced ? "repair (displaced the incumbent)" : outcome.crashed !== true && outcome.passedOfficial < best.outcome.passedOfficial ? "repair (held out: passes fewer official checks than the incumbent)" : "repair (held out: no improvement)";
-            receipts.push({
-              candidateIndex: seq,
-              selected: false,
-              score: visibleCheckScore(outcome),
-              reason: describeOutcome(label, outcome),
-              selector: "driver"
-            });
-            if (displaced) {
-              best = {
-                index: seq,
-                messages: out.messages,
-                outcome,
-                shotScore: out.score,
-                shotResolved: out.total > 0 && out.passes === out.total
-              };
-            }
-            seq += 1;
-            if (passesAllChecks(best.outcome)) {
-              repairStop = "repaired-pass";
-              break;
-            }
-          }
-        }
-      }
-      const winner = receipts.find((r) => r.candidateIndex === best.index);
-      if (winner) winner.selected = true;
-      return {
-        score: best.shotScore,
-        resolved: best.shotResolved,
-        completions,
-        progression,
-        shots,
-        selection: receipts,
-        repairStop,
-        officialChecks,
-        authoredChecks
-      };
-    }
-  );
-  if (policy.temperature === void 0) return inner;
-  return {
-    name: inner.name,
-    driver: (surface, task, opts, budget) => inner.driver(surface, task, { ...opts, temperature: policy.temperature }, budget)
-  };
-}
-
-export {
-  optimizerMethod,
-  buildDriverSystem,
-  researchDriverNote,
-  strategyAuthorMethod,
-  defaultAnalystInstruction,
-  observe,
-  renderReport,
-  depthStrategy,
-  breadthStrategy,
-  sample,
-  refine,
-  defineStrategy,
-  adaptiveRefine,
-  sampleThenRefine,
-  runAgentic,
-  defaultStructuralRolloutPolicy,
-  filterAuthoredAsserts,
-  modelAuthoredChecks,
-  officialChecksFromMeta,
-  composeCheckSources,
-  resolveEntrySymbol,
-  sandboxCheckRunner,
-  compareCheckOutcomes,
-  visibleCheckScore,
-  selectBestIndex,
-  canDisplace,
-  defaultExtractCandidate,
-  structuralRollout
-};
-//# sourceMappingURL=chunk-YJZA2BIK.js.map