/**

 * Markdown to ANSI for the coder transcript.

 *

 * Replies arrive as Markdown and used to be printed as source, so the reader

 * saw `**ox-alpha**` rather than a bold name. This turns the source into

 * styled, width-wrapped rows.

 *

 * Two properties of the caller shape every decision here:

 *

 * - The text arrives in chunks. Every frame re-renders the whole entry from

 *   whatever has arrived, so a half-arrived `**` or an unclosed fence is the

 *   normal case rather than an error. Unterminated markup renders as the

 *   literal characters that arrived, which means the row never loses a

 *   character and never flickers between two different readings of the same

 *   prefix.

 * - Rows are laid out by the interface, which owns the gutter. Wrapping

 *   therefore works on visible width with ANSI ignored, and a wrapped list

 *   item continues under its text rather than under its bullet.

 *

 * There is no Markdown dependency. The subset below is what a reply uses, and

 * a parser small enough to test directly is worth more here than a general one

 * that would still need a streaming and a wrapping layer on top.

 */

const RESET = "\x1b[0m";

const BOLD = "\x1b[1m";

const DIM = "\x1b[2m";

const ITALIC = "\x1b[3m";

const CODE = "\x1b[36m";

const HEADING = "\x1b[1m\x1b[36m";

/** A run of text that shares one ANSI prefix. */

export interface StyledSpan {

  readonly text: string;

  readonly style: string;

}

/** Visible width, ignoring ANSI styling. */

export function visibleWidth(text: string): number {

  return [...text.replace(/\x1b\[[0-9;]*m/g, "")].length;

}

/** Render one text block with a single style, wrapped like a paragraph. */

export function wrapStyled(text: string, width: number, style: string): ReadonlyArray<string> {

  const rows: string[] = [];

  for (const paragraph of text.split("\n")) {

    if (paragraph.length === 0) {

      rows.push("");

      continue;

    }

    rows.push(...wrapSpans([{ text: paragraph, style }], width, "", ""));

  }

  return rows;

}

/** Render Markdown source as styled rows no wider than `width`. */

export function renderMarkdown(text: string, width: number): ReadonlyArray<string> {

  const rows: string[] = [];

  /** The fence marker that opened the current code block, if one is open. */

  let fence: string | undefined;

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

    const fenced = /^\s*(```+|~~~+)/.exec(line);

    if (fence !== undefined) {

      // A fence closes only on its own marker, so a ``` inside a ~~~ block is

      // content rather than a terminator.

      if (fenced !== null && line.trim().startsWith(fence)) {

        fence = undefined;

        continue;

      }

      rows.push(...codeRows(line, width));

      continue;

    }

    if (fenced !== null) {

      fence = fenced[1] ?? "```";

      continue;

    }

    rows.push(...blockRows(line, width));

  }

  return rows;

}

/** One non-fenced source line as one or more rendered rows. */

function blockRows(line: string, width: number): ReadonlyArray<string> {

  if (line.trim().length === 0) return [""];

  if (/^\s*([-*_])\s*(\1\s*){2,}$/.test(line)) {

    return [`${DIM}${"─".repeat(Math.max(1, Math.min(width, 24)))}${RESET}`];

  }

  const heading = /^\s*(#{1,6})\s+(.*)$/.exec(line);

  if (heading !== null) {

    return wrapSpans(scan(heading[2] ?? "", HEADING), width, "", "");

  }

  const quote = /^\s*>\s?(.*)$/.exec(line);

  if (quote !== null) {

    const bar = `${DIM}│${RESET} `;

    return wrapSpans(scan(quote[1] ?? "", DIM), width, bar, bar);

  }

  const bullet = /^(\s*)([-*+])\s+(.*)$/.exec(line);

  if (bullet !== null) {

    const indent = " ".repeat(bullet[1]?.length ?? 0);

    return wrapSpans(scan(bullet[3] ?? "", ""), width, `${indent}${DIM}•${RESET} `, `${indent}  `);

  }

  const numbered = /^(\s*)(\d{1,9}[.)])\s+(.*)$/.exec(line);

  if (numbered !== null) {

    const indent = " ".repeat(numbered[1]?.length ?? 0);

    const marker = numbered[2] ?? "1.";

    return wrapSpans(

      scan(numbered[3] ?? "", ""),

      width,

      `${indent}${DIM}${marker}${RESET} `,

      `${indent}${" ".repeat(marker.length + 1)}`,

    );

  }

  return wrapSpans(scan(line, ""), width, "", "");

}

