}

            });

        // Ctrl+C has to reach the children. Without this the command exits and

        // leaves every child agent running, spending, with nothing left

        // holding a handle on them. The handler is prepended and repeated on

        // exit because the runtime installs a signal handler of its own that

        // tears the process down, and whichever ends the process first must not

        // be the one that skips the children.

        const onSignal = () => {

          registry.stopAll();

        };

        process.prependListener("SIGINT", onSignal);

        process.prependListener("SIGTERM", onSignal);

        process.prependListener("exit", onSignal);

        try {

          return await Promise.all(

            Array.from({ length: count }, () =>

            ),

          );

        } finally {

          process.off("SIGINT", onSignal);

          process.off("SIGTERM", onSignal);

          process.off("exit", onSignal);

          unsubscribe();

        }

      });

 * shape then breaks one small tested function rather than the scheduler.

 */

import { spawn } from "node:child_process";

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

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

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

import { tmpdir } from "node:os";

import { join } from "node:path";

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

}

/** How long a stopped child has to leave on its own before it is killed. */

const KILL_GRACE_MS = 3_000;

/**

 * Signal a child and everything it started.

 *

 * The negative pid is the process group, which is why the child is spawned

 * detached. It falls back to the child alone when the group is already gone,

 * because a group whose last member exited between the two calls raises rather

 * than reporting nothing to do.

 */

function killGroup(child: ChildProcess, signal: "SIGTERM" | "SIGKILL"): void {

  const pid = child.pid;

  if (pid === undefined) return;

  try {

    process.kill(-pid, signal);

  } catch {

    try {

      child.kill(signal);

    } catch {

      // Already gone, which is the outcome that was wanted.

    }

  }

}

/**

 * Every process descended from `root`, deepest last.

 *

 * A harness is free to put its own tool processes in groups of their own, and

 * opencode does: signalling the group takes out opencode and leaves whatever a

 * bash tool started running under pid 1. The tree has to be read while the

 * parent is still alive, because reparenting erases the link.

 */

function descendants(root: number): ReadonlyArray<number> {

  let listing: string;

  try {

    listing = execFileSync("ps", ["-A", "-o", "pid=,ppid="], { encoding: "utf8" });

  } catch {

    return [];

  }

  const byParent = new Map<number, Array<number>>();

  for (const line of listing.split("\n")) {

    const [pid, parent] = line.trim().split(/\s+/).map(Number);

    if (pid === undefined || parent === undefined) continue;

    if (!Number.isInteger(pid) || !Number.isInteger(parent)) continue;

    const siblings = byParent.get(parent);

    if (siblings === undefined) byParent.set(parent, [pid]);

    else siblings.push(pid);

  }

  const found: Array<number> = [];

  const walk = (pid: number): void => {

    for (const child of byParent.get(pid) ?? []) {

      if (found.includes(child)) continue;

      found.push(child);

      walk(child);

    }

  };

  walk(root);

  return found;

}

/** Signal a child, its group, and every process either of them started. */

function killTree(child: ChildProcess, signal: "SIGTERM" | "SIGKILL"): void {

  const pid = child.pid;

  const tree = pid === undefined ? [] : descendants(pid);

  killGroup(child, signal);

  for (const descendant of tree) {

    try {

      process.kill(descendant, signal);

    } catch {

      // Already gone, which is the outcome that was wanted.

    }

  }

}

/** Runs children as `opencode run --format json` subprocesses. */

export class OpencodeHarness implements DelegateHarness {

  readonly agent = "opencode";

          : { OPENCODE_CONFIG: this.options.configPath }),

      },

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

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

      // started. A coding agent shells out, and killing only the agent leaves

      // its build or its `sleep` running with nothing left to stop it — with a

      // fan-out of fifteen, every cancelled fleet would leave a pile behind.

      detached: true,

    });

    // The transcript is written as the events arrive, not at the end, so a

    let failure: string | undefined;

    const onAbort = () => {

      child.kill("SIGTERM");

      killTree(child, "SIGTERM");

      // A harness that ignores the term, or a tool that will not stop, still

      // has to go: the reader asked for the child to end, not to be asked.

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

      grace.unref();

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

    };

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

