const own = fromSelfHarness(record);

  if (own !== undefined) return own;

  const acp = fromAcp(record);

  if (acp !== undefined) return acp;

  // Anything else is a harness with its own event stream, and `opencode`'s is

  // the one the fleet already reads live.

  const event = parseOpencodeEvent(trimmed);

  }

};

/**

 * A Devin child, which writes the ACP protocol it spoke.

 *

 * The harness records every JSON-RPC message so a reader can open a running

 * child and watch it work. Most of those messages are not worth showing — the

 * handshake, the mode, dozens of thought fragments a token at a time — so this

 * takes the three that are: what it ran, what came back, and what it said.

 */

const fromAcp = (message: Record<string, unknown>): ChildEntry | undefined => {

  if (message["method"] !== "session/update") return undefined;

  const update = nested(nested(message["params"])["update"]);

  const kind = update["sessionUpdate"];

  if (kind === "tool_call") {

    // Devin's `title` is already the phrase a person would read — "Ran ls",

    // "Read src/a.ts" — so it is the target rather than a name to look up.

    const name = text(update["kind"]) ?? "tool";

    return { kind: "tool", name, target: text(update["title"]) };

  }

  if (kind === "tool_call_update") {

    const said = firstContentText(update["content"]);

    return said === undefined ? undefined : { kind: "output", text: said };

  }

  if (kind === "agent_message_chunk") {

    const said = text(nested(update["content"])["text"]);

    return said === undefined ? undefined : { kind: "text", text: said };

  }

  return undefined;

};

/** The first piece of text inside an ACP content array, if there is one. */

const firstContentText = (content: unknown): string | undefined => {

  if (!Array.isArray(content)) return undefined;

  for (const part of content) {

    const inner = nested(nested(part)["content"]);

    const said = text(inner["text"]);

    if (said !== undefined) return said;

  }

  return undefined;

};

const nested = (value: unknown): Record<string, unknown> =>

  typeof value === "object" && value !== null && !Array.isArray(value)

    ? (value as Record<string, unknown>)

    : {};

const fromSelfHarness = (record: Record<string, unknown>): ChildEntry | undefined => {

  const type = record["type"];

import type { ChildProcess } from "node:child_process";

import { execFileSync, spawn } from "node:child_process";

import { createWriteStream, mkdirSync } from "node:fs";

import { appendFileSync, createWriteStream, mkdirSync } from "node:fs";

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

import { tmpdir } from "node:os";

import { join } from "node:path";

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

  readonly model: string;

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

    // Devin picks its own model from its own configuration, and print mode does

    // not report which. Naming one here would be inventing it.

    // Devin picks its own model from its own configuration, and neither print

    // mode nor ACP reports which. Naming one here would be inventing it.

    this.model = options.permissionMode ?? "dangerous";

  }

  /**

   * Run the child over ACP rather than print mode.

   *

   * `devin -p` writes nothing until it finishes — measured: fourteen seconds of

   * silence for a one-word answer, and `--export` is written at close too. A

   * child doing four minutes of real work reported no tool calls, no tokens,

   * and no transcript, so the fleet showed `Initializing…` for the whole run

   * and a reader could not tell it from a hang. `devin acp` is the same agent

   * streaming the events the fleet already draws.

   */

  async *run(

    input: {

      readonly prompt: string;

    },

    signal: AbortSignal,

  ): AsyncIterable<DelegateEvent> {

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

    const mode = this.options.permissionMode ?? "dangerous";

    const child = spawn(

      command,

      [

        "-p",

        input.prompt,

        "--permission-mode",

        mode,

        // Print mode cannot show the trust prompt, so without this a child in a

        // directory nobody has opened Devin in exits before doing anything.

        "--respect-workspace-trust",

        "false",

      ],

      {

        cwd: input.cwd,

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

        // No terminal: a child that would prompt gets end-of-file and stops

        // rather than waiting where the fleet shows it as still working.

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

      },

    );

    const events: DelegateEvent[] = [];

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

    const wake = () => {

      resolveNext?.();

      resolveNext = undefined;

    };

    let answer = "";

    let failure = "";

    let done = false;

    let startFailure: Error | undefined;

    child.stdout.setEncoding("utf8");

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

      answer += chunk;

    });

    child.stderr.setEncoding("utf8");

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

      failure += chunk;

    });

    const onAbort = () => child.kill("SIGKILL");

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

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

      startFailure =

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

          ? new Error(`The \`${command}\` command is not on PATH.`)

          : cause;

      done = true;

      wake();

    });

    child.on("close", (code: number | null) => {

      const text = answer.trim();

      if (code === 0) {

        if (text.length > 0) events.push({ type: "text", value: text });

      } else {

        const said = `${failure.trim()}\n${text}`.trim();

        events.push({

          type: "error",

          message:

            said.length > 0

              ? said

              : `The \`${command}\` child exited with code ${String(code ?? -1)}.`,

        });

      }

      done = true;

      wake();

    });

    try {

      for (;;) {

        while (events.length > 0) {

          const next = events.shift();

          if (next !== undefined) yield next;

        }

        if (done) break;

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

          resolveNext = resolve;

        });

      }

      yield* runDevinAcp(

        { prompt: input.prompt, cwd: input.cwd },

        {

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

          ...(this.options.env === undefined ? {} : { env: this.options.env }),

          // Devin's own word for what this harness has always called a

          // permission mode. `bypass` is its `dangerous`.

          mode: DEVIN_MODES[this.options.permissionMode ?? "dangerous"] ?? "bypass",

          // Appended synchronously as each message arrives, not through a

          // stream: a stream's `end()` does not flush before the next line of

          // this process runs, so a child read the instant it finished showed

          // a transcript missing everything it had just done.

          record: (entry) => {

            try {

              appendFileSync(input.transcriptPath, `${JSON.stringify(entry)}\n`);

            } catch {

              // A transcript that cannot be written must not end the child.

            }

          },

        },

        signal,

      );

    } finally {

      signal.removeEventListener("abort", onAbort);

      // Nothing to close: every line was already on disk.

    }

    if (startFailure !== undefined) throw startFailure;

  }

}