/** A line inside a fenced block: never wrapped by word, only hard-split. */

function codeRows(line: string, width: number): ReadonlyArray<string> {

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

  const expanded = line.replace(/\t/g, "  ");

  const rows: string[] = [];

  let rest = [...expanded];

  do {

    const piece = rest.slice(0, body).join("");

    rows.push(`${DIM}│${RESET} ${CODE}${piece}${RESET}`);

    rest = rest.slice(body);

  } while (rest.length > 0);

  return rows;

}

/**

 * Split inline Markdown into styled spans.

 *

 * Every construct is matched by finding its terminator first. When the

 * terminator has not arrived the opening characters are kept as literal text,

 * which is what makes a half-streamed `**bold` read as `**bold` rather than

 * swallowing the rest of the reply.

 */

function scan(text: string, style: string): ReadonlyArray<StyledSpan> {

  const spans: StyledSpan[] = [];

  let buffer = "";

  const flush = () => {

    if (buffer.length === 0) return;

    spans.push({ text: buffer, style });

    buffer = "";

  };

  let index = 0;

  while (index < text.length) {

    const char = text[index] ?? "";

    const next = text[index + 1];

    if (char === "\\" && next !== undefined && /[\\`*_~[\]()#+\-.!>]/.test(next)) {

      buffer += next;

      index += 2;

      continue;

    }

    if (char === "`") {

      const end = text.indexOf("`", index + 1);

      if (end > index + 1) {

        flush();

        spans.push({ text: text.slice(index + 1, end), style: `${style}${CODE}` });

        index = end + 1;

        continue;

      }

      buffer += char;

      index += 1;

      continue;

    }

    const strong = text.startsWith("**", index)

      ? "**"

      : text.startsWith("__", index)

        ? "__"

        : undefined;

    if (strong !== undefined) {

      const end = text.indexOf(strong, index + 2);

      if (end > index + 2) {

        flush();

        spans.push(...scan(text.slice(index + 2, end), `${style}${BOLD}`));

        index = end + 2;

        continue;

      }

      buffer += strong;

      index += 2;

      continue;

    }

    if ((char === "*" || char === "_") && opensEmphasis(text, index, char)) {

      const end = closesEmphasis(text, index + 1, char);

      if (end !== undefined) {

        flush();

        spans.push(...scan(text.slice(index + 1, end), `${style}${ITALIC}`));

        index = end + 1;

        continue;

      }

    }

    buffer += char;

    index += 1;

  }

  flush();

  return spans;

}

const WORD = /[\p{L}\p{N}]/u;

/** An opener needs text after it, and `_` also needs a boundary before it. */

function opensEmphasis(text: string, index: number, marker: string): boolean {

  const after = text[index + 1];

  if (after === undefined || /\s/.test(after)) return false;

  if (marker !== "_") return true;

  const before = text[index - 1];

  return before === undefined || !WORD.test(before);

}

/** The matching terminator, or undefined when it has not arrived yet. */

function closesEmphasis(text: string, from: number, marker: string): number | undefined {

  for (let index = from; index < text.length; index += 1) {

    if (text[index] !== marker) continue;

    const before = text[index - 1];

    if (before === undefined || /\s/.test(before)) continue;

    if (marker === "_") {

      const after = text[index + 1];

      if (after !== undefined && WORD.test(after)) continue;

    }

    return index;

  }

  return undefined;

}

/**

 * Greedy word wrap over styled spans.

 *

 * Wrapping happens on visible width so styling never shifts the right edge,

 * and the continuation prefix is separate from the first one so a wrapped list

 * item lines up under its own text.

 */

export function wrapSpans(

  spans: ReadonlyArray<StyledSpan>,

  width: number,

  first: string,

  continuation: string,

): ReadonlyArray<string> {

  const rows: string[] = [];

  let prefix = first;

  let line: StyledSpan[] = [];

  let used = 0;

  /** A space seen between two words, carrying the style of the span it came from. */

  let pendingSpace: string | undefined;

  const room = () => Math.max(4, width - visibleWidth(prefix));

  const emit = () => {

    rows.push(prefix + merge(line).map(paint).join(""));

    prefix = continuation;

    line = [];

    used = 0;

    pendingSpace = undefined;

  };

  for (const span of spans) {

    for (const piece of span.text.split(/(\s+)/)) {

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

      if (/^\s+$/.test(piece)) {

        if (used > 0) pendingSpace = span.style;

        continue;

      }

      let word = [...piece];

      while (word.length > 0) {

        const gap = pendingSpace !== undefined && used > 0 ? 1 : 0;

        const available = room() - used - gap;

        if (word.length > available && used > 0) {

          emit();

          continue;

        }

        // A word wider than a whole row is split rather than dropped.

        const take = word.length > room() ? room() : word.length;

        if (pendingSpace !== undefined && used > 0) {

          // The space keeps the style of the span it came from, so a styled

          // run stays one escape sequence and a boundary space stays plain.

          line.push({ text: " ", style: pendingSpace });

          used += 1;

        }

        pendingSpace = undefined;

        line.push({ text: word.slice(0, take).join(""), style: span.style });

        used += take;

        word = word.slice(take);

        if (word.length > 0) emit();

      }

    }

  }

  emit();

  return rows;

}

/** Join neighbours that share a style, so a styled run is one escape sequence. */

function merge(spans: ReadonlyArray<StyledSpan>): ReadonlyArray<StyledSpan> {

  const out: StyledSpan[] = [];

  for (const span of spans) {

    const last = out.at(-1);

    if (last !== undefined && last.style === span.style)

      out[out.length - 1] = { text: last.text + span.text, style: last.style };

    else out.push(span);

  }

  return out;

}

function paint(span: StyledSpan): string {

  return span.style.length === 0 ? span.text : `${span.style}${span.text}${RESET}`;

}

 *   appears in pieces rather than at once.

 */

import type { ReplyChunk } from "./coder-session.js";

const SUBMIT_PATH = "/api/v3/chat/turns";

const EVENTS_PATH = "/api/v3/chat/events";

  readonly sequence?: number;

  readonly type?: string;

  readonly payload?: Record<string, unknown>;

  /**

   * The server's own projection of the tool call this event belongs to, which

   * every `tool_call_*` event carries. It already holds pretty-printed

   * arguments, the extracted result, and a structured error, so reading it

   * rather than the raw payload keeps the CLI and the web surface showing the

   * same tool call.

   */

  readonly tool_call?: ToolCallView;

}

