"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": 2455,

    "filesScanned": 2456,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:e3bf4b2c23dae0ee9b20eb8a0ce09bae4d32b9b57aa8d94ababaa57716efa9fd",

  "sourceDigest": "sha256:627eb95e2969a269c885d76ea8b1cc3983aa98770237dca8373cbd6a73645bb6",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

import { readFileSync, statSync } from "node:fs";

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

/**

 * A child's own transcript, read back for the interface to show.

 *

 * Every harness writes one as its child runs — the fleet hands each child a

 * path and the harness appends to it, so a child that is killed still leaves

 * everything it had done behind. This reads that file so the reader can open a

 * child and watch it work rather than waiting for the one paragraph it returns

 * at the end.

 *

 * Two shapes arrive here and neither is negotiable. The self-hosted harness

 * writes its own small records (`session`, `tool`, `tool_result`, `text`);

 * `opencode` writes its own event stream, which `parseOpencodeEvent` already

 * knows how to read because the fleet reads it live. Both are normalized to

 * the same handful of entries, so the screen renders one thing.

 *

 * A file is re-read when it has grown and reused when it has not. A child is

 * appended to several times a second and the screen repaints at least as

 * often; re-parsing a finished child's whole transcript on every frame is work

 * that buys nothing.

 */

export type ChildEntry =

  | { readonly kind: "started"; readonly model: string; readonly cwd: string }

  | { readonly kind: "tool"; readonly name: string; readonly target: string | undefined }

  | { readonly kind: "output"; readonly text: string }

  | { readonly kind: "text"; readonly text: string }

  | { readonly kind: "error"; readonly text: string };

interface Cached {

  readonly size: number;

  readonly entries: ReadonlyArray<ChildEntry>;

}

/**

 * What has been read, by path, bounded.

 *

 * A session's children are few, but nothing here prunes on its own and a cache

 * that only grows is one that eventually holds every transcript of a long

 * session in memory. The oldest entry goes when the cap is reached; re-reading

 * it costs one parse.

 */

const CACHE_LIMIT = 32;

const cache = new Map<string, Cached>();

const remember = (path: string, entry: Cached): void => {

  cache.delete(path);

  cache.set(path, entry);

  if (cache.size > CACHE_LIMIT) {

    const oldest = cache.keys().next();

    if (!oldest.done) cache.delete(oldest.value);

  }

};

/**

 * The child's transcript at this path, or an empty list.

 *

 * Never throws. A child that has not written yet, a path that was removed, and

 * a line that is half-written because the harness is mid-append are all the

 * same thing to a reader watching a running child: less than there will be in

 * a moment.

 */

export const readChildTranscript = (path: string | undefined): ReadonlyArray<ChildEntry> => {

  if (path === undefined) return [];

  let size: number;

  try {

    size = statSync(path).size;

  } catch {

    return [];

  }

  const seen = cache.get(path);

  if (seen !== undefined && seen.size === size) return seen.entries;

  let contents: string;

  try {

    contents = readFileSync(path, "utf8");

  } catch {

    return seen?.entries ?? [];

  }

  const entries = contents.split("\n").flatMap((line) => {

    const entry = parseLine(line);

    return entry === undefined ? [] : [entry];

  });

  remember(path, { size, entries });

  return entries;

};

const parseLine = (line: string): ChildEntry | undefined => {

  const trimmed = line.trim();

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

  let record: Record<string, unknown>;

  try {

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

  } catch {

    // A half-written last line, because the harness is appending as this

    // reads. It will parse on the next frame.

    return undefined;

  }

  const own = fromSelfHarness(record);

  if (own !== undefined) return own;

  // 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);

  if (event === undefined) return undefined;

  switch (event.type) {

    case "tool":

      return { kind: "tool", name: event.name, target: event.target };

    case "text":

      return { kind: "text", text: event.value };

    case "error":

      return { kind: "error", text: event.message };

    default:

      return undefined;

  }

};

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

  const type = record["type"];

  if (type === "session") {

    return {

      kind: "started",

      model: text(record["model"]) ?? "unknown",

      cwd: text(record["cwd"]) ?? "",

    };

  }

  if (type === "tool") {

    const name = text(record["name"]);

    if (name === undefined) return undefined;

    return { kind: "tool", name, target: target(record["arguments"]) };

  }

  if (type === "tool_result") {

    const output = text(record["output"]);

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

  }

  if (type === "text") {

    const value = text(record["value"]);

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

  }

  return undefined;

};

