@forwardimpact/libharness 0.1.22 → 1.1.0

package/src/commands/by-discussion.js

@@ -0,0 +1,94 @@
+import { join } from "node:path";
+
+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 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(fsSync, path) {
+  const fd = fsSync.openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(FIRST_LINE_CAP);
+    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 {
+    fsSync.closeSync(fd);
+  }
+}
+
+/**
+ * Scan a directory for `.ndjson` files whose meta header carries the
+ * given discussion_id. The Step 2.6 first-line guarantee makes the
+ * lookup cheap: we read only the first line per file. Files without a
+ * meta header (e.g. legacy supervise/facilitate traces) are skipped
+ * silently — not erroneous.
+ *
+ * @param {string} dir
+ * @param {string} discussionId
+ * @param {object} fsSync - Sync filesystem surface (`runtime.fsSync`).
+ * @returns {Array<{path: string, mtimeMs: number}>}
+ */
+export function findTracesByDiscussion(dir, discussionId, fsSync) {
+  const matches = [];
+  let entries;
+  try {
+    entries = fsSync.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".ndjson")) continue;
+    const path = join(dir, entry);
+    let firstLine;
+    try {
+      firstLine = readFirstLine(fsSync, path);
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(firstLine);
+    } catch {
+      continue;
+    }
+    const event = parsed.event ?? parsed;
+    if (event?.type !== "meta") continue;
+    if (event.discussion_id !== discussionId) continue;
+    matches.push({ path, mtimeMs: fsSync.statSync(path).mtimeMs });
+  }
+  matches.sort((a, b) => a.mtimeMs - b.mtimeMs);
+  return matches;
+}
+
+/**
+ * `fit-trace by-discussion <discussion-id> [trace-dir]` — list trace
+ * files whose meta header carries the given discussion_id, one per
+ * line, ordered by first-event timestamp (file mtime ascending). The
+ * result is usable with `xargs cat` for a chronological merge.
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: true} | {ok: false, code: number, error: string}>}
+ */
+export async function runByDiscussionCommand(ctx) {
+  const runtime = ctx.deps.runtime;
+  const discussionId = ctx.args["discussion-id"];
+  if (!discussionId)
+    return { ok: false, code: 1, error: "<discussion-id> is required" };
+  const dir = ctx.args["trace-dir"] ?? ctx.options["trace-dir"] ?? "traces";
+  const matches = findTracesByDiscussion(dir, discussionId, runtime.fsSync);
+  for (const { path } of matches) {
+    runtime.proc.stdout.write(`${path}\n`);
+  }
+  return { ok: true };
+}

package/src/commands/callback.js

