stopped: "■",

};

/**

 * The one-line summary for the status bar, or undefined when there is no fleet.

 *

 * Running children come first because they are what the reader is waiting on,

 * and the terminal counts follow only when there are any, so a plain fan-out

 * does not carry a trail of zeroes.

 */

export function fleetPhrase(tasks: ReadonlyArray<CoderTask>): string | undefined {

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

  const active = tasks.filter((task) => !isTerminal(task.status));

  const done = tasks.filter((task) => task.status === "completed");

  const failed = tasks.filter((task) => task.status === "failed");

  const unread = tasks.filter((task) => task.unread);

  const parts: string[] = [];

  if (active.length > 0) {

    parts.push(`${String(active.length)} ${active.length === 1 ? "agent" : "agents"}`);

  }

  if (done.length > 0) parts.push(`${String(done.length)} done`);

  if (failed.length > 0) parts.push(`${String(failed.length)} failed`);

  if (unread.length > 0) parts.push(`${String(unread.length)} unread`);

  if (parts.length === 0) return `${String(tasks.length)} agents finished`;

  return parts.join(" · ");

}

/**

 * What a child is doing, in one phrase.

 *

 * own job instead.

 */

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

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

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

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

import type { CoderTask, CoderTaskStatus } from "./coder-tasks.js";

      const rows = [`${mark} ${BOLD}${tool.name}${RESET}`];

      if (tool.name === "delegate" && tool.status === "running") {

        const phrase = fleetPhrase(tasks) ?? "starting children…";

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

        // Working children first when there are more than fit: a finished child

        // has already been reported on the transcript, so it is the one to drop.

        const shown =

          tasks.length <= FLEET_ROWS_MAX

            ? tasks

            : [

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

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

              ].slice(0, FLEET_ROWS_MAX);

        for (const child of fleetRows(shown, Math.max(20, width - 9))) {

          const color = fleetColor(child.status);

          rows.push(

            `${DIM}${child.branch}${RESET} ${color}${child.mark}${RESET} ${DIM}${child.text}${RESET}`,

          );

        }

        const hidden = tasks.length - shown.length;

        if (hidden > 0) rows.push(`${DIM}   +${String(hidden)} more${RESET}`);

        const activities = latestActivities(tasks, PREVIEW_ROWS);

        if (activities.length > 0) {

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

      return rows;

    };

    /**

     * The fleet block: one row per child.

     *

     * Drawn above the status line rather than in the transcript, because it is

     * live state and the transcript is a record. A reader who scrolled back to

     * an earlier tool call still needs to see what the fleet is doing now.

     */

    const fleetLines = (snapshot: CoderSnapshot, width: number): ReadonlyArray<string> => {

      const tasks = snapshot.tasks;

      if (tasks.length === 0) return [];

      // Working children first when there are more than fit: a finished child

      // has already been reported on the transcript, so it is the one to drop.

      const shown =

        tasks.length <= FLEET_ROWS_MAX

          ? tasks

          : [

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

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

            ].slice(0, FLEET_ROWS_MAX);

      const out = fleetRows(shown, Math.max(20, width - 8)).map((row) => {

        const color = fleetColor(row.status);

        return `  ${DIM}${row.branch}${RESET} ${color}${row.mark}${RESET} ${DIM}${row.text}${RESET}`;

      });

      const hidden = tasks.length - shown.length;

      if (hidden > 0) out.push(`  ${DIM}   +${String(hidden)} more${RESET}`);

      return out;

    };

    /** The newest tool call, which is the one ctrl+o expands. */

    const focusedTool = (snapshot: CoderSnapshot): string | undefined => {

      for (let index = snapshot.entries.length - 1; index >= 0; index -= 1) {

      }

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

      const fleet = fleetLines(snapshot, width);

      // The fleet takes its rows from the transcript, not from the chrome:

      // the composer stays where the reader's hands expect it. The status

      // line is priced into `transcriptHeight`, which keeps every frame the

      // same height whether children are running or not.

      const transcriptRows = Math.max(1, transcriptHeight - fleet.length);

      const lines = transcriptLines(snapshot, width);

      lineCount = lines.length;

      viewport = transcriptRows;

      viewport = transcriptHeight;

      const maxStart = Math.max(0, lines.length - transcriptRows);

      const maxStart = Math.max(0, lines.length - transcriptHeight);

      const start = anchor === undefined ? maxStart : Math.min(anchor, maxStart);

      // Kept for the status line: a reader scrolled up with nothing saying so

      // reads a still transcript as a stopped session.

      const above = start;

      const rows: string[] = [];

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

      rows.push(...fleet);

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

      // Bottom chrome, in the order a reader scans it. The status line is the

      // main agent's state; the delegate preview lives inline under the

      paint(

        rows,

        transcriptRows + fleet.length + 3,

        transcriptHeight + 3,

        4 + [...visible].length + 1,

      );

    };

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

import {

  activityPhrase,

  fleetPhrase,

  fleetRows,

  formatTokens,

  latestActivities,

    // tell a slow child from a stuck one.

    const now = running.startedAt + 95_000;

    expect(taskActivity(running, now)).toBe("bash(pnpm test) (1m 35s)");

    expect(fleetPhrase([running])).toBe("1 agent");

    const rows = fleetRows([running], 80, now);

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

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

    expect(done).toBeDefined();

    if (done === undefined) return;

    expect(taskActivity(done)).toBe("Done (1 tool use · 8.2k tokens · 3s)");

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

  });

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

    const delegateRow = rows.findIndex((row) => row.includes("delegate"));

    expect(delegateRow).toBeGreaterThan(0);

    const status = rows[delegateRow + 1] ?? "";

    expect(status).toContain("1 agent");

    const childRow = rows[delegateRow + 1] ?? "";

    expect(childRow).toContain("inspect the repo");

    expect(childRow).toContain("Initializing");

    // The session status lives at the bottom and does not repeat the fleet.

    const bottom = rows.filter((row) => row.includes("repo · main")).at(-1) ?? "";

    expect(bottom).toContain("repo · main");