* ragged text, and the transcript underneath it disappears.

 */

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

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

import { isTerminal } from "./coder-tasks.js";

/** One rendered child. The caller decides how `status` is coloured. */

  const running = formatDuration(now - task.startedAt);

  const activity = task.progress.lastActivity;

  if (activity === undefined) return `Initializing… (${running})`;

  return `${activityPhrase(activity)} (${running})`;

}

/**

 * What an activity says on its own, with no clock and no status around it.

 *

 * The preview box wants the doing, not the duration: the duration belongs to

 * the fleet row, which already carries it, and repeating it one row down says

 * the same thing twice.

 */

export function activityPhrase(activity: CoderToolActivity): string {

  const target = activity.target === undefined ? "" : `(${collapse(activity.target)})`;

  return `${activity.toolName}${target} (${running})`;

  return `${activity.toolName}${target}`;

}

/**

 * The newest activities across a fleet, oldest first, at most `count` of them.

 *

 * Within a child, `recentActivities` is oldest to newest. Across children the

 * activities are appended in launch order, which is exact for the one-child

 * case a preview is usually watching and stable for a fan-out: no timestamp

 * exists on an activity to order by, so launch order is the only honest one.

 *

 * Terminal children are left out. Their last actions were their outcome's

 * business, and that outcome is announced on the transcript; keeping the lines

 * here would leave a preview of work nothing is doing anymore.

 */

export function latestActivities(

  tasks: ReadonlyArray<CoderTask>,

  count: number,

): ReadonlyArray<CoderToolActivity> {

  const out: CoderToolActivity[] = [];

  for (const task of tasks) {

    if (isTerminal(task.status)) continue;

    out.push(...task.progress.recentActivities);

  }

  return out.slice(Math.max(0, out.length - Math.max(0, count)));

}

/**

 *

 *     ┌──────────────────────────────┐

 *     │ transcript, scrollable       │

 *     ├──────────────────────────────┤

 *     │ status  repo · branch · model · budget│

 *     │ delegate rows                │

 *     │ status line                  │

 *     │ activity preview, three rows │

 *     ├──────────────────────────────┤

 *     │ composer                     │

 *     └──────────────────────────────┘

 * own job instead.

 */

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