export function taskCounters(task: CoderTask): string {

  if (isTerminal(task.status)) return "";

  const tools = task.progress.toolUseCount;

  if (tools === 0 && task.progress.tokenCount === 0) return "";

  return `${String(tools)} ${tools === 1 ? "tool" : "tools"} · ${formatTokens(task.progress.tokenCount)}`;

  const tokens = task.progress.tokenCount;

  const parts: Array<string> = [];

  if (tools > 0) parts.push(`${String(tools)} ${tools === 1 ? "tool" : "tools"}`);

  // Usage is omitted until the harness has reported some, because a bare `0`

  // in a counter column reads as a missing number rather than as "not yet".

  if (tokens > 0) parts.push(`${formatTokens(tokens)} tokens`);

  return parts.join(" · ");

}

/**

      }

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

      rows.push(rule);

      rows.push(`  › ${composer}`);

      // The composer shows its tail, never more characters than the row holds.

      // A row written past the last column makes the terminal wrap it, which

      // pushes the rule and the hints down a line and leaves the text they used

      // to occupy on screen with nothing to erase it.

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

      const typed = [...composer];

      const visible =

        typed.length > composerRoom

          ? `…${typed.slice(typed.length - composerRoom + 1).join("")}`

          : composer;

      rows.push(`  › ${visible}`);

      rows.push(rule);

      // Every key named here does something in the state it is named in, and

        if (composer.length > 0) keys.push("esc to clear");

        else keys.push("ctrl+d to quit");

      }

      // Stopping the fleet comes before the conveniences, because the row is

      // clipped from the end and this hint only appears while children are

      // spending. Offered last, it was dropped exactly when it applied.

      if (snapshot.tasks.some((task) => task.status === "running")) {

        keys.push("ctrl+x to stop agents");

      }

      // Only when there is another model to switch to, and only while nothing

      // is running: a turn already accepted keeps the backend it named.

      if (session.canCycleBackend && !snapshot.running) keys.push("tab to switch model");

      if (lines.length > transcriptRows) keys.push("pgup/pgdn to scroll");

      if (focusedTool(snapshot) !== undefined) keys.push("ctrl+o to expand");

      if (snapshot.tasks.some((task) => task.status === "running")) {

        keys.push("ctrl+x to stop agents");

      }

      // `this run` is not decoration. The count is this process's, and a

      // source that is not the thread — the stand-in behind `--offline` — has

            : `${DIM}${replies}${RESET}`;

      rows.push(`  ${hints(keys, counter, inner)}`);

      paint(rows, transcriptRows + fleet.length + 3, 4 + composer.length + 1);

      paint(rows, transcriptRows + fleet.length + 3, 4 + [...visible].length + 1);

    };

    /**

    expect(rows[0]?.branch).toBe("└─");

    expect(rows[0]?.mark).toBe("◐");

    expect(rows[0]?.text).toContain("bash(pnpm test)");

    expect(rows[0]?.text).toContain("8.2k");

    expect(rows[0]?.text).toContain("8.2k tokens");

  });

  it("replaces the counters with a total once the child is done", () => {

    expect(fleetPhrase([done])).toBe("1 done · 1 unread");

  });

  it("leaves usage out of a row until the harness has reported some", () => {

    const fresh = new CoderTaskRegistry();

    const started = fresh.register(

      {

        id: "d2",

        description: "read a file",

        prompt: "read it",

        agent: "opencode",

        model: "fake/model",

        cwd: "/tmp",

        background: true,

      },

      0,

    );

    fresh.start(started.id, new AbortController());

    fresh.recordToolUse(started.id, { toolName: "read", target: "x.ts" });

    const row = fleetRows(fresh.list(), 80)[0];

    expect(row?.text).toContain("1 tool");

    expect(row?.text).not.toContain(" 0");

  });

  it("shortens token counts", () => {

    expect(formatTokens(999)).toBe("999");

    expect(formatTokens(8214)).toBe("8.2k");

    expect(status).not.toContain("a-long-repository-name");

    expect(status).toContain("$2.00");

  });

  it("keeps a long typed line inside the row, showing its tail", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(source([]), "repo", "main");

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    // A row written past the last column is wrapped by the terminal, which

    // shifts every row below it and leaves text nothing will erase.

    stdin.emit("data", `${"a".repeat(120)}END`);

    const rows = screen(stdout.written);

    // Ctrl+D quits only from an empty composer, so clear it first.

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

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

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

    await running;

    const composer = rows.find((row) => row.startsWith("  ›")) ?? "";

    expect([...composer].length).toBeLessThanOrEqual(stdout.columns);

    expect(composer.endsWith("END")).toBe(true);

    expect(composer).toContain("…");

  });

});