"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2465,

    "filesScanned": 2466,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:d54f284f2e5b93477ae762b1e4ca044f5be9959a7496e1e3fb4933e29b74c68b",

  "sourceDigest": "sha256:2c21c17d2d8df32e49231085ac25061a9ed63bac9c4b0aae149a6904dd2972c5",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/openagents-cli (61 tracked test files)"

          "ref": "packages/openagents-cli (62 tracked test files)"

        },

        {

          "type": "behavior-contract",

import {

  CHILD_MODELS,

  childLaneName,

  ClaudeCodeHarness,

  DelegateFleet,

  DevinHarness,

  describePrompt,

        // it. `fleetFor` refuses the lane rather than falling through to a

        // different agent under the name the caller asked for.

        new SelfHarness({ grant: nonNullGrant(options.grant) })

      : /^devin(:.+)?$/.test(choice)

        ? new DevinHarness(choice.startsWith("devin:") ? { permissionMode: choice.slice(6) } : {})

        : new OpencodeHarness({

            model: choice,

            ...(command === undefined ? {} : { command }),

            ...(namedConfig === undefined ? {} : { configPath: namedConfig }),

            autoApprove: options.autoApprove,

          });

      : /^claude(:.+)?$/.test(choice)

        ? new ClaudeCodeHarness(

            choice.startsWith("claude:") ? { model: choice.slice(7) } : {},

          )

        : /^devin(:.+)?$/.test(choice)

          ? new DevinHarness(choice.startsWith("devin:") ? { permissionMode: choice.slice(6) } : {})

          : new OpencodeHarness({

              model: choice,

              ...(command === undefined ? {} : { command }),

              ...(namedConfig === undefined ? {} : { configPath: namedConfig }),

              autoApprove: options.autoApprove,

            });

    return {

      fleet: new DelegateFleet(registry, harness, {

  // and the skill that documents it is not documenting a thing that fails.

  const askedFor = named === undefined ? undefined : resolveChildLane(named);

  if (askedFor !== undefined && /^claude(:(.+))?$/.test(askedFor)) {

    const model = /^claude:(.+)$/.exec(askedFor)?.[1];

    const lane = laneFor(model === undefined ? "claude" : `claude:${model}`);

    return {

      delegation: { registry, ...lane, models: CHILD_MODELS, fleetFor },

      close: () => Promise.resolve(),

    };

  }

  if (askedFor !== undefined && /^devin(:(.+))?$/.test(askedFor)) {

    const mode = /^devin:(.+)$/.exec(askedFor)?.[1];

    const lane = laneFor(mode === undefined ? "devin" : `devin:${mode}`);

import { runDevinAcp } from "./coder-devin-acp.js";

import { tmpdir } from "node:os";

import { join } from "node:path";

import { dirname, join } from "node:path";

import type { CoderTaskId, CoderTaskRegistry, CoderToolActivity } from "./coder-tasks.js";

/** What the console asks for. One shape whether it wants one child or fifteen. */

 * which says nothing about the provider refusal, the missing credential, or the

 * unreachable endpoint that actually happened.

 */

/**

 * Read one line of `claude -p --output-format stream-json --verbose` output.

 *

 * Claude's stream-json is newline-delimited and shaped for its own SDK, not for

 * this fleet. The mapping is deliberately lossy: this fleet only needs to show

 * that the child started, what it is doing, what it said, and how many tokens

 * it used. Everything else — `thinking` blocks, per-tool results, `rate_limit`

 * events, cost in dollars, cache accounting, and message-level `usage` that

 * does not carry a complete `input_tokens`/`output_tokens` pair — is ignored.

 *

 * Mapped:

 *   - `system` `init`       -> `session` (session_id only)

 *   - `assistant` text      -> `text`

 *   - `assistant` tool_use  -> `tool` (callId, name, target from input)

 *   - `result` usage        -> `tokens`

 *   - `result` is_error     -> `error`

 *   - `stream_event` text_delta -> `text`

 *   - `stream_event` tool start -> `tool`

 *   - `error`               -> `error`

 *

 * Not mapped:

 *   - `thinking` blocks

 *   - `user` tool_result messages

 *   - `stream_event` thinking_delta / input_json_delta / message_stop

 *   - `rate_limit_event`

 *   - model, cost, and cache fields when the harness did not request a model

 */

export function parseClaudeEvent(line: string): DelegateEvent | undefined {

  const trimmed = line.trim();

  if (trimmed.length === 0 || !trimmed.startsWith("{")) return undefined;

  let event: Record<string, unknown>;

  try {

    event = JSON.parse(trimmed) as Record<string, unknown>;

  } catch {

    return undefined;

  }

  const type = stringField(event, "type");

  if (type === "system" && stringField(event, "subtype") === "init") {

    const sessionId = stringField(event, "session_id");

    if (sessionId !== undefined) return { type: "session", sessionId };

    return undefined;

  }

  if (type === "assistant") {

    const message = isRecord(event["message"]) ? event["message"] : undefined;

    const content = Array.isArray(message?.["content"]) ? (message["content"] as unknown[]) : undefined;

    if (content !== undefined && content.length > 0) {

      const first = isRecord(content[0]) ? content[0] : {};

      const blockType = stringField(first, "type");

      if (blockType === "text") {

        const value = stringField(first, "text");

        if (value !== undefined) return { type: "text", value };

      }

      if (blockType === "tool_use") {

        const callId = stringField(first, "id") ?? "tool";

        const name = stringField(first, "name") ?? "tool";

        const input = isRecord(first["input"]) ? first["input"] : {};

        return { type: "tool", callId, name, target: claudeTarget(input) };

      }

    }

    const usage = isRecord(message?.["usage"]) ? message["usage"] : undefined;

    if (usage !== undefined) {

      const input = numberField(usage, "input_tokens");

      const output = numberField(usage, "output_tokens");

      if (input !== undefined && output !== undefined) return { type: "tokens", input, output };

    }

    return undefined;

  }

  if (type === "result") {

    if (event["is_error"] === true) {

      const message =

        stringField(event, "error") ??

        stringField(event, "result") ??

        "the child agent reported an error";

      return { type: "error", message };

    }

    const usage = isRecord(event["usage"]) ? event["usage"] : undefined;

    if (usage !== undefined) {

      const input = numberField(usage, "input_tokens");

      const output = numberField(usage, "output_tokens");

      if (input !== undefined && output !== undefined) return { type: "tokens", input, output };

    }

    const resultText = stringField(event, "result");

    if (resultText !== undefined && resultText.length > 0) return { type: "text", value: resultText };

    return undefined;

  }

  if (type === "stream_event") {

    const inner = isRecord(event["event"]) ? event["event"] : {};

    const eventType = stringField(inner, "type");

    if (eventType === "content_block_delta") {

      const delta = isRecord(inner["delta"]) ? inner["delta"] : {};

      const deltaType = stringField(delta, "type");

      if (deltaType === "text_delta") {

        const value = stringField(delta, "text");

        if (value !== undefined && value.length > 0) return { type: "text", value };

      }

    }

    if (eventType === "content_block_start") {

      const contentBlock = isRecord(inner["content_block"]) ? inner["content_block"] : {};

      const blockType = stringField(contentBlock, "type");

      if (blockType === "tool_use") {

        const callId = stringField(contentBlock, "id") ?? "tool";

        const name = stringField(contentBlock, "name") ?? "tool";

        const input = isRecord(contentBlock["input"]) ? contentBlock["input"] : {};

        return { type: "tool", callId, name, target: claudeTarget(input) };

      }

      if (blockType === "text") {

        const value = stringField(contentBlock, "text");

        if (value !== undefined && value.length > 0) return { type: "text", value };

      }

    }

    if (eventType === "message_delta") {

      const usage = isRecord(inner["usage"]) ? inner["usage"] : undefined;

      if (usage !== undefined) {

        const input = numberField(usage, "input_tokens");

        const output = numberField(usage, "output_tokens");

        if (input !== undefined && output !== undefined) return { type: "tokens", input, output };

      }

    }

    return undefined;

  }

  if (type === "error") {

    const message =

      stringField(event, "message") ??

      stringField(event, "error") ??

      "the child agent reported an error";

    return { type: "error", message };

  }

  return undefined;

}

/** The phrase a Claude tool_use block is working on. */

function claudeTarget(input: Record<string, unknown>): string | undefined {

  for (const key of [

    "command",

    "file_path",

    "path",

    "file",

    "url",

    "pattern",

    "query",

    "description",

    "tool_use_id",

    "content",

    "text",

  ]) {

    const value = stringField(input, key);

    if (value !== undefined && value.length > 0) return value;

  }

  return undefined;

}

function describeHarnessError(event: Record<string, unknown>): string {

  const error = isRecord(event["error"]) ? event["error"] : {};

  const data = isRecord(error["data"]) ? error["data"] : {};

 * Resolved against what the harness actually lists, so a name that goes away

 * falls through to the next rather than failing a fan-out.

 */

export interface ClaudeCodeHarnessOptions {

  /** The binary. Defaults to `claude`. */

  readonly command?: string | undefined;

  /** The model name passed to `--model`. If unset, the harness reports `not reported`. */

  readonly model?: string | undefined;

  /** The permission mode. Defaults to `auto` for unattended runs. */

  readonly permissionMode?: string | undefined;

  /** A hard cap on turns. Defaults to 50. */

  readonly maxTurns?: number | undefined;

  /** Extra environment for the child. */

  readonly env?: Readonly<Record<string, string | undefined>> | undefined;

}

/**

 * Children run by the Claude Code CLI.

 *

 * Claude Code's `claude -p --output-format stream-json --verbose` is a one-shot

 * headless mode that emits newline-delimited JSON events. This harness drives it

 * the same way the fleet drives opencode and Devin: it streams events, writes

 * the raw transcript, and can be stopped cleanly.

 *

 * It inherits the user's `claude` environment and credentials. It does not read,

 * copy, or forward any Claude credentials from this process.

 */

export class ClaudeCodeHarness implements DelegateHarness {

  readonly agent = "claude";

  readonly model: string;

  constructor(private readonly options: ClaudeCodeHarnessOptions = {}) {

    // Claude's own configuration or the init event may choose the model. Only

    // report one the caller explicitly passed.

    this.model = options.model ?? "not reported";

  }

  async *run(

    input: {

      readonly prompt: string;

      readonly cwd: string;

      readonly transcriptPath: string;

      readonly resumeSessionId?: string | undefined;

    },

    signal: AbortSignal,

  ): AsyncIterable<DelegateEvent> {

    const command = this.options.command ?? "claude";

    // `--print` runs the prompt and exits. `--output-format stream-json`

    // requires `--verbose`. `--permission-mode auto` keeps a delegated child

    // from stopping to ask; `--max-turns` is a guard on runaway cost.

    const args = [

      "-p",

      input.prompt,

      "--output-format",

      "stream-json",

      "--verbose",

      "--permission-mode",

      this.options.permissionMode ?? "auto",

    ];

    if (this.options.model !== undefined) {

      args.push("--model", this.options.model);

    }

    // Claude Code print mode cannot resume an existing session by id, so a

    // resumeSessionId is ignored rather than re-running the prompt on a fresh

    // session and duplicating any work already done.

    void input.resumeSessionId;

    mkdirSync(dirname(input.transcriptPath), { recursive: true });

    const transcript = createWriteStream(input.transcriptPath, { flags: "a" });

    const child = spawn(command, args, {

      cwd: input.cwd,

      env: { ...process.env, ...this.options.env },

      stdio: ["ignore", "pipe", "pipe"],

      detached: true,

    });

    const queue: DelegateEvent[] = [];

    let notify: (() => void) | undefined;

    const wake = () => {

      notify?.();

      notify = undefined;

    };

    let stderr = "";

    let stdout = "";

    let pending = "";

    let reported: string | undefined;

    let exited = false;

    let failure: string | undefined;

    const onAbort = () => {

      killTree(child, "SIGTERM");

      const grace = setTimeout(() => killTree(child, "SIGKILL"), KILL_GRACE_MS);

      grace.unref();

      child.once("close", () => clearTimeout(grace));

    };

    signal.addEventListener("abort", onAbort, { once: true });

    child.stdout.setEncoding("utf8");

    child.stdout.on("data", (chunk: string) => {

      transcript.write(chunk);

      stdout = `${stdout}${chunk}`.slice(-4000);

      pending += chunk;

      let newline = pending.indexOf("\n");

      while (newline >= 0) {

        const line = pending.slice(0, newline);

        pending = pending.slice(newline + 1);

        const event = parseClaudeEvent(line);

        if (event !== undefined) {

          if (event.type === "error") reported = event.message;

          queue.push(event);

        }

        newline = pending.indexOf("\n");

      }

      wake();

    });

    child.stderr.setEncoding("utf8");

    child.stderr.on("data", (chunk: string) => {

      stderr = `${stderr}${chunk}`.slice(-4000);

    });

    child.on("error", (cause: Error) => {

      failure =

        (cause as NodeJS.ErrnoException).code === "ENOENT"

          ? `The \`${command}\` harness is not on the path.`

          : cause.message;

      exited = true;

      wake();

    });

    child.on("close", (code) => {

      const trailing = parseClaudeEvent(pending);

      if (trailing !== undefined) {

        if (trailing.type === "error") reported = trailing.message;

        queue.push(trailing);

      }

      if (failure === undefined && code !== 0 && !signal.aborted) {

        failure = reported ?? describeExit(code, stderr, stdout);

      }

      exited = true;

      wake();

    });

    try {

      while (true) {

        while (queue.length > 0) {

          const event = queue.shift();

          if (event !== undefined) yield event;

        }

        if (exited) break;

        await new Promise<void>((resolve) => {

          notify = resolve;

        });

      }

    } finally {

      signal.removeEventListener("abort", onAbort);

      transcript.end();

    }

    if (failure !== undefined) throw new Error(failure);

  }

}

export const FREE_CHILD_MODELS: ReadonlyArray<string> = [

  // Ox Alpha, free and unlimited while it lasts. The slug says neither `ox`

  // nor `alpha`: opencode's own normalization maps `x-preview-f` to `ox-alpha`

  "ox-alpha": SELF_CHILD_LANE,

  [SELF_CHILD_LANE]: SELF_CHILD_LANE,

  gemini: SELF_CHILD_LANE,

  claude: "claude",

};

/**

    served: "Devin, on its own credentials — it spends nothing of this account's",

    bestFor: "straightforward engineering with a clear shape: a named fix, a test, a migration",

  },

  {

    name: "claude",

    harness: "claude (the Claude Code CLI, its own tools)",

    // Claude Code picks its own model when none is passed, and this lane does

    // not require one. The init event may report a model, but the harness only

    // advertises one the caller asked for.

    model: "not reported",

    served: "Anthropic via Claude Code, on this machine's Claude credentials",

    bestFor: "work that needs Claude's toolset and tolerates its own cost boundary",

  },

];

/** One lane as a line a model can read. */

  ...new Set(Object.keys(CHILD_LANE_ALIASES)),

  ...FREE_CHILD_MODELS,

  "devin",

  "claude",

];

/**

export const resolveChildLane = (name: string): string | undefined => {

  const asked = name.trim();

  if (asked.length === 0) return undefined;

  if (/^claude(:.+)?$/.test(asked)) return asked;

  if (/^devin(:.+)?$/.test(asked)) return asked;

  const aliased = CHILD_LANE_ALIASES[asked];

  if (aliased !== undefined) return aliased;

import { chmodSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import { describe, expect, it } from "vitest";

import {

  ClaudeCodeHarness,

  parseClaudeEvent,

  type DelegateEvent,

} from "../src/coder-delegate.js";

/**

 * A stand-in for `claude -p --output-format stream-json`, so the tests cost

 * nothing and never call out.

 *

 * It emits the JSONL lines the harness expects and, optionally, records the

 * arguments it was called with before exiting.

 */

const fakeClaude = (options: {

  readonly lines?: ReadonlyArray<string>;

  readonly exitCode?: number;

  readonly hang?: boolean;

  readonly recordArgsTo?: string;

} = {}): string => {

  const directory = mkdtempSync(join(tmpdir(), "claude-code-"));

  const script = join(directory, "claude.mjs");

  writeFileSync(

    script,

    `

import { appendFileSync } from "node:fs";

const recordTo = ${JSON.stringify(options.recordArgsTo ?? null)};

if (recordTo) appendFileSync(recordTo, process.argv.slice(2).join(" ") + "\\n");

if (${options.hang === true}) { setInterval(() => {}, 1000); }

${(options.lines ?? [])

  .map((line) => `process.stdout.write(${JSON.stringify(`${line}\n`)});`)

  .join("\n")}

${options.hang === true ? "" : `process.exit(${options.exitCode ?? 0});`}

`,

  );

  const shim = join(directory, "claude-stub");

  writeFileSync(shim, `#!/bin/sh\nexec ${process.execPath} ${script} "$@"\n`);

  chmodSync(shim, 0o755);

  return shim;

};

const collect = async (

  harness: ClaudeCodeHarness,

  cwd = process.cwd(),

): Promise<ReadonlyArray<DelegateEvent>> => {

  const events: DelegateEvent[] = [];

  const transcriptPath = join(mkdtempSync(join(tmpdir(), "claude-t-")), "child.jsonl");

  for await (const event of harness.run(

    { prompt: "do the thing", cwd, transcriptPath },

    new AbortController().signal,

  )) {

    events.push(event);

  }

  return events;

};

describe("parseClaudeEvent", () => {

  it("ignores blank lines, prose, and malformed JSON", () => {

    expect(parseClaudeEvent("")).toBeUndefined();

    expect(parseClaudeEvent("starting…")).toBeUndefined();

    expect(parseClaudeEvent('{"type":"future"}')).toBeUndefined();

    expect(parseClaudeEvent('{"type":"assistan')).toBeUndefined();

  });

  it("reads a system init as a session", () => {

    expect(

      parseClaudeEvent(

        JSON.stringify({

          type: "system",

          subtype: "init",

          session_id: "sess_01",

          model: "sonnet",

          tools: ["Bash"],

        }),

      ),

    ).toEqual({ type: "session", sessionId: "sess_01" });

  });

  it("reads an assistant tool_use block", () => {

    const line = JSON.stringify({

      type: "assistant",

      session_id: "sess_01",

      message: {

        id: "msg_1",

        role: "assistant",

        content: [

          { type: "tool_use", id: "toolu_1", name: "Bash", input: { command: "ls -la" } },

        ],

      },

    });

    expect(parseClaudeEvent(line)).toEqual({

      type: "tool",

      callId: "toolu_1",

      name: "Bash",

      target: "ls -la",

    });

  });

  it("reads an assistant text block", () => {

    expect(

      parseClaudeEvent(

        JSON.stringify({

          type: "assistant",

          session_id: "sess_01",

          message: {

            id: "msg_2",

            role: "assistant",

            content: [{ type: "text", text: "Done." }],

          },

        }),

      ),

    ).toEqual({ type: "text", value: "Done." });

  });

  it("reads token usage from a result", () => {

    expect(

      parseClaudeEvent(

        JSON.stringify({

          type: "result",

          subtype: "success",

          session_id: "sess_01",

          result: "All done.",

          usage: { input_tokens: 150, output_tokens: 30 },

        }),

      ),

    ).toEqual({ type: "tokens", input: 150, output: 30 });

  });

  it("reads a result error as an error", () => {

    expect(

      parseClaudeEvent(

        JSON.stringify({

          type: "result",

          subtype: "error",

          is_error: true,

          error: "Permission denied",

        }),

      ),

    ).toEqual({ type: "error", message: "Permission denied" });

  });

  it("reads a stream_event text delta", () => {

    expect(

      parseClaudeEvent(

        JSON.stringify({

          type: "stream_event",

          event: { type: "content_block_delta", delta: { type: "text_delta", text: "hello" } },

        }),

      ),

    ).toEqual({ type: "text", value: "hello" });

  });

  it("reads a stream_event tool start", () => {

    const line = JSON.stringify({

      type: "stream_event",

      event: {

        type: "content_block_start",

        content_block: { type: "tool_use", id: "toolu_2", name: "Read", input: { file_path: "/tmp/x" } },

      },

    });

    expect(parseClaudeEvent(line)).toEqual({

      type: "tool",

      callId: "toolu_2",

      name: "Read",

      target: "/tmp/x",

    });

  });

});

describe("running children on the Claude Code CLI", () => {

  it("names itself in the fleet, so a Claude child is not mistaken for opencode", () => {

    const harness = new ClaudeCodeHarness();

    expect(harness.agent).toBe("claude");

    expect(harness.model).toBe("not reported");

  });

  it("reports the child's answer as text", async () => {

    const events = await collect(

      new ClaudeCodeHarness({

        command: fakeClaude({

          lines: [

            JSON.stringify({

              type: "system",

              subtype: "init",

              session_id: "sess_01",

              tools: ["Bash"],

            }),

            JSON.stringify({

              type: "assistant",

              session_id: "sess_01",

              message: {

                id: "msg_1",

                role: "assistant",

                content: [{ type: "text", text: "PONG" }],

              },

            }),

            JSON.stringify({

              type: "result",

              subtype: "success",

              session_id: "sess_01",

              result: "PONG",

              usage: { input_tokens: 10, output_tokens: 1 },

            }),

          ],

        }),

      }),

    );

    expect(events.at(-2)).toEqual({ type: "text", value: "PONG" });

    expect(events.at(-1)).toEqual({ type: "tokens", input: 10, output: 1 });

  });

  it("reports what the child is doing while it does it", async () => {

    const events = await collect(

      new ClaudeCodeHarness({

        command: fakeClaude({

          lines: [

            JSON.stringify({

              type: "system",

              subtype: "init",

              session_id: "sess_01",

              tools: ["Bash", "Read"],

            }),

            JSON.stringify({

              type: "assistant",

              session_id: "sess_01",

              message: {

                id: "msg_1",

                role: "assistant",

                content: [

                  { type: "tool_use", id: "toolu_1", name: "Bash", input: { command: "ls -la" } },

                ],

              },

            }),

            JSON.stringify({

              type: "result",

              subtype: "success",

              session_id: "sess_01",

              result: "Done.",

              usage: { input_tokens: 100, output_tokens: 20 },

            }),

          ],

        }),

      }),

    );

    expect(events).toContainEqual({

      type: "tool",

      callId: "toolu_1",

      name: "Bash",

      target: "ls -la",

    });

    expect(events).toContainEqual({ type: "tokens", input: 100, output: 20 });

  });

  it("reports the session, so a retry can resume it", async () => {

    const events = await collect(

      new ClaudeCodeHarness({

        command: fakeClaude({

          lines: [

            JSON.stringify({

              type: "system",

              subtype: "init",

              session_id: "sess_01",

              tools: ["Bash"],

            }),

            JSON.stringify({

              type: "result",

              subtype: "success",

              session_id: "sess_01",

              result: "ok",

              usage: { input_tokens: 5, output_tokens: 1 },

            }),

          ],

        }),

      }),

    );

    expect(events[0]).toEqual({ type: "session", sessionId: "sess_01" });

  });

  it("writes the raw event stream to the transcript as it arrives", async () => {

    const transcriptPath = join(mkdtempSync(join(tmpdir(), "claude-t-")), "child.jsonl");

    const harness = new ClaudeCodeHarness({

      command: fakeClaude({

        lines: [

          JSON.stringify({

            type: "assistant",

            session_id: "sess_01",

            message: {

              id: "msg_1",

              role: "assistant",

              content: [{ type: "text", text: "ok" }],

            },

          }),

        ],

      }),

    });

    for await (const _event of harness.run(

      { prompt: "x", cwd: process.cwd(), transcriptPath },

      new AbortController().signal,

    )) {

      void _event;

    }

    const written = readFileSync(transcriptPath, "utf8");

    expect(written).toContain("ok");

  });

  it("uses print, stream-json, verbose, and a permission mode for unattended runs", async () => {

    const log = join(mkdtempSync(join(tmpdir(), "claude-args-")), "log");

    await collect(

      new ClaudeCodeHarness({

        command: fakeClaude({

          recordArgsTo: log,

          exitCode: 0,

          lines: [

            JSON.stringify({

              type: "result",

              subtype: "success",

              session_id: "sess_01",

              result: "ok",

              usage: { input_tokens: 1, output_tokens: 1 },

            }),

          ],

        }),

      }),

    );

    const said = readFileSync(log, "utf8");

    expect(said).toContain("-p");

    expect(said).toContain("--output-format stream-json");

    expect(said).toContain("--verbose");

    expect(said).toContain("--permission-mode auto");

  });

  it("passes the model through when the lane names one", async () => {

    const log = join(mkdtempSync(join(tmpdir(), "claude-args-")), "log");

    const harness = new ClaudeCodeHarness({

      command: fakeClaude({

        recordArgsTo: log,

        exitCode: 0,

        lines: [

          JSON.stringify({

            type: "result",

            subtype: "success",

            session_id: "sess_01",

            result: "ok",

            usage: { input_tokens: 1, output_tokens: 1 },

          }),

        ],

      }),

      model: "fable",

    });

    await collect(harness);

    expect(harness.model).toBe("fable");

    expect(readFileSync(log, "utf8")).toContain("--model fable");

  });

  it("carries the prompt through as the first positional argument", async () => {

    const log = join(mkdtempSync(join(tmpdir(), "claude-args-")), "log");

    await collect(

      new ClaudeCodeHarness({

        command: fakeClaude({

          recordArgsTo: log,

          exitCode: 0,

          lines: [

            JSON.stringify({

              type: "result",

              subtype: "success",

              session_id: "sess_01",

              result: "ok",

              usage: { input_tokens: 1, output_tokens: 1 },

            }),

          ],

        }),

      }),

    );

    const said = readFileSync(log, "utf8");

    expect(said).toContain("-p do the thing");

  });

  it("reports a Claude result error as a failed child", async () => {

    const harness = new ClaudeCodeHarness({

      command: fakeClaude({

        lines: [

          JSON.stringify({

            type: "result",

            subtype: "error",

            is_error: true,

            error: "the model provider is unavailable",

          }),

        ],

        exitCode: 1,

      }),

    });

    await expect(collect(harness)).rejects.toThrow(/model provider is unavailable/);

  });

  it("throws when the binary is not on PATH, rather than reporting an empty child", async () => {

    await expect(

      collect(new ClaudeCodeHarness({ command: "claude-does-not-exist" })),

    ).rejects.toThrow("not on the path");

  });

  it("stops when the fleet is stopped", async () => {

    const harness = new ClaudeCodeHarness({

      command: fakeClaude({

        hang: true,

        lines: [

          JSON.stringify({

            type: "system",

            subtype: "init",

            session_id: "sess_01",

            tools: ["Bash"],

          }),

        ],

      }),

    });

    const controller = new AbortController();

    const events: DelegateEvent[] = [];

    const transcriptPath = join(mkdtempSync(join(tmpdir(), "claude-t-")), "child.jsonl");

    const running = (async () => {

      for await (const event of harness.run(

        { prompt: "x", cwd: process.cwd(), transcriptPath },

        controller.signal,

      )) {

        events.push(event);

      }

    })();

    controller.abort();

    await running;

    expect(events.every((event) => event.type !== "text")).toBe(true);

  });

});