import { activityPhrase, fleetPhrase, 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 { RELOAD_EXIT_CODE, sourceCheckout } from "./coder-reload.js";

const RED = "\x1b[31m";

const STATUS_ROWS = 1;

/**

 * The status line sits under the delegate rows rather than under the composer.

 *

 * What the session is doing reads as a caption on the thing it describes, and

 * when children are running that thing is the fleet block above the line, not

 * the composer below it. The row is still paid for out of the transcript's

 * height, so the composer never moves.

 */

const COMPOSER_ROWS = 3;

/**

 * One blank row between the transcript and the composer.

 * ones that are still working and counts the rest.

 */

const FLEET_ROWS_MAX = 8;

/**

 * Activity lines the preview box holds.

 *

 * Fixed at three because a preview that grows with the run is a transcript in

 * miniature, and the transcript already exists. Newer activity pushes the

 * older rows up and out: the box always names the latest things the children

 * are doing and never more than three of them.

 */

const PREVIEW_ROWS = 3;

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

/**

 * Width of the marker column.

      return out;

    };

    /**

     * The preview box: what the working children last did, one line per thing.

     *

     * Drawn beside the fleet rather than inside it because a fleet row has one

     * line for everything a child is, and what a child did in its last three

     * steps does not fit in that line. The box scrolls by staying fixed: every

     * new activity pushes the rows up, and the oldest falls off the top.

     */

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

      const activities = latestActivities(snapshot.tasks, PREVIEW_ROWS);

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

      // Aligned with the rules and the status line: two columns of gutter,

      // then a box whose right edge meets theirs.

      const body = Math.max(10, width - 6);

      const frame = `${DIM}╭${"─".repeat(body + 2)}╮${RESET}`;

      const floor = `${DIM}╰${"─".repeat(body + 2)}╯${RESET}`;

      const rows = activities.map((activity) => {

        const text = truncate(activityPhrase(activity), body);

        const pad = " ".repeat(Math.max(0, body - [...text].length));

        return `  ${DIM}│${RESET} ${text}${pad} ${DIM}│${RESET}`;

      });

      return [`  ${frame}`, ...rows, `  ${floor}`];

    };

    /** 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

      // status line and composer stay where the reader's hands expect them.

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

      const preview = previewLines(snapshot, width);

      // The fleet and the preview take their rows from the transcript, not

      // from the chrome: the composer stays where the reader's hands expect

      // it. The status line moved up beside them; its row is already priced

      // into `transcriptHeight`, which is what keeps every frame the same

      // height whether children are running or not.

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

      const lines = transcriptLines(snapshot, width);

      lineCount = lines.length;

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

      rows.push(...fleet);

      // Bottom chrome, in the order a reader scans it: where the typing goes,

      // what the session is doing, then what the keys do. The composer sits

      // between two rules so it reads as its own region rather than as the last

      // line of the transcript, and the status line sits under that region.

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

      // directly under the delegate rows now: what the session is doing is a

      // caption on the thing it describes, and the children are that thing

      // whenever any exist. The preview box follows it, then the composer in

      // its own region between two rules.

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

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

        where = candidate;

        break;

      }

      // A blank row, then the composer, then what the session is doing. The

      // status line reads as a caption under the thing it describes: the reader

      // looks at where they type, and the state of the session is the next

      // thing down rather than something to scan back up for.

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

      rows.push(...preview);

      // A blank row, then the composer. The keys used to live on a second row

      // under it; they are in `/help` now, which is where a reader looks for

      // them once rather than past them always.

      rows.push("");

      rows.push(rule);

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

          : summarised;

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

      rows.push(rule);

      // Under the composer's own region, not inside it. Between the rules is

      // where typing goes; what the session is doing is a caption on the box,

      // and a caption sits outside the thing it describes.

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

      // One row of chrome under the composer, and it is the status line. The

      // keys used to live on a second row; they are in `/help` now, which is

      // where a reader looks for them once rather than past them always.

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

      paint(

        rows,

        transcriptRows + fleet.length + 1 + preview.length + 3,

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

      );

    };

    /**

        if (painted[index] === next) continue;

        frame.push(`\x1b[${index + 1};1H`, ERASE_LINE, next);

      }

      // Rows the last frame had that this one does not. The preview box and

      // the fleet both come and go with the work, so a frame can be shorter

      // than the one before it, and whatever it left below would otherwise

      // stay on screen with nothing owning it.

      for (let index = rows.length; index < painted.length; index += 1) {

        frame.push(`\x1b[${index + 1};1H`, ERASE_LINE);

      }

      painted = [...rows];

      frame.push(`\x1b[${cursorRow};${cursorColumn}H`, CURSOR_SHOW);

      write(frame.join(""));

  parseDelegateCommand,

  parseOpencodeEvent,

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

import { fleetPhrase, fleetRows, formatTokens, taskActivity } from "../src/coder-fleet.js";

import {

  activityPhrase,

  fleetPhrase,

  fleetRows,

  formatTokens,

  latestActivities,

  taskActivity,

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

import { CoderSession, type ReplySource } from "../src/coder-session.js";

import { CoderTaskRegistry } from "../src/coder-tasks.js";

import { mkdtempSync } from "node:fs";

    const rows = fleetRows(registry.list(), 30);

    expect(rows.every((row) => [...row.text].length <= 30)).toBe(true);

  });

  it("says an activity on its own, with no clock around it", () => {

    expect(activityPhrase({ toolName: "read", target: "src/a.ts" })).toBe("read(src/a.ts)");

    expect(activityPhrase({ toolName: "think", target: undefined })).toBe("think");

  });

});

describe("latestActivities", () => {

  const startedRegistry = () => {

    const registry = new CoderTaskRegistry();

    const task = registry.register(

      {

        id: "d1",

        description: "inspect the repo",

        prompt: "look around",

        agent: "opencode",

        model: "fake/model",

        cwd: "/tmp",

        background: true,

      },

      0,

    );

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

    return { registry, id: task.id };

  };

  it("returns nothing when no child has done anything", () => {

    expect(latestActivities([], 3)).toEqual([]);

    const { registry, id } = startedRegistry();

    expect(latestActivities(registry.list(), 3)).toEqual([]);

    registry.complete(id, "done", 10);

    expect(latestActivities(registry.list(), 3)).toEqual([]);

  });

  it("keeps the newest few, oldest first, across the fleet", () => {

    const { registry, id } = startedRegistry();

    for (const [name, target] of [

      ["read", "a.ts"],

      ["grep", "needle"],

      ["bash", "ls"],

      ["edit", "b.ts"],

    ] as const) {

      registry.recordToolUse(id, { toolName: name, target });

    }

    expect(latestActivities(registry.list(), 3)).toEqual([

      { toolName: "grep", target: "needle" },

      { toolName: "bash", target: "ls" },

      { toolName: "edit", target: "b.ts" },

    ]);

  });

  it("leaves a finished child's steps out of a live preview", () => {

    const first = startedRegistry();

    first.registry.recordToolUse(first.id, { toolName: "bash", target: "stale" });

    first.registry.complete(first.id, "done", 10);

    const second = startedRegistry();

    second.registry.recordToolUse(second.id, { toolName: "grep", target: "fresh" });

    expect(latestActivities([...first.registry.list(), ...second.registry.list()], 3)).toEqual([

      { toolName: "grep", target: "fresh" },

    ]);

  });

});

import { CODER_BACKENDS } from "../src/coder-backends.js";

import { CoderSession, type ReplyChunk, type ReplySource } from "../src/coder-session.js";

import { CoderTaskRegistry } from "../src/coder-tasks.js";

import { RELOAD_EXIT_CODE } from "../src/coder-reload.js";

import { runCoderUi } from "../src/coder-ui.js";

    expect(painted).toContain("\x1b[2m\x1b[3mI should check first.\x1b[0m");

  });

  it("says nothing about scope when the source keeps its turns to itself", async () => {

    const { rows } = await drive([{ type: "text", value: "hello" }]);

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

  });

  describe("switching backend with tab", () => {

    const driveSwitchable = async (keys: ReadonlyArray<string>) => {

      const stdin = new FakeIn();

      return { painted, rows: screen(painted), session };

    };

    it("moves to the next backend and says so", async () => {

      const { session, rows } = await driveSwitchable(["\t"]);

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

});

describe("the chrome under the composer", () => {

  it("is one row, and it is the status line", async () => {

  it("closes the composer with its floor rule, and no longer carries the status line", async () => {

    const { rows } = await drive([{ type: "text", value: "answer" }]);

    const bottom = rows.slice(-2);

    // The keys used to have a row of their own under the status line. They are

    // in `/help` now, which is where a reader looks for them once rather than

    // past them always.

    expect(bottom.some((row) => row.includes("ready") || row.includes("working"))).toBe(true);

    const composerAt = rows.findIndex((row) => row.includes("›"));

    const statusAt = rows.findIndex((row) => row.includes("repo · main"));

    // The status line moved up beside the delegate rows; what is left under

    // the composer is its own region and nothing else.

    expect(composerAt).toBeGreaterThan(0);

    expect(statusAt).toBeGreaterThanOrEqual(0);

    expect(statusAt).toBeLessThan(composerAt);

    expect(rows.at(-1)).toMatch(/^─+$/);

    expect(rows.join("\n")).not.toContain("enter to send");

    expect(rows.join("\n")).not.toContain("ctrl+d to quit");

  });

    expect(rows.join("\n")).toContain("ready");

  });

});

describe("the status line under the delegate rows", () => {

  /** A session that can delegate, driven by writing to its registry by hand. */

  const driveDelegated = async (

    record: (registry: CoderTaskRegistry) => void,

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

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const registry = new CoderTaskRegistry();

    const session = new CoderSession(source([{ type: "text", value: "hi" }]), "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,

    });

    record(registry);

    const painted = stdout.written;

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

    await running;

    return screen(painted);

  };

  const registerChild = (registry: CoderTaskRegistry): string => {

    const task = registry.register({

      id: "d1",

      description: "inspect the repo",

      prompt: "look around",

      agent: "opencode",

      model: "fake/model",

      cwd: "/tmp",

      background: true,

    });

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

    return task.id;

  };

  it("sits directly under the delegate row while a child runs", async () => {

    const rows = await driveDelegated((registry) => {

      registerChild(registry);

    });

    const delegateRow = rows.findIndex((row) => row.includes("inspect the repo"));

    expect(delegateRow).toBeGreaterThan(0);

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

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

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

  });

  it("previews the child's latest activity one line per thing, three lines at most", async () => {

    const rows = await driveDelegated((registry) => {

      const id = registerChild(registry);

      // Five activities against a box that holds three: the two oldest have

      // to fall off the top, which is what keeps the box a preview.

      registry.recordToolUse(id, { toolName: "read", target: "src/a.ts" });

      registry.recordToolUse(id, { toolName: "grep", target: "needle" });

      registry.recordToolUse(id, { toolName: "bash", target: "pnpm test" });

      registry.recordToolUse(id, { toolName: "edit", target: "src/b.ts" });

      registry.recordToolUse(id, { toolName: "shell", target: "mix test" });

    });

    const boxed = rows.filter((row) => /[╭╰]/.test(row) || row.includes(" │ "));

    expect(boxed).toHaveLength(5); // top border, three activity rows, floor.

    const text = boxed.join("\n");

    expect(text).toContain("shell(mix test)");

    expect(text).toContain("edit(src/b.ts)");

    expect(text).toContain("bash(pnpm test)");

    // Pushed out by the newer work.

    expect(text).not.toContain("read(src/a.ts)");

    expect(text).not.toContain("grep(needle)");

    // Newest last, so reading down is reading forward in time.

    const at = (phrase: string) => boxed.findIndex((row) => row.includes(phrase));

    expect(at("bash(pnpm test)")).toBeLessThan(at("edit(src/b.ts)"));

    expect(at("edit(src/b.ts)")).toBeLessThan(at("shell(mix test)"));

  });

  it("draws no preview until the child has done something", async () => {

    const rows = await driveDelegated((registry) => {

      registerChild(registry);

    });

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

  });

});