@@ -0,0 +1,119 @@
+import { sumTraceCost } from "../cost.js";
+
+/**
+ * Scan an NDJSON trace and return the last orchestrator summary event,
+ * the first `meta` event's `discussion_id`, and any structured replies
+ * collected by the discusser. Skips malformed lines.
+ *
+ * The runner is verdict-agnostic — verbatim passthrough of whatever the
+ * trace carries ("success"/"failure" from supervise/facilitate; canonical
+ * "adjourned"/"recessed"/"failed" from discuss). The bridge layer maps to
+ * its channel semantics.
+ *
+ * @param {string} content - Raw NDJSON trace content.
+ * @returns {{verdict: string, summary: string, replies: object[], trigger?: object, discussionId?: string} | null}
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: NDJSON scan with malformed-line tolerance + meta/summary dual extraction
+function readTraceSummary(content) {
+  let summary = null;
+  let metaDiscussionId = null;
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record.source !== "orchestrator") continue;
+    if (record.event?.type === "meta" && !metaDiscussionId) {
+      metaDiscussionId = record.event.discussion_id ?? null;
+    }
+    if (record.event?.type === "summary") {
+      summary = {
+        verdict: record.event.verdict ?? "failed",
+        summary: record.event.summary ?? "",
+        replies: Array.isArray(record.event.replies)
+          ? record.event.replies
+          : [],
+        ...(record.event.trigger && { trigger: record.event.trigger }),
+        ...(record.event.discussion_id && {
+          discussionId: record.event.discussion_id,
+        }),
+        ...(typeof record.event.lastActedSeq === "number" && {
+          lastActedSeq: record.event.lastActedSeq,
+        }),
+      };
+    }
+  }
+  if (summary && !summary.discussionId && metaDiscussionId) {
+    summary.discussionId = metaDiscussionId;
+  }
+  return summary;
+}
+
+/**
+ * Callback command — read an NDJSON trace, extract the terminal
+ * orchestrator summary, and POST a canonical callback body to the
+ * configured URL. Used by `kata-dispatch.yml` to deliver the lead's
+ * conclusion to the bridge that dispatched the run.
+ *
+ * Wire shape (single shape across modes):
+ *
+ * ```
+ * {
+ *   correlation_id, verdict, summary, run_url,
+ *   discussion_id?, replies: [], trigger?
+ * }
+ * ```
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: true} | {ok: false, code: number, error: string}>}
+ */
+export async function runCallbackCommand(ctx) {
+  const values = ctx.options;
+  const runtime = ctx.deps.runtime;
+  const traceFile = values["trace-file"];
+  const callbackUrl = values["callback-url"];
+  const correlationId = values["correlation-id"];
+  const runUrl = values["run-url"] ?? "";
+  const discussionIdOverride = values["discussion-id"] ?? null;
+
+  if (!traceFile)
+    return { ok: false, code: 1, error: "--trace-file is required" };
+  if (!callbackUrl)
+    return { ok: false, code: 1, error: "--callback-url is required" };
+
+  const content = runtime.fsSync.readFileSync(traceFile, "utf8");
+  const found = readTraceSummary(content) ?? {
+    verdict: "failed",
+    summary: "Run ended without producing a summary.",
+    replies: [],
+  };
+  // Total spend across every participant in the trace — the bridge surfaces
+  // it alongside the verdict so a dispatched run reports what it cost.
+  const { totalCostUsd } = sumTraceCost(content.split("\n"));
+
+  const discussionId = found.discussionId ?? discussionIdOverride ?? null;
+  const payload = {
+    correlation_id: correlationId,
+    kind: "terminal",
+    verdict: found.verdict,
+    summary: found.summary,
+    run_url: runUrl,
+    cost_usd: totalCostUsd,
+    replies: found.replies,
+    last_acted_seq: found.lastActedSeq ?? -1,
+    ...(discussionId && { discussion_id: discussionId }),
+    ...(found.trigger && { trigger: found.trigger }),
+  };
+  const res = await fetch(callbackUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+  if (!res.ok) {
+    return { ok: false, code: 1, error: `Callback POST failed: ${res.status}` };
+  }
+  return { ok: true };
+}

package/src/commands/discuss.js

@@ -0,0 +1,132 @@
+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";
+import { resolveTaskContent } from "./task-input.js";
+import { resolveWorkTracker } from "./work-tracker.js";
+import { AGENT_MODEL, LEAD_MODEL } from "@forwardimpact/libutil/models";
+
+function parseAgentProfiles(raw, cwd, maxTurns) {
+  if (!raw) return [];
+  return raw.split(",").map((entry) => {
+    const name = entry.trim();
+    return { name, role: name, cwd, agentProfile: name, maxTurns };
+  });
+}
+
+/**
+ * Parse and validate discuss command options. Exported so tests can verify
+ * defaults and the legacy-flag clean break.
+ * @param {object} values - Parsed option values
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
+ * @returns {object}
+ */
+export function parseDiscussOptions(values, runtime) {
+  const { task: taskContent, amend: taskAmend } = resolveTaskContent(
+    values,
+    runtime,
+  );
+
+  const profilesRaw = values["agent-profiles"];
+  const agentCwd = resolve(values["agent-cwd"] ?? ".");
+
+  const maxTurnsRaw = values["max-turns"] ?? "40";
+  const maxTurns = maxTurnsRaw === "0" ? 0 : parseInt(maxTurnsRaw, 10);
+
+  const agentConfigs = parseAgentProfiles(profilesRaw, agentCwd, maxTurns);
+
+  const resumeContextRaw = values["resume-context"];
+  let resumeContext = null;
+  if (resumeContextRaw) {
+    try {
+      resumeContext = JSON.parse(resumeContextRaw);
+    } catch (err) {
+      throw new Error(`--resume-context is not valid JSON: ${err.message}`);
+    }
+  }
+
+  const maxLeadTurnsRaw = values["max-lead-turns"] ?? "200";
+  const maxLeadTurns = parseInt(maxLeadTurnsRaw, 10);
+
+  return {
+    taskContent,
+    taskAmend,
+    agentConfigs,
+    leadProfile: values["lead-profile"] ?? undefined,
+    leadModel: values["lead-model"] || LEAD_MODEL,
+    agentModel: values["agent-model"] || AGENT_MODEL,
+    maxTurns,
+    maxLeadTurns,
+    outputPath: values.output,
+    workTracker: resolveWorkTracker(values, runtime?.proc?.env),
+    discussionId: values["discussion-id"] ?? null,
+    resumeContext,
+    callbackUrl: runtime.proc.env.CALLBACK_URL ?? null,
+    inboxUrl: runtime.proc.env.INBOX_URL ?? null,
+    correlationId: runtime.proc.env.CORRELATION_ID ?? null,
+  };
+}
+
+/**
+ * Discuss command — run a discusser-led session with suspend/resume
+ * semantics, threading `discussion_id` through the trace so multi-run
+ * conversations are queryable as one.
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: boolean, code?: number, error?: string}>}
+ */
+export async function runDiscussCommand(ctx) {
+  const runtime = ctx.deps.runtime;
+  const opts = parseDiscussOptions(ctx.options, runtime);
+
+  const redactor = createRedactor({ runtime });
+
+  const fileStream = 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;
+
+  if (opts.leadProfile) {
+    runtime.proc.env.LIBHARNESS_AGENT_PROFILE = opts.leadProfile;
+  }
+  // Unconditional so the default "github" is observable to the agent's
+  // active-tracker resolution, mirroring --agent-profile's env write above.
+  runtime.proc.env.LIBHARNESS_WORK_TRACKER = opts.workTracker;
+
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  const discusser = createDiscusser({
+    leadProfile: opts.leadProfile,
+    leadModel: opts.leadModel,
+    agentModel: opts.agentModel,
+    agentConfigs: opts.agentConfigs,
+    discussionId: opts.discussionId,
+    resumeContext: opts.resumeContext,
+    query,
+    output,
+    maxTurns: opts.maxTurns,
+    maxLeadTurns: opts.maxLeadTurns,
+    taskAmend: opts.taskAmend,
+    redactor,
+    callbackUrl: opts.callbackUrl,
+    inboxUrl: opts.inboxUrl,
+    correlationId: opts.correlationId,
+    runtime,
+  });
+
+  const result = await discusser.run(opts.taskContent);
+
+  if (fileStream) {
+    await new Promise((r) => output.end(r));
+    await new Promise((r) => fileStream.end(r));
+  }
+
+  return result.success ? { ok: true } : { ok: false, code: 1, error: "" };
+}

package/src/commands/facilitate.js

@@ -0,0 +1,123 @@
+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";
+import { resolveTaskContent } from "./task-input.js";
+import { resolveWorkTracker } from "./work-tracker.js";
+import { AGENT_MODEL, LEAD_MODEL } from "@forwardimpact/libutil/models";
+
+/**
+ * Parse comma-separated agent profile names into structured configs.
+ * @param {string} raw - Comma-separated profile names
+ * @param {string} cwd - Shared working directory for all agents
+ * @returns {Array<{name: string, role: string, cwd: string, agentProfile: string}>}
+ */
+function parseAgentProfiles(raw, cwd, maxTurns) {
+  return raw.split(",").map((entry) => {
+    const name = entry.trim();
+    return { name, role: name, cwd, agentProfile: name, maxTurns };
+  });
+}
+
+/**
+ * Parse and validate facilitate command options. Exported for test
+ * coverage of the `--max-turns` → per-agent threading contract; not part
+ * of the package's public API.
+ * @param {object} values - Parsed option values
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
+ * @returns {object} Parsed options
+ */
+export function parseFacilitateOptions(values, runtime) {
+  const { task: taskContent, amend: taskAmend } = resolveTaskContent(
+    values,
+    runtime,
+  );
+
+  const profilesRaw = values["agent-profiles"];
+  if (!profilesRaw) throw new Error("--agent-profiles is required");
+  const agentCwd = resolve(values["agent-cwd"] ?? ".");
+
+  const maxTurnsRaw = values["max-turns"] ?? "20";
+  const maxTurns = maxTurnsRaw === "0" ? 0 : parseInt(maxTurnsRaw, 10);
+
+  // Thread --max-turns into each participant: without this, every facilitated
+  // agent silently falls back to the 50-turn default in facilitator.js even
+  // when the caller raises the budget. Observed in run 26078312414 where
+  // staff-engineer terminated at 51 turns despite --max-turns=200.
+  const agentConfigs = parseAgentProfiles(profilesRaw, agentCwd, maxTurns);
+
+  return {
+    taskContent,
+    taskAmend,
+    agentConfigs,
+    facilitatorCwd: resolve(values["facilitator-cwd"] ?? "."),
+    agentModel: values["agent-model"] || AGENT_MODEL,
+    facilitatorModel: values["lead-model"] || LEAD_MODEL,
+    maxTurns,
+    outputPath: values.output,
+    facilitatorProfile: values["lead-profile"] ?? undefined,
+    workTracker: resolveWorkTracker(values, runtime?.proc?.env),
+  };
+}
+
+/**
+ * Facilitate command — run a facilitated multi-agent session.
+ *
+ * Usage: fit-harness facilitate [options]
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: boolean, code?: number, error?: string}>}
+ */
+export async function runFacilitateCommand(ctx) {
+  const runtime = ctx.deps.runtime;
+  const opts = parseFacilitateOptions(ctx.options, runtime);
+
+  // Build the redactor as the first observable side-effect after option
+  // parsing — the env snapshot must freeze BEFORE any in-process
+  // env writes the command performs (e.g. LIBHARNESS_AGENT_PROFILE).
+  const redactor = createRedactor({ runtime });
+
+  const fileStream = 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;
+
+  if (opts.facilitatorProfile) {
+    runtime.proc.env.LIBHARNESS_AGENT_PROFILE = opts.facilitatorProfile;
+  }
+  // Unconditional so the default "github" is observable to the agent's
+  // active-tracker resolution, mirroring --agent-profile's env write above.
+  runtime.proc.env.LIBHARNESS_WORK_TRACKER = opts.workTracker;
+
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  const facilitator = createFacilitator({
+    facilitatorCwd: opts.facilitatorCwd,
+    agentConfigs: opts.agentConfigs,
+    query,
+    output,
+    agentModel: opts.agentModel,
+    facilitatorModel: opts.facilitatorModel,
+    maxTurns: opts.maxTurns,
+    facilitatorProfile: opts.facilitatorProfile,
+    taskAmend: opts.taskAmend,
+    redactor,
+    runtime,
+  });
+
+  const result = await facilitator.run(opts.taskContent);
+
+  if (fileStream) {
+    await new Promise((r) => output.end(r));
+    await new Promise((r) => fileStream.end(r));
+  }
+
+  return result.success ? { ok: true } : { ok: false, code: 1, error: "" };
+}

package/src/commands/output.js

@@ -0,0 +1,36 @@
+import { isoTimestamp } from "@forwardimpact/libutil";
+import { createTraceCollector } from "@forwardimpact/libharness";
+
+/**
+ * Output command — process a complete NDJSON trace from stdin and write
+ * formatted output to stdout.
+ *
+ * Usage: fit-harness output [--format=json|text] < trace.ndjson
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: true}>}
+ */
+export async function runOutputCommand(ctx) {
+  const values = ctx.options;
+  const runtime = ctx.deps.runtime;
+  const format =
+    values.format === "text" || values.format === "json"
+      ? values.format
+      : "json";
+  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.
+  for await (const line of runtime.proc.stdin) {
+    collector.addLine(line);
+  }
+
+  if (format === "text") {
+    runtime.proc.stdout.write(collector.toText() + "\n");
+  } else {
+    runtime.proc.stdout.write(JSON.stringify(collector.toJSON()) + "\n");
+  }
+  return { ok: true };
+}

package/src/commands/run.js

@@ -0,0 +1,152 @@
+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";
+import { createTeeWriter } from "../tee-writer.js";
+import { SequenceCounter } from "../sequence-counter.js";
+import { resolveWorkTracker } from "./work-tracker.js";
+import { resolveTaskContent } from "./task-input.js";
+import { createServiceConfig } from "@forwardimpact/libconfig";
+import { AGENT_MODEL } from "@forwardimpact/libutil/models";
+
+/**
+ * Parse and validate run command options from parsed values.
+ * @param {object} values - Parsed option values from cli.parse()
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
+ * @returns {{ taskContent: string, cwd: string, model: string, maxTurns: number, outputPath: string|undefined, agentProfile: string|undefined, workTracker: string, allowedTools: string[] }}
+ */
+export function parseRunOptions(values, runtime) {
+  const { task: taskContent, amend: taskAmend } = resolveTaskContent(
+    values,
+    runtime,
+  );
+  const maxTurnsRaw = values["max-turns"] ?? "50";
+
+  return {
+    taskContent,
+    taskAmend,
+    cwd: resolve(values.cwd ?? "."),
+    agentModel: values["agent-model"] || AGENT_MODEL,
+    maxTurns: maxTurnsRaw === "0" ? 0 : parseInt(maxTurnsRaw, 10),
+    outputPath: values.output,
+    agentProfile: values["agent-profile"] ?? undefined,
+    workTracker: resolveWorkTracker(values, runtime?.proc?.env),
+    allowedTools: (
+      values["allowed-tools"] ??
+      "Bash,Read,Glob,Grep,Write,Edit,Agent,TodoWrite"
+    ).split(","),
+    mcpServer: values["mcp-server"] ?? undefined,
+  };
+}
+
+/**
+ * Run command — execute a single agent via the Claude Agent SDK.
+ *
+ * Usage: fit-harness run [options]
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: boolean, code?: number, error?: string}>}
+ */
+export async function runRunCommand(ctx) {
+  const runtime = ctx.deps.runtime;
+  const {
+    taskContent,
+    taskAmend,
+    cwd,
+    agentModel,
+    maxTurns,
+    outputPath,
+    agentProfile,
+    workTracker,
+    allowedTools,
+    mcpServer,
+  } = parseRunOptions(ctx.options, runtime);
+
+  // Build the redactor as the first observable side-effect after option
+  // parsing — the env snapshot must freeze BEFORE any in-process
+  // env writes the command performs (e.g. LIBHARNESS_AGENT_PROFILE).
+  const redactor = createRedactor({ runtime });
+
+  // When --output is specified, stream text to stdout while writing NDJSON to file.
+  // Otherwise, write NDJSON directly to stdout (backwards-compatible).
+  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;
+
+  const counter = new SequenceCounter();
+  const devNull = new Writable({
+    write(_chunk, _enc, cb) {
+      cb();
+    },
+  });
+  const onLine = (line) => {
+    const event = JSON.parse(line);
+    const tagged = { source: "agent", seq: counter.next(), event };
+    output.write(JSON.stringify(redactor.redactValue(tagged)) + "\n");
+  };
+
+  let mcpServers = null;
+  if (mcpServer) {
+    const mcpConfig = await createServiceConfig("mcp");
+    mcpServers = {
+      [mcpServer]: {
+        type: "http",
+        url: mcpConfig.url,
+        headers: { Authorization: `Bearer ${mcpConfig.mcpToken()}` },
+      },
+    };
+    allowedTools.push(`mcp__${mcpServer}__*`);
+  }
+
+  if (agentProfile) {
+    runtime.proc.env.LIBHARNESS_AGENT_PROFILE = agentProfile;
+  }
+  // Unconditional so the default "github" is observable to the agent's
+  // active-tracker resolution, mirroring --agent-profile's env write above.
+  runtime.proc.env.LIBHARNESS_WORK_TRACKER = workTracker;
+
+  const systemPrompt = agentProfile
+    ? composeProfilePrompt(agentProfile, {
+        profilesDir: resolve(cwd, ".claude/agents"),
+        runtime,
+      })
+    : undefined;
+
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  const runner = createAgentRunner({
+    cwd,
+    query,
+    output: devNull,
+    model: agentModel,
+    maxTurns,
+    allowedTools,
+    onLine,
+    settingSources: ["project"],
+    systemPrompt,
+    taskAmend,
+    mcpServers,
+    redactor,
+    runtime,
+  });
+
+  const result = await runner.run(taskContent);
+
+  if (fileStream) {
+    await new Promise((r) => output.end(r));
+    await new Promise((r) => fileStream.end(r));
+  }
+
+  return result.success
+    ? { ok: true }
+    : { ok: false, code: 1, error: result.error?.message ?? "" };
+}