interface ToolCallView {

  readonly call_id?: string;

  readonly name?: string;

  readonly arguments?: string;

  readonly output?: string | null;

  readonly error?: { readonly code?: string | null; readonly message?: string | null } | null;

  readonly status?: string;

}

export class OxAlphaUnavailable extends Error {

}

/**

 * Submit a turn and yield the assistant text as the server records it.

 * Submit a turn and yield what the server records, in the order it records it.

 *

 * Reasoning deltas are read but not yielded: the transcript shows what the

 * assistant said, and the runtime already treats a thought as something a

 * client may drop.

 * A turn interleaves reasoning, tool calls, and assistant text. Every one of

 * those becomes a chunk here. An earlier version yielded only `text_delta`,

 * which made a tool call invisible and joined the sentence before it to the

 * sentence after it.

 */

export class OxAlphaReplySource {

  readonly model: string;

    this.model = options.model ?? "stealth/ox-alpha";

  }

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<string> {

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    const seen = await this.latestSequence();

    const runId = await this.submit(prompt, signal);

    const startedAt = Date.now();

        if (event.type === "text_delta") {

          const value = event.payload?.["value"];

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

          if (typeof value === "string" && value.length > 0) yield { type: "text", value };

        } else if (event.type === "reasoning_delta") {

          const value = event.payload?.["value"];

          if (typeof value === "string" && value.length > 0) yield { type: "reasoning", value };

        } else if (event.type === "tool_call_started") {

          const call = toolCall(event);

          if (call !== undefined) yield call;

        } else if (event.type === "tool_call_completed" || event.type === "tool_call_failed") {

          const result = toolResult(event);

          if (result !== undefined) yield result;

        } else if (event.type === "response_completed") {

          finished = true;

        } else if (event.type === "response_failed") {

  }

}