/**

 * The old permission-mode names, mapped to the session modes ACP offers.

 *

 * `devin -p --permission-mode dangerous` and a `bypass` ACP session are the

 * same posture, and a caller that wrote the old name should not have to learn

 * the new one.

 */

const DEVIN_MODES: Readonly<Record<string, string>> = {

  dangerous: "bypass",

  bypass: "bypass",

  auto: "accept-edits",

  "accept-edits": "accept-edits",

  ask: "ask",

  plan: "plan",

  smart: "smart",

};

/**

 * The models a child is given, in the order they are preferred.

 *

import { spawn } from "node:child_process";

import type { DelegateEvent } from "./coder-delegate.js";

/**

 * A Devin child over ACP, so the fleet can see it working.

 *

 * Devin's print mode (`devin -p`) is a black box. It writes nothing to stdout

 * until the very end — measured: fourteen seconds of silence, then the whole

 * answer at once — and `--export` is written at close too. A child doing four

 * minutes of real work therefore reported no tool calls, no tokens, and no

 * transcript, so the fleet showed `Initializing…` for the whole run and a

 * reader could not tell it from a hang.

 *

 * `devin acp` is the same agent as an Agent Client Protocol server over stdio,

 * and it streams: `tool_call` with a title, `tool_call_update` with a status,

 * `usage_update` with real token counts, and `agent_message_chunk` for the

 * answer. That is every event the fleet already knows how to draw.

 *

 * Newline-delimited JSON-RPC, and one server per child. A shared server would

 * save a process per child and cost a lifecycle nobody asked for: a crash

 * would take every child with it, and a child that hangs would hold the

 * server's queue.

 *

 * Devin logs heavily to stderr and none of it is protocol. It is drained and

 * dropped rather than parsed.

 */

/** What a running Devin child reports, normalized. */

export interface DevinAcpOptions {

  readonly command?: string | undefined;

  /**

   * The session mode, which is Devin's own word for what the old harness passed

   * as `--permission-mode`. `bypass` is the equivalent of `dangerous`.

   */

  readonly mode?: string | undefined;

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

  /** Every protocol message, for the transcript. */

  readonly record?: ((entry: Record<string, unknown>) => void) | undefined;

}

interface Pending {

  readonly resolve: (result: Record<string, unknown>) => void;

  readonly reject: (cause: Error) => void;

}

