opencode-swarm 7.136.1 → 7.136.3

package/dist/cli/index-nfm9f10v.js

@@ -0,0 +1,1100 @@
+// @bun
+import {
+  CostRecordSchema,
+  EvaluationCandidateV1Schema,
+  EvaluationRunV1Schema,
+  EvaluationTaskV1Schema,
+  admitEvaluationTask,
+  claimHeldOutTest,
+  readEvaluationRun,
+  saveEvaluationRun,
+  saveTaskSetSnapshot
+} from "./index-ne28wyyc.js";
+import {
+  canonicalHash,
+  computeCandidateInputContentHash,
+  computeRunIntegrityHash,
+  computeTaskInputContentHash,
+  computeTaskSetContentHash,
+  resolveContainedExistingPath
+} from "./index-y8552snf.js";
+import {
+  exports_external,
+  init_zod
+} from "./index-bpmtbmy9.js";
+import {
+  bunSpawn
+} from "./index-y111zefa.js";
+
+// src/evaluation/runner.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// node_modules/yocto-queue/index.js
+class Node {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Queue {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    if (!this.#head) {
+      this.#tail = undefined;
+    }
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+}
+
+// node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  let rejectOnClear = false;
+  if (typeof concurrency === "object") {
+    ({ concurrency, rejectOnClear = false } = concurrency);
+  }
+  validateConcurrency(concurrency);
+  if (typeof rejectOnClear !== "boolean") {
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  }
+  const queue = new Queue;
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue().run();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (function_, resolve, reject, arguments_) => {
+    const queueItem = { reject };
+    new Promise((internalResolve) => {
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
+    }).then(run.bind(undefined, function_, resolve, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+    enqueue(function_, resolve, reject, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        if (!rejectOnClear) {
+          queue.clear();
+          return;
+        }
+        const abortError = AbortSignal.abort().reason;
+        while (queue.size > 0) {
+          queue.dequeue().reject(abortError);
+        }
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
+// src/evaluation/runner.ts
+init_zod();
+
+// src/utils/external-tool-runner.ts
+import * as fs from "fs";
+import * as path from "path";
+var DEFAULT_WINDOWS_EXTENSIONS = [".exe", ".cmd", ".bat"];
+function isExecutableFile(candidate) {
+  try {
+    const stats = fs.statSync(candidate);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveExecutableFromPath(names, envPath = process.env.PATH ?? "", platform = process.platform) {
+  const pathEntries = envPath.split(path.delimiter).filter(Boolean);
+  const isWindows = platform === "win32";
+  for (const rawName of names) {
+    if (!rawName)
+      continue;
+    if (path.isAbsolute(rawName) && isExecutableFile(rawName)) {
+      return rawName;
+    }
+    const extensions = isWindows && path.extname(rawName) === "" ? DEFAULT_WINDOWS_EXTENSIONS : [""];
+    for (const dir of pathEntries) {
+      for (const ext of extensions) {
+        const candidate = path.join(dir, `${rawName}${ext}`);
+        if (isExecutableFile(candidate)) {
+          return candidate;
+        }
+      }
+    }
+  }
+  return null;
+}
+async function readBoundedStream(stream, maxBytes) {
+  const reader = stream.getReader();
+  let lockReleased = false;
+  const releaseLock = () => {
+    if (lockReleased)
+      return;
+    lockReleased = true;
+    try {
+      reader.releaseLock();
+    } catch {}
+  };
+  const cancelAndRelease = async () => {
+    try {
+      await reader.cancel();
+    } catch {} finally {
+      releaseLock();
+    }
+  };
+  if (maxBytes <= 0) {
+    await cancelAndRelease();
+    return { text: "", truncated: true };
+  }
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (!value)
+        continue;
+      const remaining = maxBytes - total;
+      if (value.byteLength > remaining) {
+        if (remaining > 0) {
+          chunks.push(value.slice(0, remaining));
+          total += remaining;
+        }
+        truncated = true;
+        await cancelAndRelease();
+        break;
+      }
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    releaseLock();
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return {
+    text: new TextDecoder().decode(out),
+    truncated
+  };
+}
+function timeoutKillSignal(platform) {
+  return platform === "win32" ? "SIGTERM" : "SIGKILL";
+}
+function killProcess(proc) {
+  try {
+    proc?.kill(timeoutKillSignal(_internals.platform()));
+  } catch {}
+}
+async function runExternalTool(options) {
+  if (!path.isAbsolute(options.cwd)) {
+    return {
+      status: "spawn-error",
+      exitCode: null,
+      stdout: "",
+      stderr: "",
+      stdoutTruncated: false,
+      stderrTruncated: false,
+      message: "external tool cwd must be absolute"
+    };
+  }
+  if (options.abortSignal?.aborted) {
+    return {
+      status: "cancelled",
+      exitCode: null,
+      stdout: "",
+      stderr: "",
+      stdoutTruncated: false,
+      stderrTruncated: false,
+      message: "external tool execution cancelled before spawn"
+    };
+  }
+  let proc;
+  let timeoutHandle;
+  let abortListener;
+  let exitSettled = false;
+  let settledExitCode = null;
+  try {
+    proc = _internals.bunSpawn([options.executable, ...options.args], {
+      cwd: options.cwd,
+      env: options.env,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      timeout: options.timeoutMs
+    });
+    const exitPromise = proc.exited.then((exitCode) => {
+      exitSettled = true;
+      settledExitCode = exitCode;
+      return { kind: "exit", exitCode };
+    });
+    const timeout = new Promise((resolve) => {
+      timeoutHandle = setTimeout(() => {
+        if (exitSettled) {
+          resolve({
+            kind: "exit",
+            exitCode: settledExitCode ?? proc?.exitCode ?? 0
+          });
+          return;
+        }
+        killProcess(proc);
+        resolve({ kind: "timeout" });
+      }, options.timeoutMs);
+    });
+    const cancelled = new Promise((resolve) => {
+      if (!options.abortSignal)
+        return;
+      let handled = false;
+      abortListener = () => {
+        if (handled)
+          return;
+        handled = true;
+        killProcess(proc);
+        resolve({ kind: "cancelled" });
+      };
+      options.abortSignal.addEventListener("abort", abortListener, {
+        once: true
+      });
+      if (options.abortSignal.aborted)
+        abortListener();
+    });
+    const stdoutPromise = readBoundedStream(proc.stdout, options.maxStdoutBytes);
+    const stderrPromise = readBoundedStream(proc.stderr, options.maxStderrBytes);
+    const exitResult = await Promise.race([exitPromise, timeout, cancelled]);
+    if (exitResult.kind === "timeout") {
+      return {
+        status: "timeout",
+        exitCode: proc.exitCode,
+        stdout: "",
+        stderr: "",
+        stdoutTruncated: false,
+        stderrTruncated: false
+      };
+    }
+    if (exitResult.kind === "cancelled") {
+      return {
+        status: "cancelled",
+        exitCode: proc.exitCode,
+        stdout: "",
+        stderr: "",
+        stdoutTruncated: false,
+        stderrTruncated: false,
+        message: "external tool execution cancelled"
+      };
+    }
+    const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+    return {
+      status: "completed",
+      exitCode: exitResult.exitCode,
+      stdout: stdout.text,
+      stderr: stderr.text,
+      stdoutTruncated: stdout.truncated,
+      stderrTruncated: stderr.truncated
+    };
+  } catch (err) {
+    return {
+      status: "spawn-error",
+      exitCode: proc?.exitCode ?? null,
+      stdout: "",
+      stderr: "",
+      stdoutTruncated: false,
+      stderrTruncated: false,
+      message: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    if (timeoutHandle !== undefined)
+      clearTimeout(timeoutHandle);
+    if (abortListener && options.abortSignal) {
+      options.abortSignal.removeEventListener("abort", abortListener);
+    }
+    if (proc) {
+      try {
+        proc.kill();
+      } catch {}
+    }
+  }
+}
+var _internals = {
+  bunSpawn,
+  platform: () => process.platform
+};
+
+// src/evaluation/disposable-worktree.ts
+import * as crypto from "crypto";
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+var GIT_TIMEOUT_MS = 30000;
+var MAX_GIT_OUTPUT_BYTES = 4 * 1024 * 1024;
+var WORKTREE_PARENT = "opencode-swarm-evaluation";
+
+class DisposableWorktreeCleanupError extends Error {
+  worktreePath;
+  pathPresent;
+  registrationPresent;
+  cleanupErrors;
+  code = "evaluation-worktree-cleanup-failed";
+  constructor(worktreePath, pathPresent, registrationPresent, cleanupErrors) {
+    super(`Evaluation worktree cleanup could not be verified for ${worktreePath} ` + `(pathPresent=${pathPresent}, registrationPresent=${String(registrationPresent)})`);
+    this.worktreePath = worktreePath;
+    this.pathPresent = pathPresent;
+    this.registrationPresent = registrationPresent;
+    this.cleanupErrors = cleanupErrors;
+    this.name = "DisposableWorktreeCleanupError";
+  }
+}
+async function git(projectRoot, args, abortSignal) {
+  const executable = _internals2.resolveExecutableFromPath(["git"]);
+  if (!executable)
+    throw new Error("git executable not found");
+  const result = await _internals2.runExternalTool({
+    executable,
+    args: ["-C", projectRoot, ...args],
+    cwd: projectRoot,
+    timeoutMs: GIT_TIMEOUT_MS,
+    maxStdoutBytes: MAX_GIT_OUTPUT_BYTES,
+    maxStderrBytes: MAX_GIT_OUTPUT_BYTES,
+    abortSignal
+  });
+  if (result.status !== "completed" || result.exitCode !== 0) {
+    throw new Error(`git ${args[0] ?? ""} failed: ${result.message ?? result.stderr.trim() ?? result.status}`);
+  }
+  return { stdout: result.stdout, stderr: result.stderr };
+}
+async function captureWorkingTreeFingerprint(projectRoot, abortSignal) {
+  const canonicalRoot = fs2.realpathSync(projectRoot);
+  const head = await git(canonicalRoot, ["rev-parse", "HEAD"], abortSignal);
+  const porcelain = await git(canonicalRoot, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--",
+    ".",
+    ":(exclude).swarm/**"
+  ], abortSignal);
+  return {
+    head: head.stdout.trim(),
+    porcelainHash: crypto.createHash("sha256").update(porcelain.stdout).digest("hex")
+  };
+}
+async function createDisposableWorktree(projectRoot, baseRef, abortSignal) {
+  const canonicalRoot = fs2.realpathSync(projectRoot);
+  if (!/^[A-Fa-f0-9]{40,64}$/.test(baseRef)) {
+    throw new Error("Evaluation baseRef must be a full commit hash");
+  }
+  const parent = path2.join(_internals2.tmpdir(), WORKTREE_PARENT);
+  fs2.mkdirSync(parent, { recursive: true });
+  const canonicalParent = fs2.realpathSync(parent);
+  const worktreePath = path2.join(canonicalParent, crypto.randomUUID());
+  await git(canonicalRoot, ["worktree", "add", "--detach", worktreePath, baseRef], abortSignal);
+  return { path: fs2.realpathSync(worktreePath), baseSha: baseRef };
+}
+async function removeDisposableWorktree(projectRoot, worktreePath) {
+  const canonicalRoot = fs2.realpathSync(projectRoot);
+  const expectedParent = fs2.realpathSync(path2.join(_internals2.tmpdir(), WORKTREE_PARENT));
+  const resolved = path2.resolve(worktreePath);
+  const relative2 = path2.relative(expectedParent, resolved);
+  if (!relative2 || relative2 === ".." || relative2.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative2)) {
+    throw new Error("Refusing to remove a worktree outside the evaluation root");
+  }
+  const cleanupErrors = [];
+  try {
+    await git(canonicalRoot, ["worktree", "remove", "--force", resolved]);
+  } catch (error) {
+    cleanupErrors.push(`git-remove: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  try {
+    _internals2.rmSync(resolved, { recursive: true, force: true });
+  } catch (error) {
+    cleanupErrors.push(`filesystem-remove: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  try {
+    await git(canonicalRoot, ["worktree", "prune", "--expire", "now"]);
+  } catch (error) {
+    cleanupErrors.push(`git-prune: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const pathPresent = _internals2.existsSync(resolved);
+  let registrationPresent;
+  try {
+    const listed = await git(canonicalRoot, [
+      "worktree",
+      "list",
+      "--porcelain",
+      "-z"
+    ]);
+    const normalizedTarget = normalizeWorktreePath(resolved);
+    registrationPresent = listed.stdout.split("\x00").filter((field) => field.startsWith("worktree ")).some((field) => normalizeWorktreePath(field.slice("worktree ".length)) === normalizedTarget);
+  } catch (error) {
+    cleanupErrors.push(`git-list: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (pathPresent || registrationPresent !== false) {
+    throw new DisposableWorktreeCleanupError(resolved, pathPresent, registrationPresent, cleanupErrors);
+  }
+}
+function normalizeWorktreePath(value) {
+  const resolved = path2.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+async function withDisposableWorktree(args) {
+  const before = await _internals2.captureWorkingTreeFingerprint(args.projectRoot, args.abortSignal);
+  let worktree;
+  try {
+    worktree = await _internals2.createDisposableWorktree(args.projectRoot, args.baseRef, args.abortSignal);
+    return await args.run(worktree);
+  } finally {
+    let cleanupFailure;
+    if (worktree) {
+      try {
+        await _internals2.removeDisposableWorktree(args.projectRoot, worktree.path);
+      } catch (error) {
+        cleanupFailure = error;
+      }
+    }
+    const after = await _internals2.captureWorkingTreeFingerprint(args.projectRoot);
+    if (before.head !== after.head || before.porcelainHash !== after.porcelainHash) {
+      throw new Error("Evaluation changed the active working tree");
+    }
+    if (cleanupFailure) {
+      throw cleanupFailure;
+    }
+  }
+}
+var _internals2 = {
+  runExternalTool,
+  resolveExecutableFromPath,
+  tmpdir: os.tmpdir,
+  rmSync: fs2.rmSync,
+  existsSync: fs2.existsSync,
+  captureWorkingTreeFingerprint,
+  createDisposableWorktree,
+  removeDisposableWorktree
+};
+
+// src/evaluation/runner.ts
+var ScorerOutputSchema = exports_external.object({
+  v: exports_external.literal(1),
+  score: exports_external.number().finite(),
+  cost: CostRecordSchema,
+  metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+}).strict();
+var BuiltinVerdictSchema = exports_external.object({
+  v: exports_external.literal(1),
+  caught: exports_external.boolean(),
+  reason: exports_external.string().optional()
+}).strict();
+
+class ScorerFailure extends Error {
+  outcome;
+  failureCode;
+  retryable;
+  constructor(outcome, failureCode, retryable) {
+    super(failureCode);
+    this.outcome = outcome;
+    this.failureCode = failureCode;
+    this.retryable = retryable;
+    this.name = "ScorerFailure";
+  }
+}
+function aggregateCost(results) {
+  if (results.some((result) => result.cost.source === "unavailable")) {
+    return { source: "unavailable" };
+  }
+  return {
+    source: results.some((result) => result.cost.source === "estimated") ? "estimated" : "reported",
+    usd: results.reduce((sum, result) => sum + (result.cost.usd ?? 0), 0)
+  };
+}
+function failureResult(args) {
+  return {
+    v: 1,
+    taskId: args.task.id,
+    category: args.task.category,
+    protected: args.task.protected,
+    repetition: args.repetition,
+    candidateId: args.candidate.id,
+    seed: args.seed,
+    outcome: args.outcome,
+    scoreRange: args.task.scorer.scoreRange,
+    cost: args.cost ?? { source: "unavailable" },
+    durationMs: args.durationMs,
+    retries: 0,
+    failureCode: args.failureCode
+  };
+}
+function parseBuiltinScore(text) {
+  let value;
+  try {
+    value = JSON.parse(text.trim());
+  } catch {
+    throw new ScorerFailure("malformed", "builtin-invalid-json", false);
+  }
+  const parsed = BuiltinVerdictSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new ScorerFailure("malformed", "builtin-schema-invalid", false);
+  }
+  const verdict = parsed.data;
+  return {
+    v: 1,
+    score: verdict.caught ? 1 : 0,
+    cost: { source: "unavailable" },
+    metadata: verdict.reason ? { reason: verdict.reason } : undefined
+  };
+}
+async function scoreExecution(args) {
+  if (args.task.scorer.kind === "builtin")
+    return parseBuiltinScore(args.execution.text);
+  const sourceEnvironment = resolveContainedExistingPath(args.inputRoot, args.task.environment.path);
+  const sourceExecutable = resolveContainedExistingPath(args.inputRoot, args.task.scorer.argv[0]);
+  const scorerRelative = path3.relative(sourceEnvironment, sourceExecutable);
+  if (!scorerRelative || scorerRelative === ".." || scorerRelative.startsWith(`..${path3.sep}`) || path3.isAbsolute(scorerRelative)) {
+    throw new ScorerFailure("malformed", "scorer-outside-task-package", false);
+  }
+  const isolatedExecutable = resolveContainedExistingPath(args.isolatedRoot, scorerRelative);
+  if (!fs3.statSync(isolatedExecutable).isFile()) {
+    throw new ScorerFailure("malformed", "scorer-not-a-file", false);
+  }
+  const extension = path3.extname(isolatedExecutable).toLowerCase();
+  const isJavaScript = [".cjs", ".js", ".mjs"].includes(extension);
+  const executable = isJavaScript ? process.execPath : isolatedExecutable;
+  const scorerArgs = isJavaScript ? [isolatedExecutable, ...args.task.scorer.argv.slice(1)] : args.task.scorer.argv.slice(1);
+  const artifactDirectory = path3.join(args.isolatedRoot, ".artifacts");
+  fs3.mkdirSync(artifactDirectory, { recursive: true });
+  fs3.writeFileSync(path3.join(artifactDirectory, "model-output.json"), JSON.stringify({ v: 1, text: args.execution.text }));
+  const result = await _internals3.runExternalTool({
+    executable,
+    args: scorerArgs,
+    cwd: args.isolatedRoot,
+    timeoutMs: Math.min(args.task.scorer.timeoutMs, args.timeoutMs),
+    maxStdoutBytes: args.maxOutputBytes,
+    maxStderrBytes: args.maxOutputBytes,
+    abortSignal: args.abortSignal,
+    env: {
+      ...process.env,
+      SWARM_EVAL_TASK_ID: args.task.id,
+      SWARM_EVAL_CANDIDATE_ID: args.candidate.id,
+      SWARM_EVAL_ARTIFACT_DIR: artifactDirectory,
+      SWARM_EVAL_SEED: args.seed
+    }
+  });
+  if (result.status === "timeout")
+    throw new ScorerFailure("timeout", "scorer-timeout", false);
+  if (result.status === "cancelled")
+    throw new ScorerFailure("cancelled", "scorer-cancelled", false);
+  if (result.status === "spawn-error")
+    throw new ScorerFailure("infrastructure_failure", "scorer-spawn-failure", true);
+  if (result.exitCode !== 0) {
+    throw new ScorerFailure("infrastructure_failure", `scorer-exit-${result.exitCode ?? "none"}`, true);
+  }
+  if (result.stdoutTruncated || result.stderrTruncated) {
+    throw new ScorerFailure("malformed", "scorer-output-truncated", false);
+  }
+  let value;
+  try {
+    value = JSON.parse(result.stdout.trim());
+  } catch {
+    throw new ScorerFailure("malformed", "scorer-invalid-json", false);
+  }
+  const parsed = ScorerOutputSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new ScorerFailure("malformed", "scorer-schema-invalid", false);
+  }
+  return parsed.data;
+}
+async function runExecutorWithinBudget(args) {
+  const startedAt = Date.now();
+  const controller = new AbortController;
+  let timedOut = false;
+  const parentAbort = () => controller.abort();
+  args.parentSignal.addEventListener("abort", parentAbort, { once: true });
+  if (args.parentSignal.aborted)
+    controller.abort();
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, args.maxTimeMs);
+  try {
+    const aborted = new Promise((resolve2) => {
+      const finish = () => resolve2({
+        status: timedOut ? "timeout" : "cancelled",
+        text: "",
+        durationMs: Date.now() - startedAt,
+        cost: { source: "unavailable" },
+        error: timedOut ? "executor-task-timeout" : "executor-cancelled"
+      });
+      controller.signal.addEventListener("abort", finish, { once: true });
+      if (controller.signal.aborted)
+        finish();
+    });
+    return await Promise.race([
+      args.options.executor({
+        task: args.task,
+        candidate: args.candidate,
+        isolatedRoot: args.isolatedRoot,
+        instruction: args.instruction,
+        payload: args.payload,
+        seed: args.seed,
+        abortSignal: controller.signal
+      }),
+      aborted
+    ]);
+  } finally {
+    clearTimeout(timer);
+    args.parentSignal.removeEventListener("abort", parentAbort);
+    controller.abort();
+  }
+}
+async function executePairMember(args) {
+  const startedAt = Date.now();
+  const seed = canonicalHash(`${args.options.seed}:${args.task.id}:${args.candidate.id}:${args.repetition}`);
+  if (args.signal.aborted) {
+    return failureResult({
+      ...args,
+      seed,
+      outcome: "cancelled",
+      durationMs: 0,
+      failureCode: "cancelled-before-execution"
+    });
+  }
+  if (args.task.environment.kind === "container") {
+    return failureResult({
+      ...args,
+      seed,
+      outcome: "unsupported",
+      durationMs: 0,
+      failureCode: "container-runner-unavailable"
+    });
+  }
+  try {
+    return await _internals3.withDisposableWorktree({
+      projectRoot: args.options.projectRoot,
+      baseRef: args.baseSha,
+      abortSignal: args.signal,
+      run: async (worktree) => {
+        const isolatedRoot = path3.join(worktree.path, ".swarm-evaluation-task");
+        fs3.mkdirSync(isolatedRoot, { recursive: true });
+        try {
+          fs3.cpSync(resolveContainedExistingPath(args.inputRoot, args.task.environment.path), isolatedRoot, { recursive: true, errorOnExist: false });
+          const instruction = fs3.readFileSync(resolveContainedExistingPath(args.inputRoot, args.task.instructionPath), "utf8");
+          const payload = fs3.readFileSync(resolveContainedExistingPath(args.inputRoot, args.candidate.payloadPath), "utf8");
+          const remainingBeforeExecution = args.options.budgets.maxTaskTimeMs - (Date.now() - startedAt);
+          if (remainingBeforeExecution <= 0) {
+            return failureResult({
+              ...args,
+              seed,
+              outcome: "timeout",
+              durationMs: Date.now() - startedAt,
+              failureCode: "task-budget-exhausted-before-executor"
+            });
+          }
+          const execution = await runExecutorWithinBudget({
+            options: args.options,
+            task: args.task,
+            candidate: args.candidate,
+            isolatedRoot,
+            instruction,
+            payload,
+            seed,
+            parentSignal: args.signal,
+            maxTimeMs: remainingBeforeExecution
+          });
+          if (execution.status !== "completed") {
+            return failureResult({
+              ...args,
+              seed,
+              outcome: execution.status === "infrastructure_failure" ? "infrastructure_failure" : execution.status,
+              durationMs: execution.durationMs,
+              cost: execution.cost,
+              failureCode: execution.error ?? `executor-${execution.status}`
+            });
+          }
+          if (Buffer.byteLength(execution.text, "utf8") > args.options.budgets.maxOutputBytes) {
+            return failureResult({
+              ...args,
+              seed,
+              outcome: "malformed",
+              durationMs: Date.now() - startedAt,
+              cost: execution.cost,
+              failureCode: "executor-output-truncated"
+            });
+          }
+          let scored;
+          try {
+            const remainingBeforeScorer = args.options.budgets.maxTaskTimeMs - (Date.now() - startedAt);
+            if (remainingBeforeScorer <= 0) {
+              throw new ScorerFailure("timeout", "task-budget-exhausted-before-scorer", false);
+            }
+            scored = await scoreExecution({
+              task: args.task,
+              candidate: args.candidate,
+              inputRoot: args.inputRoot,
+              isolatedRoot,
+              execution,
+              seed,
+              maxOutputBytes: args.options.budgets.maxOutputBytes,
+              timeoutMs: remainingBeforeScorer,
+              abortSignal: args.signal
+            });
+          } catch (error) {
+            const scorerFailure = error instanceof ScorerFailure ? error : undefined;
+            return failureResult({
+              ...args,
+              seed,
+              outcome: args.signal.aborted ? "cancelled" : scorerFailure?.outcome ?? "malformed",
+              durationMs: Date.now() - startedAt,
+              cost: execution.cost,
+              failureCode: scorerFailure?.failureCode ?? (error instanceof Error ? error.message.slice(0, 160) : "scorer-error")
+            });
+          }
+          const [minimum, maximum] = args.task.scorer.scoreRange;
+          if (scored.score < minimum || scored.score > maximum) {
+            return failureResult({
+              ...args,
+              seed,
+              outcome: "malformed",
+              durationMs: Date.now() - startedAt,
+              cost: scored.cost,
+              failureCode: "score-out-of-range"
+            });
+          }
+          return {
+            v: 1,
+            taskId: args.task.id,
+            category: args.task.category,
+            protected: args.task.protected,
+            repetition: args.repetition,
+            candidateId: args.candidate.id,
+            seed,
+            outcome: "scored",
+            score: scored.score,
+            scoreRange: args.task.scorer.scoreRange,
+            cost: scored.cost,
+            durationMs: Date.now() - startedAt,
+            retries: 0,
+            metadata: scored.metadata
+          };
+        } finally {
+          fs3.rmSync(isolatedRoot, { recursive: true, force: true });
+        }
+      }
+    });
+  } catch (error) {
+    return failureResult({
+      ...args,
+      seed,
+      outcome: "infrastructure_failure",
+      durationMs: Date.now() - startedAt,
+      failureCode: canonicalHash(String(error)).slice(0, 32)
+    });
+  }
+}
+async function executePairMemberWithRetries(args) {
+  let result;
+  for (let attempt = 0;attempt <= args.options.budgets.maxRetries; attempt++) {
+    result = await executePairMember(args);
+    result.retries = attempt;
+    if (result.outcome !== "infrastructure_failure" || args.signal.aborted) {
+      return result;
+    }
+  }
+  return result;
+}
+async function runEvaluation(options) {
+  const inputRoot = options.inputRoot ?? options.projectRoot;
+  const tasks = options.tasks.map((task) => EvaluationTaskV1Schema.parse(task));
+  if (tasks.length === 0 || tasks.length > options.budgets.maxTasks) {
+    throw new Error("evaluation task count exceeds its declared budget");
+  }
+  if (tasks.some((task) => task.split !== options.split)) {
+    throw new Error("evaluation task split does not match the run split");
+  }
+  const baseline = EvaluationCandidateV1Schema.parse(options.baseline);
+  const candidate = EvaluationCandidateV1Schema.parse(options.candidate);
+  for (const item of [baseline, candidate]) {
+    if (await computeCandidateInputContentHash(inputRoot, item) !== item.contentHash) {
+      throw new Error(`candidate ${item.id} content hash is invalid`);
+    }
+  }
+  const snapshotDraft = {
+    v: 1,
+    id: `taskset-${canonicalHash(tasks.map((task) => task.id)).slice(0, 20)}`,
+    split: options.split,
+    tasks,
+    createdAt: new Date().toISOString()
+  };
+  for (const task of tasks) {
+    await admitEvaluationTask(options.projectRoot, task, inputRoot);
+  }
+  const taskSet = {
+    ...snapshotDraft,
+    contentHash: computeTaskSetContentHash(snapshotDraft)
+  };
+  const storedTaskSet = await saveTaskSetSnapshot(options.projectRoot, taskSet, inputRoot);
+  const runId = `eval-${canonicalHash({
+    baseline: baseline.contentHash,
+    candidate: candidate.contentHash,
+    taskSet: storedTaskSet.contentHash,
+    split: options.split,
+    seed: options.seed,
+    models: options.models,
+    budgets: options.budgets
+  }).slice(0, 32)}`;
+  const existingRun = await readEvaluationRun(options.projectRoot, runId);
+  if (existingRun)
+    return existingRun;
+  if (options.split === "test") {
+    await claimHeldOutTest(options.projectRoot, {
+      v: 1,
+      runId,
+      taskSetHash: storedTaskSet.contentHash,
+      baselineHash: baseline.contentHash,
+      candidateHash: candidate.contentHash,
+      claimedAt: new Date().toISOString()
+    });
+  }
+  const before = await _internals3.captureWorkingTreeFingerprint(options.projectRoot);
+  const controller = new AbortController;
+  let externallyCancelled = options.abortSignal?.aborted ?? false;
+  let timedOut = false;
+  let budgetInconclusive = false;
+  let scheduledSpendUsd = 0;
+  const externalAbort = () => {
+    externallyCancelled = true;
+    controller.abort();
+  };
+  options.abortSignal?.addEventListener("abort", externalAbort, { once: true });
+  if (externallyCancelled)
+    controller.abort();
+  const totalExecutions = tasks.length * 2 * options.budgets.maxRepetitions;
+  const executionWaves = Math.ceil(totalExecutions / options.budgets.maxConcurrency);
+  const totalTimeoutMs = Math.min(2147483647, options.budgets.maxTaskTimeMs * executionWaves * (options.budgets.maxRetries + 1) + 1000);
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, totalTimeoutMs);
+  try {
+    const limit = pLimit(options.budgets.maxConcurrency);
+    const jobs = [];
+    for (const task of tasks) {
+      for (const item of [baseline, candidate]) {
+        for (let repetition = 0;repetition < options.budgets.maxRepetitions; repetition++) {
+          jobs.push(limit(() => executePairMemberWithRetries({
+            options,
+            inputRoot,
+            task,
+            candidate: item,
+            repetition,
+            signal: controller.signal,
+            baseSha: before.head
+          }).then((result) => {
+            if (options.budgets.maxSpendUsd !== undefined) {
+              if (result.cost.source === "unavailable") {
+                budgetInconclusive = true;
+                controller.abort();
+              } else {
+                scheduledSpendUsd += result.cost.usd ?? 0;
+                if (scheduledSpendUsd > options.budgets.maxSpendUsd) {
+                  budgetInconclusive = true;
+                  controller.abort();
+                }
+              }
+            }
+            return result;
+          })));
+        }
+      }
+    }
+    const results = await Promise.all(jobs);
+    for (const task of tasks) {
+      if (await computeTaskInputContentHash(inputRoot, task) !== task.contentHash) {
+        throw new Error(`task ${task.id} changed during evaluation`);
+      }
+    }
+    for (const item of [baseline, candidate]) {
+      if (await computeCandidateInputContentHash(inputRoot, item) !== item.contentHash) {
+        throw new Error(`candidate ${item.id} changed during evaluation`);
+      }
+    }
+    const cost = aggregateCost(results);
+    const spendUnknown = options.budgets.maxSpendUsd !== undefined && cost.source === "unavailable";
+    const overSpend = options.budgets.maxSpendUsd !== undefined && cost.source !== "unavailable" && (cost.usd ?? 0) > options.budgets.maxSpendUsd;
+    const incomplete = results.some((result) => result.outcome !== "scored");
+    const runDraft = {
+      v: 1,
+      runId,
+      createdAt: new Date().toISOString(),
+      status: externallyCancelled || timedOut ? "cancelled" : incomplete || spendUnknown || overSpend || budgetInconclusive ? "inconclusive" : "complete",
+      baseline,
+      candidate,
+      taskSet: {
+        id: storedTaskSet.id,
+        contentHash: storedTaskSet.contentHash,
+        taskIds: tasks.map((task) => task.id)
+      },
+      split: options.split,
+      seed: options.seed,
+      models: options.models,
+      environment: {
+        platform: process.platform,
+        arch: process.arch,
+        runtime: `node-${process.versions.node};bun-${process.versions.bun ?? "compat"}`,
+        baseSha: before.head,
+        activeTreeHash: canonicalHash(before),
+        taskSetHash: storedTaskSet.contentHash
+      },
+      budgets: options.budgets,
+      results,
+      cost
+    };
+    const run = EvaluationRunV1Schema.parse({
+      ...runDraft,
+      integrityHash: computeRunIntegrityHash(runDraft)
+    });
+    await saveEvaluationRun(options.projectRoot, run);
+    return run;
+  } finally {
+    clearTimeout(timeout);
+    options.abortSignal?.removeEventListener("abort", externalAbort);
+    const after = await _internals3.captureWorkingTreeFingerprint(options.projectRoot);
+    if (before.head !== after.head || before.porcelainHash !== after.porcelainHash) {
+      throw new Error("evaluation changed the active working tree");
+    }
+  }
+}
+var _internals3 = {
+  captureWorkingTreeFingerprint,
+  runExternalTool,
+  withDisposableWorktree
+};
+function createModelEvaluationExecutor(dispatcher, parentSessionId) {
+  return async (args) => {
+    const result = await dispatcher({
+      directory: args.isolatedRoot,
+      agentName: args.candidate.agent ?? "reviewer",
+      modelId: args.candidate.model,
+      system: args.payload,
+      prompt: [
+        "EVALUATION TASK:",
+        args.instruction,
+        "",
+        "Return the task-required scorer payload exactly."
+      ].join(`
+`),
+      timeoutMs: args.task.scorer.timeoutMs,
+      parentSessionId,
+      abortSignal: args.abortSignal
+    });
+    return {
+      status: result.status === "error" ? "infrastructure_failure" : result.status,
+      text: result.text,
+      durationMs: result.durationMs,
+      cost: { source: "unavailable" },
+      error: result.error
+    };
+  };
+}
+
+export { resolveExecutableFromPath, runExternalTool, pLimit, captureWorkingTreeFingerprint, runEvaluation, _internals3 as _internals, createModelEvaluationExecutor };