/** The start of a tool call, read from the server's projection of it. */

function toolCall(event: ChatEvent): Extract<ReplyChunk, { type: "tool_call" }> | undefined {

  const view = event.tool_call;

  const callId = view?.call_id ?? stringField(event.payload, "call_id");

  if (callId === undefined) return undefined;

  return {

    type: "tool_call",

    callId,

    name: view?.name ?? stringField(event.payload, "name") ?? "tool",

    arguments: view?.arguments ?? stringField(event.payload, "arguments") ?? "",

  };

}

/** The outcome of a tool call. `error` decides whether it succeeded. */

function toolResult(event: ChatEvent): Extract<ReplyChunk, { type: "tool_result" }> | undefined {

  const view = event.tool_call;

  const callId = view?.call_id ?? stringField(event.payload, "call_id");

  if (callId === undefined) return undefined;

  const message = view?.error?.message ?? stringField(event.payload, "error");

  const error = message ?? (event.type === "tool_call_failed" ? "The tool failed." : undefined);

  const output = view?.output ?? stringField(event.payload, "output");

  return { type: "tool_result", callId, output: output ?? undefined, error };

}

function stringField(

  payload: Record<string, unknown> | undefined,

  key: string,

): string | undefined {

  const value = payload?.[key];

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

}

/** The newest run in the log that the pre-submit snapshot did not know about. */