export async function* runDevinAcp(

  input: { readonly prompt: string; readonly cwd: string },

  options: DevinAcpOptions,

  signal: AbortSignal,

): AsyncIterable<DelegateEvent> {

  const command = options.command ?? "devin";

  const child = spawn(command, ["acp"], {

    cwd: input.cwd,

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

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

    // Its own process group, so stopping a child stops what the child started.

    detached: true,

  });

  // Devin's own logging. Not protocol, and it is a lot of it.

  child.stderr.resume();

  const events: DelegateEvent[] = [];

  const pending = new Map<number, Pending>();

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

  let finished = false;

  let failure: Error | undefined;

  let sequence = 0;

  let buffer = "";

  let answer = "";

  const nudge = () => {

    wake?.();

    wake = undefined;

  };

  const send = (method: string, params?: Record<string, unknown>) =>

    new Promise<Record<string, unknown>>((resolve, reject) => {

      const id = (sequence += 1);

      pending.set(id, { resolve, reject });

      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);

    });

  const reply = (id: number, result: Record<string, unknown>) => {

    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);

  };

  child.stdout.setEncoding("utf8");

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

    buffer += chunk;

    for (;;) {

      const at = buffer.indexOf("\n");

      if (at === -1) break;

      const line = buffer.slice(0, at).trim();

      buffer = buffer.slice(at + 1);

      if (line.length === 0) continue;

      let message: Record<string, unknown>;

      try {

        message = JSON.parse(line) as Record<string, unknown>;

      } catch {

        // Not protocol. Devin writes plain lines too.

        continue;

      }

      options.record?.(message);

      handle(message);

    }

    nudge();

  });

  const handle = (message: Record<string, unknown>) => {

    const id = message["id"];

    // A reply to something asked for.

    if (typeof id === "number" && message["method"] === undefined) {

      const waiting = pending.get(id);

      pending.delete(id);

      if (waiting === undefined) return;

      const error = message["error"];

      if (error !== undefined) {

        waiting.reject(new Error(`Devin refused ${JSON.stringify(error).slice(0, 200)}`));

      } else {

        waiting.resolve((message["result"] ?? {}) as Record<string, unknown>);

      }

      return;

    }

    const method = message["method"];

    // A request from the agent. The only one that matters is permission, and a

    // delegated child has no one to ask: it was launched to run unattended, so

    // an unanswered request would hang it for as long as the reader left it.

    if (typeof id === "number" && method === "session/request_permission") {

      const params = record(message["params"]);

      const chosen = firstAllowOption(params);

      reply(id, {

        outcome:

          chosen === undefined

            ? { outcome: "cancelled" }

            : { outcome: "selected", optionId: chosen },

      });

      return;

    }

    if (method !== "session/update") return;

    const update = record(record(message["params"])["update"]);

    const kind = update["sessionUpdate"];

    if (kind === "tool_call") {

      const callId = text(update["toolCallId"]) ?? `devin_${String(events.length)}`;

      // Devin's `title` is already the phrase a person would read — "Ran ls",

      // "Read src/a.ts" — so it is the activity rather than a name to look up.

      events.push({

        type: "tool",

        callId,

        name: text(update["kind"]) ?? "tool",

        target: text(update["title"]),

      });

      return;

    }

    if (kind === "usage_update") {

      const meta = record(update["_meta"]);

      const input_tokens = number(meta["cognition.ai/inputTokens"]);

      const output_tokens = number(meta["cognition.ai/outputTokens"]);

      if (input_tokens !== undefined && output_tokens !== undefined) {

        events.push({ type: "tokens", input: input_tokens, output: output_tokens });

      }

      return;

    }

    if (kind === "agent_message_chunk") {

      const piece = text(record(update["content"])["text"]);

      if (piece !== undefined) answer += piece;

    }

  };

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

    failure =

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

        ? new Error(`The \`${command}\` command is not on PATH.`)

        : cause;

    finished = true;

    nudge();

  });

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

    finished = true;

    for (const waiting of pending.values()) {

      waiting.reject(new Error("The Devin agent exited before it answered."));

    }

    pending.clear();

    nudge();

  });

  const stop = () => {

    try {

      process.kill(-child.pid!, "SIGKILL");

    } catch {

      child.kill("SIGKILL");

    }

  };

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

  // The conversation, driven from here while the generator yields whatever the

  // agent has said since the last time it was asked.

  const turn = (async () => {

    await send("initialize", {

      protocolVersion: 1,

      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } },

    });

    const opened = await send("session/new", { cwd: input.cwd, mcpServers: [] });

    const sessionId = text(opened["sessionId"]);

    if (sessionId === undefined) throw new Error("Devin opened no session.");

    events.push({ type: "session", sessionId });

    const mode = options.mode;

    if (mode !== undefined) {

      // Best effort. A build of Devin without this mode should not lose the

      // child over the name of a permission setting.

      await send("session/set_mode", { sessionId, modeId: mode }).catch(() => ({}));

    }

    await send("session/prompt", {

      sessionId,

      prompt: [{ type: "text", text: input.prompt }],

    });

  })();

  turn.catch((cause: unknown) => {

    // Whichever failure came first. A missing binary raises `error` and then

    // `close`, and the close rejects everything still pending — so taking the

    // later one reports "the agent exited before it answered" for a command

    // that was never there.

    failure ??= cause instanceof Error ? cause : new Error(String(cause));

  });

  const settled = turn.then(

    () => {

      finished = true;

      nudge();

    },

    () => {

      finished = true;

      nudge();

    },

  );

  try {

    for (;;) {

      while (events.length > 0) {

        const event = events.shift();

        if (event !== undefined) yield event;

      }

      if (finished) break;

      if (signal.aborted) return;

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

        wake = resolve;

      });

    }

    await settled;

    // A stopped fleet is not a failed child. Killing the agent closes its

    // stdio, which rejects everything still in flight, and reporting that as

    // an error would make every `ctrl+x` look like a crash.

    if (signal.aborted) return;

    if (failure !== undefined) {

      yield { type: "error", message: failure.message };

      throw failure;

    }

    const said = answer.trim();

    if (said.length > 0) yield { type: "text", value: said };

  } finally {

    signal.removeEventListener("abort", stop);

    stop();

  }

}