/** The one argument worth showing beside a tool's name, if there is one. */

const target = (args: unknown): string | undefined => {

  if (typeof args !== "object" || args === null) return undefined;

  const record = args as Record<string, unknown>;

  for (const key of ["command", "path", "file", "pattern", "query"]) {

    const value = record[key];

    if (typeof value === "string" && value.length > 0) return value;

  }

  return undefined;

};

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

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

          "  shift+tab                   change how hard it thinks",

          "  ctrl+o                      expand a tool call",

          "  ctrl+x                      stop the children",

          "  →                           move into the children column",

          "  ↑↓ · enter · ←              in the column: select · open · leave",

          "  pgup / pgdn                 scroll the transcript",

          "  ctrl+c                      stop · ctrl+d  quit",

        ].join("\n"),

 * own job instead.

 */

import { readChildTranscript } from "./coder-child-transcript.js";

import { activityPhrase, fleetRows, latestActivities, taskActivity } from "./coder-fleet.js";

import { renderMarkdown, visibleWidth, wrapStyled } from "./coder-markdown.js";

import type { CoderEntry, CoderSession, CoderSnapshot, CoderToolCall } from "./coder-session.js";

const DIM = "\x1b[2m";

const BOLD = "\x1b[1m";

/** Reverse video, for the sidebar's selector bar. */

const REVERSE = "\x1b[7m";

const ITALIC = "\x1b[3m";

const RESET = "\x1b[0m";

const CYAN = "\x1b[36m";

 */

const SIDEBAR_WIDTH = 34;

const SIDEBAR_MINIMUM_TERMINAL = 100;

/** How many rows of one tool result the child screen shows. */

const CHILD_OUTPUT_ROWS = 12;

/** Width of the role gutter, so every entry's text starts in one column. */