function newestRun(

  events: ReadonlyArray<ChatEvent>,

 *

 * `docs/2026-08-23-openagents-coder-cli-spec.md` section 3.6 makes this the

 * contract: the interface is optional, the agent is not.

 *

 * It renders a subset on purpose. Assistant text is written as the Markdown

 * source the model produced, with no ANSI, because this is the path a script

 * reads. Tool calls are written as one line each, so a reader can still see

 * that a call happened between two sentences. Reasoning is not written: it is

 * a thought, and a pipe wants the answer.

 */

import { createInterface } from "node:readline";

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

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

export interface CoderPlainOptions {

  readonly stdin: NodeJS.ReadableStream;

  const { stdin, stdout, prompt } = options;

  let written = 0;

  // Notices are tracked by their text rather than by position: a failed turn

  // removes the empty assistant entry, so an index into the transcript can move

  // backwards and skip the very notice that explains the failure.

  // Notices and tool lines are tracked by their text rather than by position: a

  // failed turn removes the empty assistant entry, so an index into the

  // transcript can move backwards and skip the very notice that explains the

  // failure.

  const reported = new Set<string>();

  const announce = (line: string) => {

    if (reported.has(line)) return;

    reported.add(line);

    stdout.write(`${line}\n`);

  };

  const flush = () => {

    const entries = session.snapshot().entries;

    // Notices carry refusals and failures. Dropping them here is how a failed

    // turn becomes a silent empty reply, so they are written as they arrive.

    // Notices carry refusals and failures, and a tool call is the only sign

    // that the text either side of it came from two different places. Dropping

    // either here is how a turn becomes a silent or run-on reply.

    for (const entry of entries) {

      if (entry.role !== "notice" || reported.has(entry.text)) continue;

      reported.add(entry.text);

      stdout.write(`${entry.text}\n`);

      if (entry.role === "notice") announce(entry.text);

      else if (entry.role === "tool") announce(toolLine(entry));

    }

    const last = entries.at(-1);

    unsubscribe();

  }

}

/**

 * One line when the call starts and one when it ends.

 *

 * Both are keyed by their own text, so the start line is written once while

 * the call runs and the outcome line replaces nothing: a reader of a pipe sees

 * the call begin and sees how it ended.

 */

function toolLine(entry: CoderEntry): string {

  const tool = entry.tool;

  if (tool === undefined) return `[tool] ${entry.text}`;

  if (tool.status === "running") {

    return `\n[tool] ${tool.name} ${tool.arguments.replace(/\s+/g, " ").trim()}`;

  }

  return `[tool] ${tool.name} → ${tool.error === undefined ? "ok" : `failed: ${tool.error}`}`;

}

 * line-oriented fallback in `coder-plain.ts` both render the same snapshot, so

 * the two cannot disagree about what a session contains.

 *

 * The reply source is a stand-in. The delivered first stage replaces

 * `DummyReplySource` with an ACP client that spawns the agent runtime and

 * streams `session/update` notifications; nothing outside this file changes

 * when it does, because both produce the same chunks through the same

 * interface.

 * A reply is not one string. A turn interleaves reasoning, tool calls, and

 * assistant text, and the transcript keeps them as separate entries in the

 * order the source produced them. An earlier version yielded only text, so a

 * tool call left no entry at all and the sentences on either side of it were

 * appended to the same entry and read as one run-on sentence.

 */

/** What a reply source produces. One entry kind per member. */

export type ReplyChunk =

  | { readonly type: "text"; readonly value: string }

  | { readonly type: "reasoning"; readonly value: string }

  | {

      readonly type: "tool_call";

      readonly callId: string;

      readonly name: string;

      /** Arguments as JSON source, pretty-printed when the server printed it. */

      readonly arguments: string;

    }

  | {

      readonly type: "tool_result";

      readonly callId: string;

      readonly output: string | undefined;

      readonly error: string | undefined;

    };

/** The tool half of a `tool` entry. Grows when the outcome arrives. */

export interface CoderToolCall {

  readonly callId: string;

  readonly name: string;

  readonly arguments: string;

  output: string | undefined;

  error: string | undefined;

  status: "running" | "succeeded" | "failed";

}

/** One entry in the transcript. */

export interface CoderEntry {

  readonly role: "you" | "assistant" | "notice";

  /** Rendered text. Assistant entries grow while a reply streams. */

  readonly role: "you" | "assistant" | "notice" | "tool" | "reasoning";

  /** Rendered text. Streaming entries grow while chunks arrive. */

  text: string;

  /** False while chunks are still arriving, so a renderer can show a caret. */

  settled: boolean;

  /** Present on a `tool` entry only. */

  readonly tool?: CoderToolCall;

}

/** Everything a renderer needs. No renderer reads anything else. */

   * Yield the reply to `prompt` in chunks. Rendering appends each chunk as it

   * arrives, so a slow source shows partial text rather than nothing.

   */

  reply(prompt: string, signal: AbortSignal): AsyncIterable<string>;

  reply(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk>;

}

const DUMMY_PREAMBLE =

 * It streams word by word with a small delay because a reply that appears all

 * at once would not exercise the incremental rendering the real source needs,

 * and a rendering bug that only shows up mid-stream would stay hidden until

 * the runtime landed.

 * the runtime landed. It emits reasoning, a tool call, and Markdown for the

 * same reason: `--offline` has to exercise every entry kind the interface

 * draws, or a rendering defect only appears against the live model.

 */

export class DummyReplySource implements ReplySource {

  readonly model = "dummy (no agent attached)";

  constructor(private readonly delayMs = 18) {}

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<string> {

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    const thought =

      "The prompt asks about this repository. I should check what is connected " +

      "before answering, then describe what the session can do.";

    for (const token of tokenize(thought)) {

      if (signal.aborted) return;

      await sleep(this.delayMs, signal);

      if (signal.aborted) return;

      yield { type: "reasoning", value: token };

    }

    if (signal.aborted) return;

    const callId = "dummy-call-1";

    yield {

      type: "tool_call",

      callId,

      name: "repo_grep",

      arguments: `{\n  "max_results": 30,\n  "pattern": ${JSON.stringify(prompt.trim())}\n}`,

    };

    await sleep(this.delayMs * 6, signal);

    if (signal.aborted) return;

    yield {

      type: "tool_result",

      callId,

      output: `{\n  "matches": [],\n  "status": "empty"\n}`,

      error: undefined,

    };

    const body = [

      DUMMY_PREAMBLE,

      `## ${DUMMY_PREAMBLE}`,

      "",

      `You said: **${prompt.trim()}**`,

      "",

      `You said: ${prompt.trim()}`,

      "What works right now:",

      "",

      "What works right now: the transcript, the composer, streaming, " +

        "interruption, and the status line.",

      "- the transcript, the composer, and *streaming*",

      "- interruption, the status line, and `--plain`",

      "- Markdown, including a wrapped list item whose continuation lines line " +

        "up under the item text rather than under its bullet",

      "",

      "What does not: reading files, running commands, and answering the " +

        "question you actually asked.",

      "",

      "```elixir",

      'def hello, do: "world"',

      "```",

    ].join("\n");

    for (const token of tokenize(body)) {

      if (signal.aborted) return;

      await sleep(this.delayMs, signal);

      if (signal.aborted) return;

      yield token;

      yield { type: "text", value: token };

    }

  }

}

  snapshot(): CoderSnapshot {

    return {

      entries: this.entries.map((entry) => ({ ...entry })),

      entries: this.entries.map(copyEntry),

      running: this.controller !== undefined,

      repository: this.repository,

      branch: this.branch,

    if (prompt.trim().length === 0) return;

    this.entries.push({ role: "you", text: prompt, settled: true });

    const reply: CoderEntry = { role: "assistant", text: "", settled: false };

    this.entries.push(reply);

    // An empty assistant entry from the start, so the interface shows a caret

    // rather than nothing while the first chunk is in flight. It is withdrawn

    // if the turn opens with reasoning or a tool call instead of text.

    const opening: CoderEntry = { role: "assistant", text: "", settled: false };

    this.entries.push(opening);

    /** The entry each streaming chunk kind is currently appending to. */

    let text: CoderEntry | undefined = opening;

    let reasoning: CoderEntry | undefined;

    const settle = (entry: CoderEntry | undefined) => {

      if (entry !== undefined) entry.settled = true;

    };

    const withdrawOpening = () => {

      const at = this.entries.indexOf(opening);

      if (at >= 0 && opening.text.length === 0) this.entries.splice(at, 1);

    };

    const controller = new AbortController();

    this.controller = controller;

    try {

      for await (const chunk of this.source.reply(prompt, controller.signal)) {

        if (controller.signal.aborted) break;

        reply.text += chunk;

        if (chunk.type === "text") {

          if (text === undefined) {

            settle(reasoning);

            reasoning = undefined;

            text = { role: "assistant", text: "", settled: false };

            this.entries.push(text);

          }

          text.text += chunk.value;

        } else if (chunk.type === "reasoning") {

          if (reasoning === undefined) {

            if (text === opening) withdrawOpening();

            settle(text);

            text = undefined;

            reasoning = { role: "reasoning", text: "", settled: false };

            this.entries.push(reasoning);

          }

          reasoning.text += chunk.value;

        } else if (chunk.type === "tool_call") {

          if (text === opening) withdrawOpening();

          settle(text);

          settle(reasoning);

          text = undefined;

          reasoning = undefined;

          this.entries.push({

            role: "tool",

            text: chunk.name,

            settled: false,

            tool: {

              callId: chunk.callId,

              name: chunk.name,

              arguments: chunk.arguments,

              output: undefined,

              error: undefined,

              status: "running",

            },

          });

        } else {

          this.applyToolResult(chunk);

        }

        this.emit();

      }

      if (controller.signal.aborted && reply.text.length > 0) {

      if (controller.signal.aborted) {

        // Keep the partial text. Cancellation is a state transition, not a

        // failure, so what the agent already said stays on the transcript.

        reply.text += "\n\n[interrupted]";

        const last = text ?? reasoning;

        if (last !== undefined && last.text.length > 0) last.text += "\n\n[interrupted]";

      }

    } catch (cause) {

      // A failed turn ends the turn, not the session. The reason belongs on the

      // transcript where the prompt that caused it is still visible, and any

      // text the source produced before failing is kept.

      const message = cause instanceof Error ? cause.message : String(cause);

      if (reply.text.length === 0) {

        this.entries.splice(this.entries.indexOf(reply), 1);

      if (text !== undefined && text.text.length === 0) {

        this.entries.splice(this.entries.indexOf(text), 1);

        text = undefined;

      }

      this.entries.push({ role: "notice", text: message, settled: true });

    } finally {

      reply.settled = true;

      for (const entry of this.entries) {

        if (entry.settled) continue;

        entry.settled = true;

        // A tool call the turn never resolved has no outcome to report.

        if (entry.tool?.status === "running") entry.tool.status = "failed";

      }

      this.controller = undefined;

      this.turnCount += 1;

      this.emit();

    return true;

  }

  private applyToolResult(chunk: Extract<ReplyChunk, { type: "tool_result" }>): void {

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

      const tool = this.entries[index]?.tool;

      if (tool === undefined || tool.callId !== chunk.callId) continue;

      tool.output = chunk.output;

      tool.error = chunk.error;

      tool.status = chunk.error === undefined ? "succeeded" : "failed";

      const entry = this.entries[index];

      if (entry !== undefined) entry.settled = true;

      return;

    }

  }

  private emit(): void {

    for (const listener of this.listeners) listener();

  }

}

/** A renderer must not be able to mutate the transcript through its snapshot. */

function copyEntry(entry: CoderEntry): CoderEntry {

  return entry.tool === undefined ? { ...entry } : { ...entry, tool: { ...entry.tool } };

}

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

 *     │ composer                     │

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

 *

 * Painting is differential. An earlier version cleared the whole screen and

 * repainted it several times a second while a reply streamed, which left a

 * stack of half-drawn frames wherever the terminal kept scrolled-off alternate

 * screen rows. Nothing here clears the screen, writes a newline, or moves the

 * cursor past the last row, so the terminal never scrolls and its own

 * scrollback is never written to. Scrolling the transcript is the interface's

 * own job instead.

 */

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

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

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

const ALT_SCREEN_ON = "\x1b[?1049h";

const ALT_SCREEN_OFF = "\x1b[?1049l";

const CURSOR_HIDE = "\x1b[?25l";

const CURSOR_SHOW = "\x1b[?25h";

const CLEAR = "\x1b[2J";

const ERASE_LINE = "\x1b[K";

/**

 * Alternate scroll: the terminal turns the wheel into arrow keys while the

 * alternate screen is up. It costs one escape sequence and, unlike mouse

 * reporting, leaves the terminal's own text selection alone.

 */

const ALT_SCROLL_ON = "\x1b[?1007h";

const ALT_SCROLL_OFF = "\x1b[?1007l";

const DIM = "\x1b[2m";

const BOLD = "\x1b[1m";

const ITALIC = "\x1b[3m";

const RESET = "\x1b[0m";

const CYAN = "\x1b[36m";

const GREEN = "\x1b[32m";

const YELLOW = "\x1b[33m";

const MAGENTA = "\x1b[35m";

const RED = "\x1b[31m";

const STATUS_ROWS = 1;

const COMPOSER_ROWS = 3;

/** Escape arms interruption for this long, so an arrow key is not an escape. */

const INTERRUPT_WINDOW_MS = 5000;

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

const GUTTER = 9;

/**

 * How long a lone escape byte waits for the rest of a sequence.

 *

 * A bare `\x1b` and the first byte of an arrow key are the same byte, so the

 * only way to tell them apart is to wait. Terminals deliver the rest of an

 * arrow key in the same read or the one straight after, so this is below the

 * threshold where a keypress feels delayed, and it lets a single escape

 * interrupt rather than requiring two.

 */

const ESCAPE_WINDOW_MS = 40;

export interface CoderUiOptions {

  readonly stdin: NodeJS.ReadStream;

  readonly stdout: NodeJS.WriteStream;

}

/** Visible width, ignoring ANSI styling. */

function visibleWidth(text: string): number {

  return [...text.replace(/\x1b\[[0-9;]*m/g, "")].length;

}

/**

 * Put `left` at the start of a row and `right` at the end.

 *

  return `${minutes}m ${seconds % 60}s`;

}

/** Wrap one paragraph to the available width, preserving blank lines. */

function wrap(text: string, width: number): ReadonlyArray<string> {

  const lines: string[] = [];

  for (const paragraph of text.split("\n")) {

    if (paragraph.length === 0) {

      lines.push("");

      continue;

    }

    let current = "";

    for (const word of paragraph.split(" ")) {

      if (current.length === 0) {

        current = word;

      } else if (current.length + 1 + word.length <= width) {

        current += ` ${word}`;

      } else {

        lines.push(current);

        current = word;

      }

    }

    lines.push(current);

  }

  return lines;

/** Collapse to one line and cut to a visible width, marking what was cut. */

function clip(text: string, width: number): string {

  return truncate(text.replace(/\s+/g, " ").trim(), width);

}

/** Cut to a visible width, keeping the leading indentation intact. */

function truncate(text: string, width: number): string {

  const glyphs = [...text.replace(/\t/g, "  ")];

  if (glyphs.length <= width) return glyphs.join("");

  return `${glyphs.slice(0, Math.max(1, width - 1)).join("")}…`;

}

/**

 * Match a complete escape sequence at `index`, or return undefined for a bare

 * escape. Covers CSI (`\x1b[…final`), SS3 (`\x1bO…`), and the `\x1b[…~` forms

 * that carry PageUp and PageDown.

 * Match a complete escape sequence at `index`, or return undefined when the

 * bytes so far could still be the start of one. Covers CSI (`\x1b[…final`),

 * SS3 (`\x1bO…`), and the `\x1b[…~` forms that carry PageUp and PageDown.

 */

function matchEscapeSequence(text: string, index: number): string | undefined {

  if (text[index] !== "\x1b") return undefined;

    return index + 2 < text.length ? text.slice(index, index + 3) : undefined;

  }

  return undefined;

  // Anything else after the escape is not a sequence this interface reads, so

  // the escape stands on its own and the next byte is an ordinary key.

  return "\x1b";

}

/**

  const { stdin, stdout } = options;

  let composer = "";

  let scrollOffset = 0;

  let escapeArmedAt = 0;

  let armedNotice = false;

  /**

   * The first transcript line the viewport shows, or undefined while the

   * viewport follows the newest content.

   *

   * Holding an absolute line rather than a distance from the bottom is what

   * makes a scrolled-up reader stay put while a reply keeps arriving: the

   * bottom moves, the anchor does not.

   */

  let anchor: number | undefined;

  /** Tool calls the reader expanded with ctrl+o. */

  const expanded = new Set<string>();

  let exitCode = 0;

  let closed = false;

  let runningSince = Date.now();

  /** Redraws the status line once a second so the elapsed time advances. */

  let ticker: NodeJS.Timeout | undefined;

  /** Rows as last painted, so only what changed is written. */

  let painted: string[] = [];

  /** Geometry from the last paint, which is what the scroll keys act on. */

  let lineCount = 0;

  let viewport = 1;

  /** Bytes held back because they may be the start of an escape sequence. */

  let pendingEscape = "";

  let escapeTimer: NodeJS.Timeout | undefined;

  const write = (text: string) => {

    stdout.write(text);

        clearInterval(ticker);

        ticker = undefined;

      }

      if (escapeTimer !== undefined) {

        clearTimeout(escapeTimer);

        escapeTimer = undefined;

      }

      unsubscribe();

      stdin.off("data", onData);

      stdout.off("resize", render);

      stdout.off("resize", onResize);

      if (stdin.isTTY) stdin.setRawMode(false);

      stdin.pause();

      write(CURSOR_SHOW + ALT_SCREEN_OFF);

      write(CURSOR_SHOW + ALT_SCROLL_OFF + ALT_SCREEN_OFF);

      resolve(exitCode);

    };

    /** Turn the transcript into printable lines, newest last. */

    /** Turn the transcript into printable rows, newest last. */