/** The option a permission request offers that lets the work continue. */

const firstAllowOption = (params: Record<string, unknown>): string | undefined => {

  const options = params["options"];

  if (!Array.isArray(options)) return undefined;

  const ranked = options

    .map((option) => record(option))

    .filter((option) => text(option["optionId"]) !== undefined);

  const allow = ranked.find((option) => String(option["kind"] ?? "").startsWith("allow"));

  return text((allow ?? ranked[0] ?? {})["optionId"]);

};

const record = (value: unknown): Record<string, unknown> =>

  typeof value === "object" && value !== null && !Array.isArray(value)

    ? (value as Record<string, unknown>)

    : {};

const text = (value: unknown): string | undefined =>

  typeof value === "string" && value.length > 0 ? value : undefined;

const number = (value: unknown): number | undefined =>

  typeof value === "number" && Number.isFinite(value) ? value : undefined;

    expect(readChildTranscript(undefined)).toEqual([]);

  });

});

describe("reading a child Devin ran", () => {

  it("reads the ACP protocol the Devin harness records", () => {

    const path = transcript([

      { jsonrpc: "2.0", id: 1, result: { protocolVersion: 1 } },

      {

        jsonrpc: "2.0",

        method: "session/update",

        params: {

          sessionId: "s",

          update: {

            sessionUpdate: "tool_call",

            toolCallId: "functions.exec:0",

            title: "Ran ls",

            kind: "execute",

          },

        },

      },

      {

        jsonrpc: "2.0",

        method: "session/update",

        params: {

          sessionId: "s",

          update: {

            sessionUpdate: "tool_call_update",

            toolCallId: "functions.exec:0",

            status: "in_progress",

            content: [{ type: "content", content: { type: "text", text: "a.txt" } }],

          },

        },

      },

      {

        jsonrpc: "2.0",

        method: "session/update",

        params: {

          sessionId: "s",

          update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "done" } },

        },

      },

    ]);

    expect(readChildTranscript(path)).toEqual([

      { kind: "tool", name: "execute", target: "Ran ls" },

      { kind: "output", text: "a.txt" },

      { kind: "text", text: "done" },

    ]);

  });

  it("shows none of the handshake, and none of the thinking a token at a time", () => {

    // A Devin child writes hundreds of messages and three kinds are worth

    // reading. Showing the rest would bury what it actually did.

    const path = transcript([

      { jsonrpc: "2.0", id: 2, result: { sessionId: "ses_x" } },

      {

        jsonrpc: "2.0",

        method: "session/update",

        params: {

          sessionId: "s",

          update: { sessionUpdate: "agent_thought_chunk", content: { type: "text", text: "hmm" } },

        },

      },

      { jsonrpc: "2.0", method: "_cognition.ai/output", params: { message: "Connecting to MCP" } },

    ]);

    expect(readChildTranscript(path)).toEqual([]);

  });

});

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

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 { DevinHarness, type DelegateEvent } from "../src/coder-delegate.js";