/**

 * Width of the marker column.

   * screen over it rather than a turn in it, because switching a skill off is

   * a change to what the next turn carries, not something to say to the model.

   */

  let screen: "chat" | "skills" = "chat";

  let screen: "chat" | "skills" | "child" = "chat";

  /**

   * Which half of the chat screen has the arrow keys.

   *

   * The composer, until the reader presses right. The sidebar is a list and

   * the composer is a field, and the two want the same four keys, so one of

   * them holds them at a time and the other shows that it does not.

   */

  let focus: "composer" | "sidebar" = "composer";

  /** The selected child, as an index into the sidebar's own order. */

  let sidebarRow = 0;

  /** The child whose transcript fills the screen, while one does. */

  let childId: string | undefined;

  /** Scroll position within that transcript, or the end when undefined. */

  let childAnchor: number | undefined;

  /** How many rows the child screen can show, for paging it. */

  let childViewport = 1;

  let childLines = 0;

  /** The row `/skills` acts on. */

  let skillRow = 0;

  /**

     * viewport at the moment the reader most wanted to see what the parent

     * had said.

     */

    /**

     * The order the column shows children in, and the order the selector moves

     * through. One function, because a selector that walks a different order

     * than the one on screen selects the wrong child.

     */

    const sidebarOrder = (tasks: ReadonlyArray<CoderTask>): ReadonlyArray<CoderTask> => [

      ...tasks.filter((task) => task.status === "running" || task.status === "pending"),

      ...tasks.filter((task) => task.status !== "running" && task.status !== "pending"),

    ];

    const sidebarLines = (

      tasks: ReadonlyArray<CoderTask>,

      height: number,

          ? `${BOLD}children${RESET}`

          : `${BOLD}children${RESET} ${DIM}${String(running)} working${RESET}`;

      const rows: string[] = [heading, ""];

      const rows: string[] = [

        heading,

        focus === "sidebar" ? `${DIM}↑↓ select · enter opens · ← back${RESET}` : "",

      ];

      // Working children first. A finished one has already been reported on

      // the transcript, so it is the one to drop when the column runs out.

      const ordered = [

        ...tasks.filter((task) => task.status === "running" || task.status === "pending"),

        ...tasks.filter((task) => task.status !== "running" && task.status !== "pending"),

      ];

      const ordered = sidebarOrder(tasks);

      const built = fleetRows(ordered, inner);

        if (rows.length + 2 > height) break;

        const color = fleetColor(row.status);

        rows.push(`${color}${row.mark}${RESET} ${truncate(task.description, inner - 2)}`);

        // The selector bar. Only while the column holds the keys, because a

        // highlight on a list that does not answer them is a lie about where

        // typing goes.

        const selected = focus === "sidebar" && index === sidebarRow;

        const name = truncate(task.description, inner - 2);

        rows.push(

          selected

            ? `${REVERSE}${color}${row.mark}${RESET}${REVERSE} ${name}${RESET}`

            : `${color}${row.mark}${RESET} ${name}`,

        );

        const activities = latestActivities([task], PREVIEW_ROWS);

      return rows;

    };

    /**

     * One child's transcript, filling the screen.

     *

     * A child reports one paragraph when it finishes, and until then the fleet

     * row says only what tool it is on. This is the rest of it: every event the

     * harness wrote, read from the file it is still appending to, so a reader

     * can watch a child work instead of waiting for its summary.

     */

    const childScreenLines = (task: CoderTask, width: number): ReadonlyArray<string> => {

      const rows: string[] = [];

      const body = Math.max(20, width - 4);

      rows.push(

        `${BOLD}${task.description}${RESET} ${DIM}${task.agent} · ${task.model} · ${task.status}${RESET}`,

        "",

      );

      const entries = readChildTranscript(task.transcriptPath);

      if (entries.length === 0) {

        rows.push(

          task.transcriptPath === undefined

            ? `${DIM}This child has not started writing yet.${RESET}`

            : `${DIM}Nothing written yet.${RESET}`,

        );

      }

      for (const entry of entries) {

        switch (entry.kind) {

          case "started":

            rows.push(`${DIM}started in ${entry.cwd} on ${entry.model}${RESET}`, "");

            break;

          case "tool":

            rows.push(

              `${YELLOW}▸${RESET} ${BOLD}${entry.name}${RESET}` +

                (entry.target === undefined ? "" : ` ${DIM}${truncate(entry.target, body - 6)}${RESET}`),

            );

            break;

          case "output":

            // Bounded per result. A child that cats a large file must not push

            // everything it did before that off the top of the screen.

            for (const line of entry.text.split("\n").slice(0, CHILD_OUTPUT_ROWS)) {

              rows.push(`  ${DIM}${truncate(line, body - 2)}${RESET}`);

            }

            if (entry.text.split("\n").length > CHILD_OUTPUT_ROWS) {

              rows.push(`  ${DIM}…${RESET}`);

            }

            break;

          case "text":

            rows.push("", ...wrapStyled(entry.text, body, ""), "");

            break;

          case "error":

            rows.push(...wrapStyled(entry.text, body, RED));

            break;

        }

      }

      // The answer, once there is one. It is what the parent was given, and a

      // reader who opened the child came for exactly this.

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

        rows.push("", `${GREEN}result${RESET}`, ...wrapStyled(task.result, body, ""));

      }

      if (task.error !== undefined) {

        rows.push("", `${RED}failed${RESET}`, ...wrapStyled(task.error, body, RED));

      }

      return rows.map((row) => `  ${row}`);

    };

    const render = () => {

      if (closed) return;

      const snapshot = session.snapshot();

        paint(rows, rows.length, 1);

        return;

      }

      // One child, filling the screen. Left or escape returns to the chat, and

      // the chat is untouched underneath: this is a screen over it, not a

      // place the session went.

      if (screen === "child") {

        const task = snapshot.tasks.find((candidate) => candidate.id === childId);

        if (task === undefined) {

          // The child was cleared while its transcript was open.

          screen = "chat";

        } else {

          const room = Math.max(1, height - 2);

          const lines = childScreenLines(task, width);

          childLines = lines.length;

          childViewport = room;

          const last = Math.max(0, lines.length - room);

          const from = childAnchor === undefined ? last : Math.min(childAnchor, last);

          const rows: string[] = [];

          for (let row = 0; row < room; row += 1) rows.push(lines[from + row] ?? "");

          rows.push(

            `${DIM}${"─".repeat(Math.max(0, width))}${RESET}`,

            hints(

              [{ text: "↑↓ scroll" }, { text: "← back" }, { text: "esc back" }],

              `${DIM}${task.description}${RESET}`,

              width,

            ),

          );

          paint(rows, rows.length, 1);

          return;

        }

      }

      const transcriptHeight = Math.max(1, height - STATUS_ROWS - COMPOSER_ROWS - SPACER_ROWS);

      // The column appears when there is something to put in it and room to

      // read first and the bottom chrome is the last thing the eye reaches.

      rows.push(`  ${justify(activity, where, inner)}`);

      if (focus === "sidebar") {

        // On the selected child, because a cursor left blinking in a composer

        // that is not taking keys says the wrong thing about where typing goes.

        const heading = 2;

        const selectedRow = Math.min(transcriptHeight, heading + sidebarRow * 3 + 1);

        paint(rows, selectedRow, transcriptWidth + 2);

        return;

      }

      paint(

        rows,

        transcriptHeight + 3,

          continue;

        }

        // The child screen takes the keyboard while it is up, for the same

        // reason the skills screen does: a stray letter must not fall through

        // into a composer the reader cannot see.

        if (screen === "child") {

          if (char === "\x1b") {

            const sequence = matchEscapeSequence(text, index);

            if (sequence === undefined) {

              pendingEscape = text.slice(index);

              break;

            }

            index += sequence.length;

            const page = Math.max(1, childViewport - 1);

            const scroll = (by: number) => {

              const last = Math.max(0, childLines - childViewport);

              const from = childAnchor ?? last;

              const next = Math.min(last, Math.max(0, from + by));

              childAnchor = next >= last ? undefined : next;

            };

            if (sequence === "\x1b" || sequence === "\x1b[D" || sequence === "\x1bOD") {

              // Back to the chat, and back into the column it was opened from,

              // so a reader stepping through children does not have to press

              // right again between each one.

              screen = "chat";

              focus = "sidebar";

              childAnchor = undefined;

              painted = [];

            } else if (sequence === "\x1b[A" || sequence === "\x1bOA") scroll(-1);

            else if (sequence === "\x1b[B" || sequence === "\x1bOB") scroll(1);

            else if (sequence === "\x1b[5~") scroll(-page);

            else if (sequence === "\x1b[6~") scroll(page);

            else continue;

            render();

            continue;

          }

          index += 1;

          if (char === "\x03" || char === "\x04") {

            screen = "chat";

            focus = "composer";

            childAnchor = undefined;

            painted = [];

            render();

          }

          continue;

        }

        // The skills screen takes the keyboard while it is up. Only the keys it

        // names do anything: a stray letter must not fall through into the

        // composer of a screen the reader cannot see.

            continue;

          }

          // The column, when there is one. Right hands it the arrow keys;

          // left hands them back. Both are no-ops when no children are

          // running, so the keys never disappear into a column that is not on

          // screen.

          const children = sidebarOrder(session.snapshot().tasks);

          const columnOpen =

            children.length > 0 && (stdout.columns ?? 80) >= SIDEBAR_MINIMUM_TERMINAL;

          if (focus === "composer" && columnOpen && (sequence === "\x1b[C" || sequence === "\x1bOC")) {

            focus = "sidebar";

            sidebarRow = Math.min(sidebarRow, children.length - 1);

            render();

            continue;

          }

          if (focus === "sidebar") {

            if (sequence === "\x1b[D" || sequence === "\x1bOD" || sequence === "\x1b") {

              focus = "composer";

            } else if (sequence === "\x1b[A" || sequence === "\x1bOA") {

              sidebarRow = Math.max(0, sidebarRow - 1);

            } else if (sequence === "\x1b[B" || sequence === "\x1bOB") {

              sidebarRow = Math.min(Math.max(0, children.length - 1), sidebarRow + 1);

            } else {

              continue;

            }

            render();

            continue;

          }

          const page = Math.max(1, viewport - 1);

          if (sequence === "\x1b[5~") scrollBy(-page);

          else if (sequence === "\x1b[6~") scrollBy(page);

          continue;

        }

        // Typing is always typing. A reader who starts a sentence while the

        // column has the keys means to type it, not to lose it, so the

        // character brings the composer back rather than being swallowed.

        if (focus === "sidebar" && char >= " " && char !== "\x7f") {

          focus = "composer";

        }

        if (char === "\r" || char === "\n") {

          index += 1;

          // Swallow a CRLF pair so a paste does not submit twice.

          if (char === "\r" && text[index] === "\n") index += 1;

          // Enter belongs to whatever holds the arrow keys. In the column it

          // opens the selected child rather than sending the composer, which

          // would send a line the reader was not looking at.

          if (focus === "sidebar") {

            const selected = sidebarOrder(session.snapshot().tasks)[sidebarRow];

            if (selected !== undefined) {

              childId = selected.id;

              childAnchor = undefined;

              screen = "child";

              painted = [];

              render();

            }

            continue;

          }

          // Always. A turn already running is not a reason to drop what was

          // typed: an interface command runs at once, and anything else is

          // queued by the session and sent when the turn ends. Ignoring the key

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

import { tmpdir } from "node:os";

import { join } from "node:path";

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

import { readChildTranscript } from "../src/coder-child-transcript.js";

const transcript = (lines: ReadonlyArray<unknown>) => {

  const path = join(mkdtempSync(join(tmpdir(), "oa-child-")), "child.jsonl");

  writeFileSync(path, lines.map((line) => JSON.stringify(line)).join("\n") + "\n");

  return path;

};

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

  it("reads its own records back", () => {

    const path = transcript([

      { type: "session", sessionId: "s1", model: "ox-alpha", cwd: "/repo" },

      { type: "tool", callId: "t1", name: "shell", arguments: { command: "git log" } },

      { type: "tool_result", callId: "t1", output: "abc123 a commit" },

      { type: "text", value: "The last commit is abc123." },

    ]);

    expect(readChildTranscript(path)).toEqual([

      { kind: "started", model: "ox-alpha", cwd: "/repo" },

      { kind: "tool", name: "shell", target: "git log" },

      { kind: "output", text: "abc123 a commit" },

      { kind: "text", text: "The last commit is abc123." },

    ]);

  });

  it("takes the one argument worth showing beside a tool", () => {

    const path = transcript([

      { type: "tool", name: "read", arguments: { path: "lib/a.ex", offset: 40 } },

      { type: "tool", name: "think", arguments: { thoughts: "hmm" } },

    ]);

    const entries = readChildTranscript(path);

    expect(entries[0]).toEqual({ kind: "tool", name: "read", target: "lib/a.ex" });

    // Nothing worth showing is shown as nothing, rather than as the first

    // field that happened to be a string.

    expect(entries[1]).toEqual({ kind: "tool", name: "think", target: undefined });

  });

});

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

  it("reads opencode's own event stream through the parser the fleet uses", () => {

    const path = transcript([

      {

        type: "tool_use",

        part: {

          type: "tool",

          callID: "call_1",

          tool: "bash",

          state: { status: "completed", input: { command: "pnpm test" } },

        },

      },

    ]);

    const entries = readChildTranscript(path);

    expect(entries).toHaveLength(1);

    expect(entries[0]).toMatchObject({ kind: "tool", name: "bash" });

  });

});

