@forwardimpact/libeval 0.1.51 → 0.1.52

package/src/benchmark/workdir.js

@@ -5,16 +5,17 @@
  *
  * The Workdir handle threads `cwd`, `port`, `pgid`, and trace paths through
  * runAgent → invariants → judge → teardown.
+ *
+ * Filesystem, subprocess, clock, and process-signal access all route through
+ * the injected `runtime` bag. Only raw TCP plumbing (`node:net`) stays direct —
+ * it is not an ambient-dependency smell and the runtime bag models no socket
+ * surface.
  */
 
-import { spawn } from "node:child_process";
-import { cp, mkdir } from "node:fs/promises";
 import { createServer } from "node:net";
 import { connect } from "node:net";
 import { join } from "node:path";
 
-import { createDefaultRuntime } from "@forwardimpact/libutil/runtime";
-
 import { loadEnv } from "./env-loader.js";
 
 const DEFAULT_TERM_GRACE_MS = 5_000;
@@ -39,6 +40,8 @@ export class WorkdirManager {
    * @param {object} deps
    * @param {string} deps.stagingDir - Output of `installApm(...)`.
    * @param {string} deps.runOutputDir - Root run-output directory (parent of `runs/`).
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} deps.runtime -
+   *   Ambient collaborators; uses `fs`, `subprocess`, `clock`, `proc`.
    */
   constructor({
     stagingDir,
@@ -49,14 +52,12 @@ export class WorkdirManager {
   }) {
     if (!stagingDir) throw new Error("stagingDir is required");
     if (!runOutputDir) throw new Error("runOutputDir is required");
+    if (!runtime) throw new Error("runtime is required");
     this.stagingDir = stagingDir;
     this.runOutputDir = runOutputDir;
     this.termGraceMs = termGraceMs ?? DEFAULT_TERM_GRACE_MS;
     this.familyRootPath = familyRootPath ?? null;
-    // `loadEnv` is the only collaborator routed through the runtime today; the
-    // rest of this manager still uses raw streaming/net/process-group APIs the
-    // runtime surface does not yet cover.
-    this.runtime = runtime ?? null;
+    this.runtime = runtime;
   }
 
   /**
@@ -66,36 +67,39 @@ export class WorkdirManager {
    * @returns {Promise<Workdir>}
    */
   async start(task, runIndex) {
+    const fs = this.runtime.fs;
     const slug = task.id.replace("/", "__");
     const runDir = join(this.runOutputDir, "runs", slug, String(runIndex));
     const cwd = join(runDir, "cwd");
-    await mkdir(cwd, { recursive: true });
+    await fs.mkdir(cwd, { recursive: true });
 
-    await cp(task.paths.workdir, cwd, { recursive: true }).catch((e) => {
-      if (e.code !== "ENOENT") throw e;
-    });
-    await cp(task.paths.specs, join(cwd, "specs"), {
-      recursive: true,
-    }).catch((e) => {
+    await fs.cp(task.paths.workdir, cwd, { recursive: true }).catch((e) => {
       if (e.code !== "ENOENT") throw e;
     });
-    await cp(join(this.stagingDir, ".claude"), join(cwd, ".claude"), {
-      recursive: true,
-    });
-    await cp(join(this.stagingDir, "node_modules"), join(cwd, "node_modules"), {
+    await fs
+      .cp(task.paths.specs, join(cwd, "specs"), {
+        recursive: true,
+      })
+      .catch((e) => {
+        if (e.code !== "ENOENT") throw e;
+      });
+    await fs.cp(join(this.stagingDir, ".claude"), join(cwd, ".claude"), {
       recursive: true,
-    }).catch((e) => {
-      if (e.code !== "ENOENT") throw e;
     });
+    await fs
+      .cp(join(this.stagingDir, "node_modules"), join(cwd, "node_modules"), {
+        recursive: true,
+      })
+      .catch((e) => {
+        if (e.code !== "ENOENT") throw e;
+      });
 
     const envDirs = [
       ...(this.familyRootPath ? [this.familyRootPath] : []),
       ...(task.paths.taskDir ? [task.paths.taskDir] : []),
     ];
     const envNames =
-      envDirs.length > 0
-        ? await loadEnv(envDirs, cwd, this.runtime ?? createDefaultRuntime())
-        : [];
+      envDirs.length > 0 ? await loadEnv(envDirs, cwd, this.runtime) : [];
 
     const port = await allocatePort();
     const agentTracePath = join(runDir, "agent.ndjson");
@@ -103,7 +107,7 @@ export class WorkdirManager {
     const judgeTracePath = join(runDir, "judge.ndjson");
 
     const preflight = task.paths.preflight
-      ? await runPreflight(task.paths.preflight, cwd, port)
+      ? await runPreflight(this.runtime, task.paths.preflight, cwd, port)
       : { pgid: 0 };
 
     return {
@@ -126,81 +130,71 @@ export class WorkdirManager {
    * @returns {Promise<{portFree: boolean, descendants: number}>}
    */
   async teardown(workdir) {
+    const { proc, clock } = this.runtime;
     if (workdir.pgid && workdir.pgid > 0) {
       try {
-        process.kill(-workdir.pgid, "SIGTERM");
+        proc.kill(-workdir.pgid, "SIGTERM");
       } catch {
         // Process group already gone — fine.
       }
-      await sleep(this.termGraceMs);
+      await clock.sleep(this.termGraceMs);
       try {
-        process.kill(-workdir.pgid, "SIGKILL");
+        proc.kill(-workdir.pgid, "SIGKILL");
       } catch {
         // Already exited.
       }
       // Poll briefly until the process group is empty — SIGKILL returns
       // before the kernel finishes reaping descendants.
       await waitFor(
-        async () => (await countDescendants(workdir.pgid)) === 0,
+        this.runtime,
+        async () => (await countDescendants(this.runtime, workdir.pgid)) === 0,
         2_000,
       );
     }
     const portFree = await isPortFree(workdir.port);
-    const descendants = await countDescendants(workdir.pgid);
+    const descendants = await countDescendants(this.runtime, workdir.pgid);
     return { portFree, descendants };
   }
 }
 
 /**
  * Spawn preflight. Stays detached so we can SIGTERM the whole process group.
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
  * @param {string} script
  * @param {string} cwd - Agent CWD passed via $WORKDIR.
  * @param {number} port - Free TCP port passed via $PORT.
  * @returns {Promise<{pgid: number, error?: {phase: string, message: string, exitCode: number}}>}
  */
-function runPreflight(script, cwd, port) {
-  return new Promise((res, rej) => {
-    let stderr = "";
-    const child = spawn(script, [], {
-      cwd,
-      env: { ...process.env, WORKDIR: cwd, PORT: String(port) },
-      detached: true,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    if (child.pid === undefined) {
-      rej(new Error(`failed to spawn preflight: ${script}`));
-      return;
-    }
-    const pgid = child.pid;
-    child.stderr.on("data", (d) => {
-      stderr += d.toString();
-    });
-    child.on("error", (e) => {
-      res({
-        pgid,
-        error: {
-          phase: "preflight",
-          message: `preflight failed to spawn: ${e.message}`,
-          exitCode: -1,
-        },
-      });
-    });
-    child.on("exit", (code, signal) => {
-      if (code === 0) {
-        res({ pgid });
-        return;
-      }
-      const message = stderr.trim() || `preflight exited with signal ${signal}`;
-      res({
-        pgid,
-        error: {
-          phase: "preflight",
-          message,
-          exitCode: typeof code === "number" ? code : -1,
-        },
-      });
-    });
+async function runPreflight(runtime, script, cwd, port) {
+  const child = runtime.subprocess.spawn(script, [], {
+    cwd,
+    env: { ...runtime.proc.env, WORKDIR: cwd, PORT: String(port) },
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
   });
+  if (child.pid === undefined) {
+    throw new Error(`failed to spawn preflight: ${script}`);
+  }
+  const pgid = child.pid;
+  let stderr = "";
+  const drainStdout = (async () => {
+    for await (const _chunk of child.stdout) {
+      // discard
+    }
+  })();
+  for await (const chunk of child.stderr) stderr += chunk.toString();
+  await drainStdout;
+  const code = await child.exitCode;
+  if (code === 0) return { pgid };
+  const message = stderr.trim() || `preflight exited with code ${code}`;
+  return {
+    pgid,
+    error: {
+      phase: "preflight",
+      message,
+      exitCode: typeof code === "number" ? code : -1,
+    },
+  };
 }
 
 function allocatePort() {
@@ -236,37 +230,35 @@ function isPortFree(port) {
   });
 }
 
-function countDescendants(pgid) {
-  if (!pgid || pgid <= 0) return Promise.resolve(0);
-  return new Promise((res) => {
-    const child = spawn("ps", ["-o", "pid=", "-g", String(pgid)], {
+async function countDescendants(runtime, pgid) {
+  if (!pgid || pgid <= 0) return 0;
+  const child = runtime.subprocess.spawn(
+    "ps",
+    ["-o", "pid=", "-g", String(pgid)],
+    {
       stdio: ["ignore", "pipe", "ignore"],
-    });
-    let out = "";
-    child.stdout.on("data", (d) => {
-      out += d.toString();
-    });
-    child.on("error", () => res(0));
-    child.on("close", () => {
-      const pids = out
-        .split("\n")
-        .map((s) => s.trim())
-        .filter(Boolean)
-        .filter((s) => Number(s) !== process.pid);
-      res(pids.length);
-    });
-  });
-}
-
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
+    },
+  );
+  let out = "";
+  try {
+    for await (const chunk of child.stdout) out += chunk.toString();
+    await child.exitCode;
+  } catch {
+    return 0;
+  }
+  const pids = out
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .filter((s) => Number(s) !== runtime.proc.pid);
+  return pids.length;
 }
 
-async function waitFor(predicate, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
+async function waitFor(runtime, predicate, timeoutMs) {
+  const deadline = runtime.clock.now() + timeoutMs;
+  while (runtime.clock.now() < deadline) {
     if (await predicate()) return true;
-    await sleep(50);
+    await runtime.clock.sleep(50);
   }
   return false;
 }

package/src/commands/benchmark-invariants.js

@@ -27,7 +27,7 @@ export async function runBenchmarkInvariantsCommand(ctx) {
   if (!workdirArg)
     return { ok: false, code: 1, error: "--workdir is required" };
 
-  const family = await loadTaskFamily(familyInput);
+  const family = await loadTaskFamily(familyInput, runtime);
   const task = family.tasks().find((t) => t.id === taskId);
   if (!task)
     return { ok: false, code: 1, error: `task not found in family: ${taskId}` };
@@ -36,7 +36,7 @@ export async function runBenchmarkInvariantsCommand(ctx) {
   const cwd = join(runDir, "cwd");
   const port = await allocatePort();
 
-  const invariants = await runInvariants(task, { cwd, port, runDir });
+  const invariants = await runInvariants(task, { cwd, port, runDir }, runtime);
   const record = {
     taskId: task.id,
     invariants,

package/src/commands/benchmark-report.js

@@ -40,6 +40,7 @@ export async function runBenchmarkReportCommand(ctx) {
     inputDir: resolve(inputDir),
     kValues,
     includeRuns: format === "text",
+    runtime,
   });
   if (format === "text") {
     runtime.proc.stdout.write(renderTextReport(report, kValues) + "\n");

package/src/commands/benchmark-run.js

@@ -33,7 +33,7 @@ export async function runBenchmarkRunCommand(ctx) {
   delete runtime.proc.env.NODE_EXTRA_CA_CERTS;
 
   const { query } = await import("@anthropic-ai/claude-agent-sdk");
-  const runner = createBenchmarkRunner({ ...opts, query });
+  const runner = createBenchmarkRunner({ ...opts, query, runtime });
 
   let anyFail = false;
   for await (const record of runner.run()) {

package/src/commands/by-discussion.js

@@ -1,4 +1,3 @@
-import { closeSync, openSync, readSync } from "node:fs";
 import { join } from "node:path";
 
 const FIRST_LINE_CAP = 64 * 1024;
@@ -6,25 +5,25 @@ const FIRST_LINE_CAP = 64 * 1024;
 /**
  * Read the first newline-terminated line of a file, bounded to the first
  * {@link FIRST_LINE_CAP} bytes. Trace `.ndjson` files can be many MB; the
- * Step 2.6 meta header is always small, so a bounded `readSync` avoids
- * loading whole files into memory just to inspect the header. This uses
- * `node:fs` directly because the `runtime.fsSync` surface exposes no
- * positional `openSync`/`readSync` — the file is grandfathered for
- * `import:fs` in `check-ambient-deps.deny.yml` until that seam exists.
+ * Step 2.6 meta header is always small, so a bounded positional read avoids
+ * loading whole files into memory just to inspect the header. The positional
+ * `openSync`/`readSync`/`closeSync` trio is read off the injected
+ * `runtime.fsSync` surface.
  *
+ * @param {object} fsSync - Sync filesystem surface (`runtime.fsSync`).
  * @param {string} path
  * @returns {string}
  */
-function readFirstLine(path) {
-  const fd = openSync(path, "r");
+function readFirstLine(fsSync, path) {
+  const fd = fsSync.openSync(path, "r");
   try {
     const buf = Buffer.alloc(FIRST_LINE_CAP);
-    const bytes = readSync(fd, buf, 0, buf.length, 0);
+    const bytes = fsSync.readSync(fd, buf, 0, buf.length, 0);
     const text = buf.toString("utf8", 0, bytes);
     const nl = text.indexOf("\n");
     return nl === -1 ? text : text.slice(0, nl);
   } finally {
-    closeSync(fd);
+    fsSync.closeSync(fd);
   }
 }
 
@@ -53,7 +52,7 @@ export function findTracesByDiscussion(dir, discussionId, fsSync) {
     const path = join(dir, entry);
     let firstLine;
     try {
-      firstLine = readFirstLine(path);
+      firstLine = readFirstLine(fsSync, path);
     } catch {
       continue;
     }

package/src/commands/discuss.js

@@ -1,5 +1,5 @@
-import { createWriteStream } from "node:fs";
 import { resolve } from "node:path";
+import { isoTimestamp } from "@forwardimpact/libutil";
 import { createDiscusser } from "../discusser.js";
 import { createRedactor } from "../redaction.js";
 import { createTeeWriter } from "../tee-writer.js";
@@ -80,13 +80,14 @@ export async function runDiscussCommand(ctx) {
   const redactor = createRedactor({ runtime });
 
   const fileStream = opts.outputPath
-    ? createWriteStream(opts.outputPath)
+    ? runtime.fs.createWriteStream(opts.outputPath)
     : null;
   const output = fileStream
     ? createTeeWriter({
         fileStream,
         textStream: runtime.proc.stdout,
         mode: "supervised",
+        now: () => isoTimestamp(runtime.clock.now()),
       })
     : runtime.proc.stdout;
 

package/src/commands/facilitate.js

@@ -1,5 +1,5 @@
-import { createWriteStream } from "node:fs";
 import { resolve } from "node:path";
+import { isoTimestamp } from "@forwardimpact/libutil";
 import { createFacilitator } from "../facilitator.js";
 import { createRedactor } from "../redaction.js";
 import { createTeeWriter } from "../tee-writer.js";
@@ -76,13 +76,14 @@ export async function runFacilitateCommand(ctx) {
   const redactor = createRedactor({ runtime });
 
   const fileStream = opts.outputPath
-    ? createWriteStream(opts.outputPath)
+    ? runtime.fs.createWriteStream(opts.outputPath)
     : null;
   const output = fileStream
     ? createTeeWriter({
         fileStream,
         textStream: runtime.proc.stdout,
         mode: "supervised",
+        now: () => isoTimestamp(runtime.clock.now()),
       })
     : runtime.proc.stdout;
 

package/src/commands/output.js

@@ -1,3 +1,4 @@
+import { isoTimestamp } from "@forwardimpact/libutil";
 import { createTraceCollector } from "@forwardimpact/libeval";
 
 /**
@@ -16,7 +17,9 @@ export async function runOutputCommand(ctx) {
     values.format === "text" || values.format === "json"
       ? values.format
       : "json";
-  const collector = createTraceCollector();
+  const collector = createTraceCollector({
+    now: () => isoTimestamp(runtime.clock.now()),
+  });
 
   // `runtime.proc.stdin` is an AsyncIterable of UTF-8 lines (newline-split by
   // the runtime), so each yielded value is exactly one NDJSON record.

package/src/commands/run.js

@@ -1,6 +1,6 @@
-import { createWriteStream } from "node:fs";
 import { Writable } from "node:stream";
 import { resolve } from "node:path";
+import { isoTimestamp } from "@forwardimpact/libutil";
 import { createAgentRunner } from "../agent-runner.js";
 import { composeProfilePrompt } from "../profile-prompt.js";
 import { createRedactor } from "../redaction.js";
@@ -67,12 +67,15 @@ export async function runRunCommand(ctx) {
 
   // When --output is specified, stream text to stdout while writing NDJSON to file.
   // Otherwise, write NDJSON directly to stdout (backwards-compatible).
-  const fileStream = outputPath ? createWriteStream(outputPath) : null;
+  const fileStream = outputPath
+    ? runtime.fs.createWriteStream(outputPath)
+    : null;
   const output = fileStream
     ? createTeeWriter({
         fileStream,
         textStream: runtime.proc.stdout,
         mode: "raw",
+        now: () => isoTimestamp(runtime.clock.now()),
       })
     : runtime.proc.stdout;
 
@@ -108,6 +111,7 @@ export async function runRunCommand(ctx) {
   const systemPrompt = agentProfile
     ? composeProfilePrompt(agentProfile, {
         profilesDir: resolve(cwd, ".claude/agents"),
+        runtime,
       })
     : undefined;
 

package/src/commands/supervise.js

@@ -1,5 +1,5 @@
-import { createWriteStream } from "node:fs";
 import { resolve, join } from "node:path";
+import { isoTimestamp } from "@forwardimpact/libutil";
 import { createSupervisor } from "../supervisor.js";
 import { createRedactor } from "../redaction.js";
 import { createTeeWriter } from "../tee-writer.js";
@@ -72,13 +72,14 @@ export async function runSuperviseCommand(ctx) {
   // When --output is specified, stream text to stdout while writing NDJSON to file.
   // Otherwise, write NDJSON directly to stdout (backwards-compatible).
   const fileStream = opts.outputPath
-    ? createWriteStream(opts.outputPath)
+    ? runtime.fs.createWriteStream(opts.outputPath)
     : null;
   const output = fileStream
     ? createTeeWriter({
         fileStream,
         textStream: runtime.proc.stdout,
         mode: "supervised",
+        now: () => isoTimestamp(runtime.clock.now()),
       })
     : runtime.proc.stdout;
 

package/src/commands/tee.js

@@ -1,32 +1,47 @@
-import { createWriteStream } from "fs";
 import { PassThrough } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { isoTimestamp } from "@forwardimpact/libutil";
 import { createTeeWriter } from "../tee-writer.js";
 
 /**
  * Tee command — stream text output to stdout while optionally saving the raw
- * NDJSON to a file. Processes stdin line-by-line for streaming output.
+ * NDJSON to a file. Reads stdin line-by-line through the injected runtime and
+ * re-delimits each record with a newline so the TeeWriter's line splitter sees
+ * the same framing the raw byte stream produced.
  *
  * Usage: fit-eval tee [output.ndjson] < trace.ndjson
  *
- * @param {object} values - Parsed option values from cli.parse()
- * @param {string[]} args - Positional arguments (optional output file path)
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: boolean, code?: number, error?: string}>}
  */
-export async function runTeeCommand(values, args) {
-  const outputPath = args.find((a) => !a.startsWith("-")) ?? null;
-  const fileStream = outputPath ? createWriteStream(outputPath) : null;
+export async function runTeeCommand(ctx) {
+  const runtime = ctx.deps.runtime;
+  const outputPath = ctx.args.output ?? null;
+  const fileStream = outputPath
+    ? runtime.fs.createWriteStream(outputPath)
+    : null;
 
   // TeeWriter requires a fileStream; when no output file is specified,
   // use a PassThrough as a no-op sink (NDJSON is not saved).
   const sink = fileStream ?? new PassThrough();
   const tee = createTeeWriter({
     fileStream: sink,
-    textStream: process.stdout,
+    textStream: runtime.proc.stdout,
     mode: "raw",
+    now: () => isoTimestamp(runtime.clock.now()),
   });
 
   try {
-    await pipeline(process.stdin, tee);
+    // `runtime.proc.stdin` yields newline-stripped lines; re-append `\n` so the
+    // TeeWriter's `_write` line splitter frames records exactly as it did when
+    // piped the raw byte stream.
+    const lines = (async function* () {
+      for await (const line of runtime.proc.stdin) yield `${line}\n`;
+    })();
+    await pipeline(lines, tee);
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, code: 1, error: error.message };
   } finally {
     if (fileStream) {
       await new Promise((resolve, reject) => {

package/src/commands/trace.js

@@ -1,4 +1,5 @@
 import { join, dirname } from "node:path";
+import { isoTimestamp } from "@forwardimpact/libutil";
 import { createTraceCollector } from "@forwardimpact/libeval";
 import { createTraceQuery } from "../trace-query.js";
 import { createTraceGitHub } from "../trace-github.js";
@@ -50,7 +51,9 @@ export async function runDownloadCommand(ctx) {
   const ndjsonFile = result.files.find((f) => f.endsWith(".ndjson"));
   if (ndjsonFile) {
     const ndjsonPath = join(result.dir, ndjsonFile);
-    const collector = createTraceCollector();
+    const collector = createTraceCollector({
+      now: () => isoTimestamp(runtime.clock.now()),
+    });
     for (const line of runtime.fsSync
       .readFileSync(ndjsonPath, "utf8")
       .split("\n")) {
@@ -325,7 +328,9 @@ function loadTrace(runtime, file) {
     // Not valid JSON — fall through to NDJSON.
   }
 
-  const collector = createTraceCollector();
+  const collector = createTraceCollector({
+    now: () => isoTimestamp(runtime.clock.now()),
+  });
   for (const line of content.split("\n")) {
     collector.addLine(line);
   }

package/src/discusser.js

@@ -226,8 +226,10 @@ export function createDiscusser({
   callbackUrl,
   inboxUrl,
   correlationId,
+  runtime,
 }) {
   if (!redactor) throw new Error("redactor is required");
+  if (!runtime) throw new Error("runtime is required");
   const resolvedLeadCwd = resolve(leadCwd ?? ".");
   const resolvedProfilesDir =
     profilesDir ?? resolve(resolvedLeadCwd, ".claude/agents");
@@ -326,6 +328,7 @@ export function createDiscusser({
         profile: config.agentProfile,
         profilesDir: resolvedProfilesDir,
         trailer: agentTrailer,
+        runtime,
       }),
       redactor,
     });
@@ -358,6 +361,7 @@ export function createDiscusser({
       profile: leadProfile,
       profilesDir: resolvedProfilesDir,
       trailer: DISCUSS_SYSTEM_PROMPT,
+      runtime,
     }),
     redactor,
   });

package/src/facilitator.js

@@ -109,8 +109,10 @@ export function createFacilitator({
   profilesDir,
   taskAmend,
   redactor,
+  runtime,
 }) {
   if (!redactor) throw new Error("redactor is required");
+  if (!runtime) throw new Error("runtime is required");
   const resolvedProfilesDir =
     profilesDir ?? resolve(facilitatorCwd, ".claude/agents");
   const ctx = createOrchestrationContext();
@@ -151,6 +153,7 @@ export function createFacilitator({
         profile: config.agentProfile,
         profilesDir: resolvedProfilesDir,
         trailer: agentTrailer,
+        runtime,
       }),
       redactor,
     });
@@ -187,6 +190,7 @@ export function createFacilitator({
       profile: facilitatorProfile,
       profilesDir: resolvedProfilesDir,
       trailer: FACILITATOR_SYSTEM_PROMPT,
+      runtime,
     }),
     redactor,
   });

package/src/judge.js

@@ -167,17 +167,20 @@ export function createJudge({
   judgeProfile,
   profilesDir,
   taskAmend,
+  runtime,
 }) {
   if (!cwd) throw new Error("cwd is required");
   if (!query) throw new Error("query is required");
   if (!output) throw new Error("output is required");
   if (!redactor) throw new Error("redactor is required");
+  if (!runtime) throw new Error("runtime is required");
 
   const resolvedProfilesDir = profilesDir ?? resolve(cwd, ".claude/agents");
   const systemPrompt = judgeProfile
     ? composeProfilePrompt(judgeProfile, {
         profilesDir: resolvedProfilesDir,
         trailer: JUDGE_SYSTEM_PROMPT,
+        runtime,
       })
     : {
         type: "preset",