/** A stand-in for the binary, so the tests cost nothing and never call out. */

const fake = (script: string): string => {

  const directory = mkdtempSync(join(tmpdir(), "devin-harness-"));

  const path = join(directory, "devin-stub");

  writeFileSync(path, `#!/bin/sh\n${script}\n`);

  chmodSync(path, 0o755);

  return path;

/**

 * A stand-in for `devin acp`, so the tests cost nothing and never call out.

 *

 * It speaks the protocol the harness speaks: newline-delimited JSON-RPC on

 * stdio, replying to `initialize`, `session/new`, and `session/prompt`, and

 * sending whatever `session/update` notifications the test asks for.

 */

const fakeAgent = (options: {

  readonly updates?: ReadonlyArray<Record<string, unknown>>;

  readonly answer?: string;

  readonly failPrompt?: string;

  readonly hang?: boolean;

  readonly recordArgsTo?: string;

} = {}): string => {

  const directory = mkdtempSync(join(tmpdir(), "devin-acp-"));

  const script = join(directory, "agent.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); }

let buffer = "";

const write = (m) => process.stdout.write(JSON.stringify(m) + "\\n");

process.stdin.setEncoding("utf8");

process.stdin.on("data", (chunk) => {

  buffer += chunk;

  for (;;) {

    const at = buffer.indexOf("\\n");

    if (at === -1) break;

    const line = buffer.slice(0, at).trim();

    buffer = buffer.slice(at + 1);

    if (!line) continue;

    const m = JSON.parse(line);

    if (recordTo) appendFileSync(recordTo, m.method + " " + JSON.stringify(m.params ?? {}) + "\\n");

    if (m.method === "initialize") write({ jsonrpc: "2.0", id: m.id, result: { protocolVersion: 1 } });

    else if (m.method === "session/new") write({ jsonrpc: "2.0", id: m.id, result: { sessionId: "ses_test" } });

    else if (m.method === "session/set_mode") write({ jsonrpc: "2.0", id: m.id, result: {} });

    else if (m.method === "session/prompt") {

      for (const update of ${JSON.stringify(options.updates ?? [])})

        write({ jsonrpc: "2.0", method: "session/update", params: { sessionId: "ses_test", update } });

      ${

        options.answer === undefined

          ? ""

          : `write({ jsonrpc: "2.0", method: "session/update", params: { sessionId: "ses_test", update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: ${JSON.stringify(options.answer)} } } } });`

      }

      ${

        options.failPrompt === undefined

          ? `write({ jsonrpc: "2.0", id: m.id, result: { stopReason: "end_turn" } });`

          : `write({ jsonrpc: "2.0", id: m.id, error: { code: -32000, message: ${JSON.stringify(options.failPrompt)} } });`

      }

      if (!${options.hang === true}) setTimeout(() => process.exit(0), 10);

    }

  }

});

`,

  );

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

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

  chmodSync(shim, 0o755);

  return shim;

};

const collect = async (

  cwd = process.cwd(),

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

  const events: DelegateEvent[] = [];

  for await (const event of harness.run(

    { prompt: "do the thing", cwd, transcriptPath: join(tmpdir(), "unused.jsonl") },

    new AbortController().signal,

  )) {

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

  for await (const event of harness.run({ prompt: "do the thing", cwd, transcriptPath }, new AbortController().signal)) {

    events.push(event);

  }

  return events;

  });

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

    const events = await collect(new DevinHarness({ command: fake('echo "PONG"') }));

    const events = await collect(new DevinHarness({ command: fakeAgent({ answer: "PONG" }) }));

    expect(events).toEqual([{ type: "text", value: "PONG" }]);

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

  });

  it("passes the prompt, the unattended mode, and the trust flag", async () => {

    // Print mode cannot show the trust prompt, so without the flag a child in a

    // directory nobody has opened Devin in exits before doing anything.

    const events = await collect(new DevinHarness({ command: fake('echo "$@"') }));

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

    // The whole reason this harness speaks ACP. In print mode a child doing

    // four minutes of work reported nothing at all until it finished, so the

    // fleet showed `Initializing…` for the entire run and a reader could not

    // tell it from a hang.

    const events = await collect(

      new DevinHarness({

        command: fakeAgent({

          updates: [

            {

              sessionUpdate: "tool_call",

              toolCallId: "functions.exec:0",

              title: "Ran ls",

              kind: "execute",

            },

            {

              sessionUpdate: "usage_update",

              used: 16_086,

              _meta: { "cognition.ai/inputTokens": 16_020, "cognition.ai/outputTokens": 66 },

            },

          ],

          answer: "done",

        }),

      }),

    );

    const said = (events[0] as { value: string }).value;

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

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

    expect(said).toContain("--respect-workspace-trust false");

    expect(events).toContainEqual({

      type: "tool",

      callId: "functions.exec:0",

      name: "execute",

      target: "Ran ls",

    });

    expect(events).toContainEqual({ type: "tokens", input: 16_020, output: 66 });

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

  });

  it("takes a different permission mode when one is asked for", async () => {

    const harness = new DevinHarness({ command: fake('echo "$@"'), permissionMode: "auto" });

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

    const events = await collect(new DevinHarness({ command: fakeAgent({ answer: "x" }) }));

    const said = ((await collect(harness))[0] as { value: string }).value;

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

    // The mode is what the fleet shows beside the agent, because print mode

    // does not report which model answered.

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

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

  });

  it("reports a failing child as an error, with what it said", async () => {

    const events = await collect(

      new DevinHarness({ command: fake('echo "went wrong" >&2; exit 2') }),

    );

  it("writes the protocol to the transcript as it arrives", async () => {

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

    const harness = new DevinHarness({

      command: fakeAgent({

        updates: [

          { sessionUpdate: "tool_call", toolCallId: "c1", title: "Read a.ts", kind: "read" },

        ],

        answer: "ok",

      }),

    });

    for await (const _event of harness.run(

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

      new AbortController().signal,

    )) {

      void _event;

    }

    // A child that is killed still leaves what it had done behind, and opening

    // a running child shows something rather than an empty screen.

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

    expect(written).toContain("Read a.ts");

  });

  it("asks for the unattended session mode, in Devin's own word for it", async () => {

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

    const harness = new DevinHarness({

      command: fakeAgent({ answer: "x", recordArgsTo: log }),

      permissionMode: "dangerous",

    });

    await collect(harness);

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

    expect(said).toContain("acp");

    // `bypass` is ACP's name for what the flag called `dangerous`. A caller

    // that wrote the old name should not have to learn the new one.

    expect(said).toContain(`"modeId":"bypass"`);

    // The mode is what the fleet shows beside the agent, because neither print

    // mode nor ACP reports which model answered.

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

  });

  it("carries the prompt through as a content block", async () => {

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

    await collect(new DevinHarness({ command: fakeAgent({ answer: "x", recordArgsTo: log }) }));

    expect(events).toEqual([{ type: "error", message: "went wrong" }]);

    expect(readFileSync(log, "utf8")).toContain(`"text":"do the thing"`);

  });

  it("says so when a failing child said nothing at all", async () => {

    const events = await collect(new DevinHarness({ command: fake("exit 3") }));

  it("reports a refused prompt as an error rather than an empty child", async () => {

    const harness = new DevinHarness({

      command: fakeAgent({ failPrompt: "the model provider is unavailable" }),

    });

    expect((events[0] as { message: string }).message).toContain("exited with code 3");

    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 () => {

  });

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

    const harness = new DevinHarness({ command: fake("sleep 30") });

    const harness = new DevinHarness({ command: fakeAgent({ hang: true }) });

    const controller = new AbortController();

    const events: DelegateEvent[] = [];

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

    const running = (async () => {

      for await (const event of harness.run(

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

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

        controller.signal,

      )) {

        events.push(event);