describe("reading a child that is still writing", () => {

  it("ignores a half-written last line rather than losing the file", () => {

    const path = transcript([{ type: "text", value: "so far" }]);

    // The harness is mid-append. This is the common case while a child runs,

    // not an error state.

    appendFileSync(path, `{"type":"tool","name":"sh`);

    expect(readChildTranscript(path)).toEqual([{ kind: "text", text: "so far" }]);

  });

  it("re-reads once the file has grown, and not before", () => {

    const path = transcript([{ type: "text", value: "one" }]);

    expect(readChildTranscript(path)).toHaveLength(1);

    // Same size, so the parse is reused: a finished child re-parsed on every

    // frame is work that buys nothing.

    expect(readChildTranscript(path)).toHaveLength(1);

    appendFileSync(path, JSON.stringify({ type: "text", value: "two" }) + "\n");

    expect(readChildTranscript(path)).toHaveLength(2);

  });

});

describe("reading a child that has written nothing", () => {

  it("is empty for a path that does not exist, rather than throwing", () => {

    expect(readChildTranscript(join(tmpdir(), "oa-absent", "nothing.jsonl"))).toEqual([]);

  });

  it("is empty for a child the harness has not named a path for", () => {

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

  });

});

    expect(rows.join("\n")).not.toContain(" → ");

  });

});

