@tangle-network/agent-runtime 0.82.0 → 0.84.0

package/dist/{chunk-JYURIKPF.js → chunk-UJW6EVNY.js}

@@ -15,7 +15,7 @@ import {
   settledToIteration,
   supervise,
   withDriverExecutor
-} from "./chunk-CO2KBPRE.js";
+} from "./chunk-XN5TIJGP.js";
 import {
   addTokenUsage,
   isAbortError,
@@ -23,12 +23,12 @@ import {
   sleep,
   stringifySafe,
   zeroTokenUsage
-} from "./chunk-H7IBHAFT.js";
+} from "./chunk-BZF3KQ6G.js";
 import {
   AnalystError,
   PlannerError,
   ValidationError
-} from "./chunk-NBV35BR6.js";
+} from "./chunk-YEJR7IXO.js";
 
 // src/runtime/index.ts
 import { computeFindingId, makeFinding as makeFinding2 } from "@tangle-network/agent-eval";
@@ -604,6 +604,480 @@ function deterministicCompletion(check) {
   };
 }
 
+// src/runtime/define-leaderboard.ts
+import { execFileSync } from "child_process";
+import { mkdirSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import {
+  CODING_HARNESSES,
+  expandProfileAxes,
+  harnessAxisOf
+} from "@tangle-network/agent-eval";
+import {
+  runProfileMatrix
+} from "@tangle-network/agent-eval/campaign";
+import { collectAgentResponseText } from "@tangle-network/sandbox";
+
+// src/runtime/report-usage.ts
+function reportLoopUsage(cost, result, source = "loop") {
+  cost.observe(result.costUsd, source);
+  cost.observeTokens(result.tokenUsage);
+}
+
+// src/runtime/loop-dispatch.ts
+function campaignTraceToLoopEmitter(trace) {
+  return {
+    emit(event) {
+      trace.span(event.kind, { runId: event.runId, timestamp: event.timestamp, ...event.payload }).end();
+    }
+  };
+}
+async function runLoopForCell(opts, scenario, profile, ctx) {
+  const loopOptions = opts.toLoopOptions(scenario, profile);
+  return runLoopWithCampaignContext(opts, loopOptions, ctx);
+}
+async function runLoopWithCampaignContext(opts, loopOptions, ctx) {
+  const result = await runLoop({
+    ...loopOptions,
+    ctx: {
+      sandboxClient: opts.sandboxClient,
+      signal: ctx.signal,
+      traceEmitter: opts.forwardTrace === false ? void 0 : campaignTraceToLoopEmitter(ctx.trace)
+    }
+  });
+  reportLoopUsage(ctx.cost, result, opts.costSource ?? "loop");
+  const toArtifact = opts.toArtifact ?? ((r) => r.winner?.output);
+  return toArtifact(result);
+}
+function loopCampaignDispatch(opts) {
+  return (scenario, ctx) => runLoopWithCampaignContext(opts, opts.toLoopOptions(scenario), ctx);
+}
+function loopDispatch(opts) {
+  return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
+}
+
+// src/runtime/inline-sandbox-client.ts
+function isAsyncIterable(v) {
+  return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
+}
+async function settle(exec, task, signal) {
+  const r = exec.execute(task, signal);
+  if (isAsyncIterable(r)) {
+    for await (const _ of r) {
+    }
+    return exec.resultArtifact();
+  }
+  return r;
+}
+function inlineSandboxClient(factory) {
+  let seq = 0;
+  return {
+    async create(options) {
+      const id = `inline-${seq++}`;
+      const createOptions = options;
+      return {
+        id,
+        async *streamPrompt(message) {
+          const controller = new AbortController();
+          const spec = { profile: { name: id }, harness: null };
+          const exec = factory(spec, { signal: controller.signal, seams: { createOptions } });
+          try {
+            const artifact = await settle(exec, message, controller.signal);
+            const out = artifact.out;
+            const tokensIn = artifact.spent.tokens.input;
+            const tokensOut = artifact.spent.tokens.output;
+            const costUsd = artifact.spent.usd;
+            if (tokensIn || tokensOut || costUsd) {
+              yield {
+                type: "llm_call",
+                data: { tokensIn, tokensOut, costUsd }
+              };
+            }
+            yield {
+              type: "result",
+              data: {
+                finalText: out?.content ?? "",
+                tokenUsage: {
+                  inputTokens: tokensIn,
+                  outputTokens: tokensOut
+                },
+                costUsd
+              }
+            };
+          } finally {
+            await exec.teardown("brutalKill").catch(() => {
+            });
+          }
+        },
+        async delete() {
+        }
+      };
+    }
+  };
+}
+
+// src/runtime/resolve-sandbox-client.ts
+function resolveSandboxClient(opts) {
+  switch (opts.backend) {
+    case "sandbox": {
+      if (!opts.sandboxClient) {
+        throw new Error("resolveSandboxClient: backend 'sandbox' requires opts.sandboxClient");
+      }
+      return opts.sandboxClient;
+    }
+    case "bridge": {
+      const bridge = opts.bridge;
+      if (!bridge?.bearer || !bridge.model) {
+        throw new Error(
+          "resolveSandboxClient: backend 'bridge' requires bridge.bearer and bridge.model"
+        );
+      }
+      return inlineSandboxClient(
+        createExecutor({
+          backend: "bridge",
+          bridgeUrl: bridge.url ?? "http://127.0.0.1:3355",
+          bridgeBearer: bridge.bearer,
+          model: bridge.model,
+          timeoutMs: bridge.timeoutMs
+        })
+      );
+    }
+    case "router": {
+      const router = opts.router;
+      if (!router?.baseUrl || !router.key || !router.model) {
+        throw new Error(
+          "resolveSandboxClient: backend 'router' requires router.baseUrl, router.key and router.model"
+        );
+      }
+      return inlineSandboxClient(
+        createExecutor({
+          backend: "router",
+          routerBaseUrl: router.baseUrl,
+          routerKey: router.key,
+          model: router.model
+        })
+      );
+    }
+  }
+}
+
+// src/runtime/steering-drivers.ts
+function decideUntilValidOrCapped(history, maxIterations) {
+  if (history.some((it) => it.verdict?.valid)) return "pick-winner";
+  return history.length < maxIterations ? "refine" : "fail";
+}
+function naiveDriver(options) {
+  const { continuation, applyContinuation, maxIterations, name = "naive" } = options;
+  return {
+    name,
+    plan(task, history) {
+      if (history.length === 0) return Promise.resolve([task]);
+      const last = history[history.length - 1];
+      if (last?.verdict?.valid) return Promise.resolve([]);
+      if (history.length >= maxIterations) return Promise.resolve([]);
+      return Promise.resolve([applyContinuation(task, continuation)]);
+    },
+    decide(history) {
+      return decideUntilValidOrCapped(history, maxIterations);
+    },
+    // Pure refine topology (one task per round) — render the steer move.
+    describePlan() {
+      return { kind: "refine", rationale: "naive fixed continuation (no grade signal)" };
+    }
+  };
+}
+function dumbDriver(options) {
+  const { onPass, onFail, applyContinuation, maxIterations, name = "dumb" } = options;
+  return {
+    name,
+    plan(task, history) {
+      if (history.length === 0) return Promise.resolve([task]);
+      const last = history[history.length - 1];
+      const passed = last?.verdict?.valid === true;
+      if (passed) return Promise.resolve([]);
+      if (history.length >= maxIterations) return Promise.resolve([]);
+      const continuation = passed ? onPass : onFail;
+      return Promise.resolve([applyContinuation(task, continuation)]);
+    },
+    decide(history) {
+      return decideUntilValidOrCapped(history, maxIterations);
+    },
+    describePlan() {
+      return { kind: "refine", rationale: "dumb pass/fail-only continuation (no grader findings)" };
+    }
+  };
+}
+
+// src/runtime/define-leaderboard.ts
+function argOf(argv, name) {
+  const i = argv.indexOf(`--${name}`);
+  if (i >= 0 && i + 1 < argv.length) return argv[i + 1];
+  return void 0;
+}
+function splitList(v) {
+  if (v === void 0) return void 0;
+  const parts = v.split(",").map((s) => s.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function withSnapshot(model, snapshot) {
+  return model.includes("@") ? model : `${model}@${snapshot}`;
+}
+function bareModel(model) {
+  return model.split("@")[0] ?? model;
+}
+function gitSha() {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], { encoding: "utf8" }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function normalizeScore(s) {
+  return typeof s === "number" ? { composite: s } : s;
+}
+function defineLeaderboard(spec) {
+  const caseId = (c) => {
+    const id = spec.caseId ? spec.caseId(c) : c.id;
+    if (typeof id !== "string" || id.length === 0) {
+      throw new Error(
+        `defineLeaderboard(${spec.name}): every case needs a stable string id \u2014 give cases an \`id\` property or supply spec.caseId`
+      );
+    }
+    return id;
+  };
+  const selectCases = (ids) => {
+    if (!ids) return spec.cases;
+    const byId = new Map(spec.cases.map((c) => [caseId(c), c]));
+    return ids.map((id) => {
+      const c = byId.get(id);
+      if (c === void 0) {
+        throw new Error(
+          `defineLeaderboard(${spec.name}): unknown case "${id}" (have: ${[...byId.keys()].join(", ")})`
+        );
+      }
+      return c;
+    });
+  };
+  const scoreJudge = {
+    name: `${spec.name}-score`,
+    dimensions: [{ key: "composite", description: `${spec.name} case score` }],
+    score({ artifact, scenario }) {
+      const s = normalizeScore(spec.score(artifact, scenario.case));
+      return {
+        composite: s.composite,
+        dimensions: { composite: s.composite, ...s.dimensions },
+        notes: s.notes ?? ""
+      };
+    }
+  };
+  async function run(argv = process.argv.slice(2)) {
+    const args = {};
+    for (const name of [
+      "backend",
+      "harnesses",
+      "models",
+      "cases",
+      "shots",
+      "reps",
+      "model-snapshot",
+      "run-dir",
+      "export-dir"
+    ]) {
+      args[name] = argOf(argv, name);
+    }
+    for (const [name, flag] of Object.entries(spec.flags ?? {})) {
+      args[name] = argOf(argv, name) ?? flag.default;
+    }
+    const backendName = args.backend ?? "sandbox";
+    const shots = Number(args.shots ?? spec.shots ?? 1);
+    const reps = Number(args.reps ?? spec.reps ?? 1);
+    const snapshot = args["model-snapshot"] ?? "leaderboard";
+    const runDir = args["run-dir"] ?? join(tmpdir(), `leaderboard-${spec.name}-${Date.now()}-${process.pid}`);
+    const exportDir = args["export-dir"] ?? join(runDir, "export");
+    mkdirSync(runDir, { recursive: true });
+    const cases = selectCases(splitList(args.cases));
+    if (cases.length === 0) throw new Error(`defineLeaderboard(${spec.name}): no cases to run`);
+    const scenarios = cases.map((c) => ({
+      id: caseId(c),
+      kind: spec.name,
+      case: c
+    }));
+    const harnesses = splitList(args.harnesses) ?? spec.axis?.harnesses ?? CODING_HARNESSES;
+    const rawModels = splitList(args.models) ?? spec.axis?.models ?? (spec.baseProfile?.model?.default !== void 0 ? [spec.baseProfile.model.default] : void 0);
+    if (!rawModels || rawModels.length === 0) {
+      throw new Error(
+        `defineLeaderboard(${spec.name}): no models \u2014 pass --models, set spec.axis.models, or give spec.baseProfile a model.default`
+      );
+    }
+    const models = rawModels.map((m) => withSnapshot(m, snapshot));
+    const base = spec.baseProfile ?? { name: spec.name, model: { default: bareModel(models[0] ?? "") } };
+    const profiles = expandProfileAxes({ base, harnesses, models });
+    const ctx = {
+      name: spec.name,
+      backend: backendName,
+      runDir,
+      exportDir,
+      args,
+      harnesses,
+      models,
+      caseIds: scenarios.map((s) => s.id),
+      shots,
+      reps
+    };
+    const backends = {
+      sandbox: () => {
+        throw new Error(
+          `defineLeaderboard(${spec.name}): the 'sandbox' backend needs your product's real SandboxClient \u2014 supply spec.backends.sandbox (e.g. () => new SandboxClient({ apiKey, baseUrl }))`
+        );
+      },
+      "cli-bridge": () => {
+        const bearer = process.env.BRIDGE_BEARER ?? process.env.CLI_BRIDGE_BEARER;
+        if (!bearer) {
+          throw new Error(
+            `defineLeaderboard(${spec.name}): backend 'cli-bridge' needs BRIDGE_BEARER or CLI_BRIDGE_BEARER set`
+          );
+        }
+        return resolveSandboxClient({
+          backend: "bridge",
+          bridge: {
+            url: process.env.CLI_BRIDGE_URL,
+            bearer,
+            model: bareModel(models[0] ?? ""),
+            timeoutMs: 9e5
+          }
+        });
+      },
+      ...spec.backends
+    };
+    const makeClient = backends[backendName];
+    if (!makeClient) {
+      throw new Error(
+        `defineLeaderboard(${spec.name}): unknown backend "${backendName}" (have: ${Object.keys(backends).join(", ")})`
+      );
+    }
+    const sandboxClient = makeClient();
+    const promptById = /* @__PURE__ */ new Map();
+    for (const s of scenarios) promptById.set(s.id, await spec.prompt(s.case));
+    const promptOf = (s) => {
+      const p = promptById.get(s.id);
+      if (p === void 0)
+        throw new Error(`defineLeaderboard(${spec.name}): no prompt for case "${s.id}"`);
+      return p;
+    };
+    let shotNonce = 0;
+    const dispatch = spec.dispatch ?? loopDispatch({
+      sandboxClient,
+      toLoopOptions: (scenario, profile) => {
+        const axis = harnessAxisOf(profile);
+        const modelId = bareModel(axis?.model ?? models[0] ?? "");
+        return {
+          // naiveDriver = the no-signal retry floor: re-run the same case as
+          // an independent attempt until one scores (>0) or the shot cap.
+          driver: naiveDriver({
+            continuation: "",
+            applyContinuation: (task) => task,
+            maxIterations: shots
+          }),
+          agentRun: {
+            profile,
+            taskToPrompt: (s) => `${promptOf(s)}
+
+<!-- independent-attempt:${shotNonce++} -->`,
+            ...axis ? {
+              sandboxOverrides: {
+                backend: {
+                  type: axis.harness,
+                  model: { ...spec.modelBackend, model: modelId }
+                }
+              }
+            } : {}
+          },
+          output: {
+            parse: (events) => {
+              spec.onCellEvents?.(events, scenario.case);
+              return spec.parseOutput ? spec.parseOutput(events, scenario.case) : collectAgentResponseText(events) ?? "";
+            }
+          },
+          validator: {
+            validate: async (output) => {
+              const s = normalizeScore(spec.score(output, scenario.case));
+              return { valid: s.composite > 0, score: s.composite };
+            }
+          },
+          task: scenario,
+          maxIterations: shots
+        };
+      }
+    });
+    await spec.setup?.(ctx);
+    try {
+      const result = await runProfileMatrix({
+        profiles,
+        scenarios,
+        dispatch,
+        judges: spec.judges ?? [scoreJudge],
+        runDir,
+        commitSha: gitSha(),
+        reps,
+        ...spec.matrix
+      });
+      if (spec.export) {
+        await spec.export(result, ctx);
+      } else {
+        mkdirSync(exportDir, { recursive: true });
+        writeFileSync(join(runDir, "matrix-result.json"), `${JSON.stringify(result, null, 2)}
+`);
+        const table = renderLeaderboardMarkdown(
+          leaderboard(result.records, { title: spec.name, meta: { backend: backendName } })
+        );
+        writeFileSync(join(exportDir, "leaderboard.md"), table);
+        console.log(table);
+      }
+      return result;
+    } finally {
+      await spec.teardown?.(ctx);
+    }
+  }
+  function toBenchmarkAdapter() {
+    return {
+      name: spec.name,
+      async preflight() {
+        const seen = /* @__PURE__ */ new Set();
+        for (const c of spec.cases) {
+          const id = caseId(c);
+          if (seen.has(id)) {
+            throw new Error(`defineLeaderboard(${spec.name}): duplicate case id "${id}"`);
+          }
+          seen.add(id);
+        }
+      },
+      async loadTasks(opts) {
+        const selected = selectCases(opts?.ids);
+        const limited = opts?.limit !== void 0 ? selected.slice(0, opts.limit) : selected;
+        return Promise.all(
+          limited.map(async (c) => ({
+            id: caseId(c),
+            prompt: await spec.prompt(c),
+            metadata: { case: c }
+          }))
+        );
+      },
+      async judge(task, artifact) {
+        const [c] = selectCases([task.id]);
+        if (c === void 0)
+          throw new Error(`defineLeaderboard(${spec.name}): no case "${task.id}"`);
+        const s = normalizeScore(spec.score(artifact, c));
+        return { resolved: s.composite > 0, score: s.composite, detail: s.notes };
+      },
+      async goldArtifact() {
+        return void 0;
+      }
+    };
+  }
+  return { run, toBenchmarkAdapter };
+}
+
 // src/runtime/observe.ts
 import { makeFinding } from "@tangle-network/agent-eval";
 var observerId = "observe/trace";
@@ -815,9 +1289,9 @@ async function harvestCorpus(opts) {
 // src/runtime/in-process-sandbox-client.ts
 import { mkdtempSync, rmSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { dirname, join } from "path";
-function isAsyncIterable(v) {
+import { tmpdir as tmpdir2 } from "os";
+import { dirname, join as join2 } from "path";
+function isAsyncIterable2(v) {
   return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
 }
 function inProcessSandboxClient(options) {
@@ -827,15 +1301,15 @@ function inProcessSandboxClient(options) {
     async create(_options) {
       const current = seq++;
       const id = typeof idOption === "function" ? idOption(current) : idOption ?? `in-process-${current}`;
-      const boxWorkdir = workdirPrefix !== void 0 ? mkdtempSync(join(tmpdir(), `${workdirPrefix}-`)) : void 0;
+      const boxWorkdir = workdirPrefix !== void 0 ? mkdtempSync(join2(tmpdir2(), `${workdirPrefix}-`)) : void 0;
       let round = 0;
       const fsMembers = boxWorkdir !== void 0 ? {
         fs: {
           async read(path) {
-            return readFile(join(boxWorkdir, path), "utf8");
+            return readFile(join2(boxWorkdir, path), "utf8");
           },
           async write(path, content) {
-            const abs = join(boxWorkdir, path);
+            const abs = join2(boxWorkdir, path);
             await mkdir(dirname(abs), { recursive: true });
             await writeFile(abs, content, "utf8");
           }
@@ -868,7 +1342,7 @@ function inProcessSandboxClient(options) {
           const ctx = { round, workdir: boxWorkdir, signal };
           round += 1;
           const produced = await onPrompt(prompt, ctx);
-          if (isAsyncIterable(produced)) {
+          if (isAsyncIterable2(produced)) {
             for await (const ev of produced) yield ev;
           } else {
             for (const ev of produced) yield ev;
@@ -884,104 +1358,6 @@ function inProcessSandboxClient(options) {
   };
 }
 
-// src/runtime/inline-sandbox-client.ts
-function isAsyncIterable2(v) {
-  return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
-}
-async function settle(exec, task, signal) {
-  const r = exec.execute(task, signal);
-  if (isAsyncIterable2(r)) {
-    for await (const _ of r) {
-    }
-    return exec.resultArtifact();
-  }
-  return r;
-}
-function inlineSandboxClient(factory) {
-  let seq = 0;
-  return {
-    async create(options) {
-      const id = `inline-${seq++}`;
-      const createOptions = options;
-      return {
-        id,
-        async *streamPrompt(message) {
-          const controller = new AbortController();
-          const spec = { profile: { name: id }, harness: null };
-          const exec = factory(spec, { signal: controller.signal, seams: { createOptions } });
-          try {
-            const artifact = await settle(exec, message, controller.signal);
-            const out = artifact.out;
-            const tokensIn = artifact.spent.tokens.input;
-            const tokensOut = artifact.spent.tokens.output;
-            const costUsd = artifact.spent.usd;
-            if (tokensIn || tokensOut || costUsd) {
-              yield {
-                type: "llm_call",
-                data: { tokensIn, tokensOut, costUsd }
-              };
-            }
-            yield {
-              type: "result",
-              data: {
-                finalText: out?.content ?? "",
-                tokenUsage: {
-                  inputTokens: tokensIn,
-                  outputTokens: tokensOut
-                },
-                costUsd
-              }
-            };
-          } finally {
-            await exec.teardown("brutalKill").catch(() => {
-            });
-          }
-        },
-        async delete() {
-        }
-      };
-    }
-  };
-}
-
-// src/runtime/report-usage.ts
-function reportLoopUsage(cost, result, source = "loop") {
-  cost.observe(result.costUsd, source);
-  cost.observeTokens(result.tokenUsage);
-}
-
-// src/runtime/loop-dispatch.ts
-function campaignTraceToLoopEmitter(trace) {
-  return {
-    emit(event) {
-      trace.span(event.kind, { runId: event.runId, timestamp: event.timestamp, ...event.payload }).end();
-    }
-  };
-}
-async function runLoopForCell(opts, scenario, profile, ctx) {
-  const loopOptions = opts.toLoopOptions(scenario, profile);
-  return runLoopWithCampaignContext(opts, loopOptions, ctx);
-}
-async function runLoopWithCampaignContext(opts, loopOptions, ctx) {
-  const result = await runLoop({
-    ...loopOptions,
-    ctx: {
-      sandboxClient: opts.sandboxClient,
-      signal: ctx.signal,
-      traceEmitter: opts.forwardTrace === false ? void 0 : campaignTraceToLoopEmitter(ctx.trace)
-    }
-  });
-  reportLoopUsage(ctx.cost, result, opts.costSource ?? "loop");
-  const toArtifact = opts.toArtifact ?? ((r) => r.winner?.output);
-  return toArtifact(result);
-}
-function loopCampaignDispatch(opts) {
-  return (scenario, ctx) => runLoopWithCampaignContext(opts, opts.toLoopOptions(scenario), ctx);
-}
-function loopDispatch(opts) {
-  return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
-}
-
 // src/runtime/mcp-environment.ts
 async function rpc(endpoint, body) {
   let lastErr;
@@ -2220,51 +2596,6 @@ function promotionGate(opts) {
   };
 }
 
-// src/runtime/resolve-sandbox-client.ts
-function resolveSandboxClient(opts) {
-  switch (opts.backend) {
-    case "sandbox": {
-      if (!opts.sandboxClient) {
-        throw new Error("resolveSandboxClient: backend 'sandbox' requires opts.sandboxClient");
-      }
-      return opts.sandboxClient;
-    }
-    case "bridge": {
-      const bridge = opts.bridge;
-      if (!bridge?.bearer || !bridge.model) {
-        throw new Error(
-          "resolveSandboxClient: backend 'bridge' requires bridge.bearer and bridge.model"
-        );
-      }
-      return inlineSandboxClient(
-        createExecutor({
-          backend: "bridge",
-          bridgeUrl: bridge.url ?? "http://127.0.0.1:3355",
-          bridgeBearer: bridge.bearer,
-          model: bridge.model,
-          timeoutMs: bridge.timeoutMs
-        })
-      );
-    }
-    case "router": {
-      const router = opts.router;
-      if (!router?.baseUrl || !router.key || !router.model) {
-        throw new Error(
-          "resolveSandboxClient: backend 'router' requires router.baseUrl, router.key and router.model"
-        );
-      }
-      return inlineSandboxClient(
-        createExecutor({
-          backend: "router",
-          routerBaseUrl: router.baseUrl,
-          routerKey: router.key,
-          model: router.model
-        })
-      );
-    }
-  }
-}
-
 // src/runtime/run-benchmark.ts
 import { pairedBootstrap as pairedBootstrap2, paretoFrontier } from "@tangle-network/agent-eval";
 
@@ -3267,56 +3598,9 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/runtime/steering-drivers.ts
-function decideUntilValidOrCapped(history, maxIterations) {
-  if (history.some((it) => it.verdict?.valid)) return "pick-winner";
-  return history.length < maxIterations ? "refine" : "fail";
-}
-function naiveDriver(options) {
-  const { continuation, applyContinuation, maxIterations, name = "naive" } = options;
-  return {
-    name,
-    plan(task, history) {
-      if (history.length === 0) return Promise.resolve([task]);
-      const last = history[history.length - 1];
-      if (last?.verdict?.valid) return Promise.resolve([]);
-      if (history.length >= maxIterations) return Promise.resolve([]);
-      return Promise.resolve([applyContinuation(task, continuation)]);
-    },
-    decide(history) {
-      return decideUntilValidOrCapped(history, maxIterations);
-    },
-    // Pure refine topology (one task per round) — render the steer move.
-    describePlan() {
-      return { kind: "refine", rationale: "naive fixed continuation (no grade signal)" };
-    }
-  };
-}
-function dumbDriver(options) {
-  const { onPass, onFail, applyContinuation, maxIterations, name = "dumb" } = options;
-  return {
-    name,
-    plan(task, history) {
-      if (history.length === 0) return Promise.resolve([task]);
-      const last = history[history.length - 1];
-      const passed = last?.verdict?.valid === true;
-      if (passed) return Promise.resolve([]);
-      if (history.length >= maxIterations) return Promise.resolve([]);
-      const continuation = passed ? onPass : onFail;
-      return Promise.resolve([applyContinuation(task, continuation)]);
-    },
-    decide(history) {
-      return decideUntilValidOrCapped(history, maxIterations);
-    },
-    describePlan() {
-      return { kind: "refine", rationale: "dumb pass/fail-only continuation (no grader findings)" };
-    }
-  };
-}
-
 // src/runtime/strategy-author.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { join as join2 } from "path";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
 var strategyAuthorContract = `
 You author an OPTIMIZATION STRATEGY for an agentic loop system. A strategy decides how to
 spend a compute budget to beat a task's deployable check. You compose exactly two steps:
@@ -3434,9 +3718,9 @@ async function authorStrategy(opts) {
     code = await requestAuthoredCode(opts, opts.fallbackModel);
   }
   assertStrategyContract(code);
-  mkdirSync(opts.outDir, { recursive: true });
-  const file = join2(opts.outDir, `authored-${Date.now()}.mts`);
-  writeFileSync(file, code);
+  mkdirSync2(opts.outDir, { recursive: true });
+  const file = join3(opts.outDir, `authored-${Date.now()}.mts`);
+  writeFileSync2(file, code);
   const mod = await import(`file://${file}`);
   if (!mod.default || typeof mod.default.driver !== "function" || !mod.default.name) {
     throw new Error(`authorStrategy: ${file} does not export a default Strategy`);
@@ -3445,7 +3729,7 @@ async function authorStrategy(opts) {
 }
 
 // src/runtime/strategy-evolution.ts
-import { existsSync, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync, readFileSync, writeFileSync as writeFileSync3 } from "fs";
 import { gzipSync } from "zlib";
 function discriminatingMeans(report, fieldOrder) {
   const rows = report.perTask.filter((r) => {
@@ -3557,7 +3841,7 @@ async function runStrategyEvolution(cfg) {
   }
   const save = (state) => {
     if (cfg.checkpoint)
-      writeFileSync2(cfg.checkpoint.path, JSON.stringify({ ...state, fingerprint }, null, 1));
+      writeFileSync3(cfg.checkpoint.path, JSON.stringify({ ...state, fingerprint }, null, 1));
   };
   const bench = async (phase, tasks, strategies) => {
     await cfg.onPhase?.(phase);
@@ -4641,9 +4925,9 @@ function jjWorkspace(opts) {
 }
 async function runInWorkspace(ws, body, opts = {}) {
   const { mkdtempSync: mkdtempSync2, rmSync: rmSync2 } = await import("fs");
-  const { tmpdir: tmpdir2 } = await import("os");
-  const { join: join3 } = await import("path");
-  const dir = mkdtempSync2(join3(tmpdir2(), opts.tmpPrefix ?? "ws-run-"));
+  const { tmpdir: tmpdir3 } = await import("os");
+  const { join: join4 } = await import("path");
+  const dir = mkdtempSync2(join4(tmpdir3(), opts.tmpPrefix ?? "ws-run-"));
   try {
     await ws.materialize(dir);
     const r = await body(dir);
@@ -4676,15 +4960,19 @@ export {
   stopSentinel,
   sentinelCompletion,
   deterministicCompletion,
+  reportLoopUsage,
+  loopCampaignDispatch,
+  loopDispatch,
+  inlineSandboxClient,
+  resolveSandboxClient,
+  naiveDriver,
+  dumbDriver,
+  defineLeaderboard,
   defaultAnalystInstruction,
   observe,
   renderReport,
   harvestCorpus,
   inProcessSandboxClient,
-  inlineSandboxClient,
-  reportLoopUsage,
-  loopCampaignDispatch,
-  loopDispatch,
   createMcpEnvironment,
   assertTraceDerivedFindings,
   createScopeAnalyst,
@@ -4709,7 +4997,6 @@ export {
   trajectoryReport,
   equalKOnCost,
   promotionGate,
-  resolveSandboxClient,
   depthStrategy,
   breadthStrategy,
   sample,
@@ -4722,8 +5009,6 @@ export {
   printBenchmarkReport,
   SandboxRunAbortError,
   openSandboxRun,
-  naiveDriver,
-  dumbDriver,
   strategyAuthorContract,
   assertStrategyContract,
   authorStrategy,
@@ -4751,4 +5036,4 @@ export {
   computeFindingId,
   makeFinding2 as makeFinding
 };
-//# sourceMappingURL=chunk-JYURIKPF.js.map
+//# sourceMappingURL=chunk-UJW6EVNY.js.map