describe("inspecting a child from the column", () => {

  /** Drive the interface, sending keys between paints, and return each frame. */

  const driveKeys = async (

    record: (registry: CoderTaskRegistry) => void,

    steps: ReadonlyArray<ReadonlyArray<string>>,

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

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    stdout.columns = 120;

    const registry = new CoderTaskRegistry();

    const session = new CoderSession(

      {

        model: "scripted",

        async *reply(_prompt: string, signal: AbortSignal) {

          yield { type: "tool_call", callId: "c1", name: "delegate", arguments: "{}" };

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

            if (signal.aborted) return resolve();

            signal.addEventListener("abort", () => resolve(), { once: true });

          });

        },

      },

      "repo",

      "main",

      { registry, fleet: { submit: (): Promise<never> => new Promise(() => {}) }, label: "fake" },

    );

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    const turn = session.submit("go");

    await new Promise((resolve) => setTimeout(resolve, 0));

    record(registry);

    await new Promise((resolve) => setTimeout(resolve, 0));

    const frames: ReadonlyArray<string>[] = [];

    for (const keys of steps) {

      stdout.written = "";

      for (const key of keys) stdin.emit("data", key);

      await new Promise((resolve) => setTimeout(resolve, 0));

      frames.push(screen(stdout.written));

    }

    // Back to a state that can quit, whatever the steps left behind: the

    // child screen and the column both take ctrl+d as "return", and ctrl+d

    // only exits from an empty composer.

    stdin.emit("data", "\x04");

    stdin.emit("data", "\x7f".repeat(40));

    stdin.emit("data", "\x04");

    await running;

    session.interrupt();

    await turn;

    return frames;

  };

  const two = (registry: CoderTaskRegistry) => {

    for (const [id, description] of [

      ["d1", "audit open_router"],

      ["d2", "audit vercel_gateway"],

    ] as const) {

      const task = registry.register({

        id,

        description,

        prompt: "x",

        agent: "openagents",

        model: "ox-alpha",

        cwd: "/tmp",

        background: true,

      });

      registry.start(task.id, new AbortController());

    }

  };

  it("hands the arrow keys to the column on right, and back on left", async () => {

    const [before, inside, back] = await drillKeys();

    // Nothing says the column is live until it is.

    expect(before.join("\n")).not.toContain("enter opens");

    expect(inside.join("\n")).toContain("enter opens");

    expect(back.join("\n")).not.toContain("enter opens");

  });

  it("moves the selector without moving the transcript", async () => {

    const frames = await driveKeys(two, [

      ["\x1b[C"],

      ["\x1b[B"],

    ]);

    // Down in the column selects the second child. It must not scroll the

    // conversation, which is what down does when the composer has the keys.

    const moved = frames[1] ?? [];

    expect(moved.join("\n")).toContain("audit vercel_gateway");

  });

  it("opens the selected child on enter, filling the screen", async () => {

    const frames = await driveKeys(two, [["\x1b[C"], ["\x1b[B"], ["\r"]]);

    const opened = (frames[2] ?? []).join("\n");

    expect(opened).toContain("audit vercel_gateway");

    expect(opened).toContain("↑↓ scroll");

    // The conversation is not underneath it: this is a screen, not a pane.

    expect(opened).not.toContain("│");

  });

  it("returns from a child to the column it was opened from", async () => {

    // Stepping through children should not need a press of right between each.

    const frames = await driveKeys(two, [["\x1b[C"], ["\r"], ["\x1b[D"]]);

    const returned = (frames[2] ?? []).join("\n");

    expect(returned).toContain("enter opens");

    expect(returned).toContain("│");

  });

  it("gives the keys back to the composer when the reader types", async () => {

    // A sentence started while the column has the keys is a sentence, not a

    // set of shortcuts to swallow.

    const frames = await driveKeys(two, [["\x1b[C"], ["h", "i"]]);

    const typed = (frames[1] ?? []).join("\n");

    expect(typed).toContain("› hi");

  });

  it("ignores right when there is no column to move into", async () => {

    const frames = await driveKeys(

      () => undefined,

      [["\x1b[C"]],

    );

    expect((frames[0] ?? []).join("\n")).not.toContain("enter opens");

  });

  const drillKeys = async () =>

    driveKeys(two, [[], ["\x1b[C"], ["\x1b[D"]]);

});