laohuang 0.3.2 → 0.4.0

package/dist/terminal/ui.js

@@ -0,0 +1,1815 @@
+/**
+ * Polished interactive terminal UI for laoHuangCode.
+ *
+ * Port of terminal_ui.py: the sole terminal writer. Everything visible is an
+ * append-only transcript of blocks; mutable blocks stream inline and are
+ * frozen (never rewritten) once their turn completes. Cancelled/truncated
+ * partial replies stay on screen and are marked.
+ *
+ * Scope notes for the TypeScript rewrite:
+ * - The legacy prompt_toolkit/rich console path has no TS equivalent; the
+ *   interactive UI is always the single-renderer raw loop, and non-TTY
+ *   sessions use PlainEventSink.
+ * - The editor and raw-input decoder behind the loop live behind the
+ *   EditorLike/InputDecoderLike interfaces so terminal/input.ts (another
+ *   workstream) can be injected once landed. BasicEditorState and
+ *   BasicInputDecoder are the built-in defaults implementing that contract.
+ */
+var _a, _b;
+import { appendFileSync } from "node:fs";
+import { createUIState, UIEventReducer, } from "../ui-state.js";
+import { renderMarkdownLines } from "./markdown.js";
+import { resolveTerminalTheme } from "./theme.js";
+import { PiMainScreenRenderer, charCellWidth, truncateToWidth, visibleWidth, wrapTextToWidth, } from "./screen.js";
+// ---------------------------------------------------------------------------
+// BasicEditorState — default line editor behind the raw loop
+// ---------------------------------------------------------------------------
+function cpSlice(text, start, end) {
+    return [...text].slice(start, end).join("");
+}
+function cpLength(text) {
+    return [...text].length;
+}
+function cellWidth(char) {
+    return Math.max(1, charCellWidth(char));
+}
+function textDisplayWidth(text) {
+    let width = 0;
+    for (const char of text) {
+        width += cellWidth(char);
+    }
+    return width;
+}
+function wrapEditorLine(text, width) {
+    const rows = [];
+    let row = "";
+    let rowWidth = 0;
+    for (const char of text) {
+        const charWidth = cellWidth(char);
+        if (row && rowWidth + charWidth > width) {
+            rows.push(row);
+            row = "";
+            rowWidth = 0;
+        }
+        row += char;
+        rowWidth += charWidth;
+    }
+    if (row || rows.length === 0) {
+        rows.push(row);
+    }
+    return rows;
+}
+function editorCursorPosition(text, width) {
+    let row = 0;
+    let column = 0;
+    for (const char of text) {
+        const charWidth = cellWidth(char);
+        if (column > 0 && column + charWidth > width) {
+            row += 1;
+            column = 0;
+        }
+        column += charWidth;
+        if (column === width) {
+            row += 1;
+            column = 0;
+        }
+    }
+    return [row, column];
+}
+/**
+ * Text, history, and command-completion state for the active editor.
+ *
+ * Default implementation of EditorLike; the richer editor from
+ * terminal/input.ts can replace it through the same interface.
+ */
+export class BasicEditorState {
+    text = "";
+    /** Cursor position in code points. */
+    cursor = 0;
+    history = [];
+    historyIndex = null;
+    #historyDraft = "";
+    completions = [];
+    selectedCompletion = null;
+    get completionVisible() {
+        return this.completions.length > 0;
+    }
+    setCompletions(values) {
+        this.completions = this.text.startsWith("/") ? [...values] : [];
+        this.selectedCompletion = this.completions.length > 0 ? 0 : null;
+    }
+    apply(action, options) {
+        if (action.kind === "submit") {
+            if (this.completionVisible) {
+                this.#acceptCompletion();
+                return {};
+            }
+            return this.#submit();
+        }
+        if (action.kind === "newline") {
+            this.#insert("\n");
+            return {};
+        }
+        if (action.kind === "cancel") {
+            return this.#cancelOrClear(options.runtimeActive);
+        }
+        if (action.kind === "eof") {
+            return this.#exitOrNotice(options.runtimeActive);
+        }
+        if (action.kind === "dismiss") {
+            this.#clearCompletions();
+            return {};
+        }
+        return this.#applyEditAction(action);
+    }
+    renderLines(width, options = {}) {
+        const prompt = options.prompt ?? "❯ ";
+        const mask = options.mask ?? false;
+        const targetWidth = Math.max(3, width);
+        const promptWidth = Math.max(1, textDisplayWidth(prompt));
+        const contentWidth = Math.max(1, targetWidth - promptWidth);
+        const displayText = mask ? "*".repeat(cpLength(this.text)) : this.text;
+        const sourceLines = displayText.split("\n");
+        const rows = [];
+        for (const source of sourceLines) {
+            rows.push(...wrapEditorLine(source, contentWidth));
+        }
+        const lastSource = sourceLines[sourceLines.length - 1];
+        if (displayText &&
+            !displayText.endsWith("\n") &&
+            textDisplayWidth(lastSource) % contentWidth === 0) {
+            rows.push("");
+        }
+        const rendered = rows.map((row, index) => (index === 0 ? prompt : " ".repeat(promptWidth)) + row);
+        const before = cpSlice(displayText, 0, this.cursor);
+        const beforeLines = before.split("\n");
+        let priorRows = 0;
+        for (const line of beforeLines.slice(0, -1)) {
+            priorRows += wrapEditorLine(line, contentWidth).length;
+        }
+        const current = beforeLines[beforeLines.length - 1];
+        const [currentRow, currentColumn] = editorCursorPosition(current, contentWidth);
+        const cursorRow = priorRows + currentRow;
+        const cursorColumn = promptWidth + currentColumn;
+        return {
+            lines: rendered,
+            cursorRow: Math.min(cursorRow, rendered.length - 1),
+            cursorCol: Math.min(cursorColumn, targetWidth - 1),
+        };
+    }
+    #submit() {
+        const submitted = this.text;
+        this.#clearCompletions();
+        this.text = "";
+        this.cursor = 0;
+        this.historyIndex = null;
+        this.#historyDraft = "";
+        if (!submitted) {
+            return {};
+        }
+        this.history = [...this.history, submitted];
+        return { submit: submitted };
+    }
+    #cancelOrClear(runtimeActive) {
+        if (runtimeActive) {
+            return { cancelRequested: true };
+        }
+        this.text = "";
+        this.cursor = 0;
+        this.historyIndex = null;
+        this.#clearCompletions();
+        return {};
+    }
+    #exitOrNotice(runtimeActive) {
+        if (runtimeActive) {
+            return { notice: "A task is still running. Press Ctrl+C to cancel it." };
+        }
+        if (this.text) {
+            return { notice: "Clear the editor before exiting." };
+        }
+        return { exitRequested: true };
+    }
+    #applyEditAction(action) {
+        if (action.kind === "history_up" && this.completionVisible) {
+            this.#moveCompletion(-1);
+        }
+        else if (action.kind === "history_down" && this.completionVisible) {
+            this.#moveCompletion(1);
+        }
+        else if (action.kind === "insert") {
+            this.#insert(action.text ?? "");
+        }
+        else if (action.kind === "backspace" && this.cursor > 0) {
+            this.#clearCompletions();
+            this.text = cpSlice(this.text, 0, this.cursor - 1) + cpSlice(this.text, this.cursor);
+            this.cursor -= 1;
+        }
+        else if (action.kind === "cursor_left") {
+            this.#clearCompletions();
+            this.cursor = Math.max(0, this.cursor - 1);
+        }
+        else if (action.kind === "cursor_right") {
+            this.#clearCompletions();
+            this.cursor = Math.min(cpLength(this.text), this.cursor + 1);
+        }
+        else if (action.kind === "history_up") {
+            this.#historyUp();
+        }
+        else if (action.kind === "history_down") {
+            this.#historyDown();
+        }
+        else if (action.kind === "complete") {
+            this.#acceptCompletion();
+        }
+        this.#closeCompletionIfContextLost();
+        return {};
+    }
+    #insert(text) {
+        this.#clearCompletions();
+        this.text = cpSlice(this.text, 0, this.cursor) + text + cpSlice(this.text, this.cursor);
+        this.cursor += cpLength(text);
+        this.historyIndex = null;
+    }
+    #acceptCompletion() {
+        if (this.selectedCompletion === null) {
+            return;
+        }
+        const item = this.completions[this.selectedCompletion];
+        const start = Math.max(0, this.cursor + item.start);
+        this.text = cpSlice(this.text, 0, start) + item.value + cpSlice(this.text, this.cursor);
+        this.cursor = start + cpLength(item.value);
+        this.#clearCompletions();
+    }
+    #moveCompletion(offset) {
+        if (this.selectedCompletion === null) {
+            return;
+        }
+        const count = this.completions.length;
+        this.selectedCompletion = (((this.selectedCompletion + offset) % count) + count) % count;
+    }
+    #historyUp() {
+        if (this.history.length === 0) {
+            return;
+        }
+        if (this.historyIndex === null) {
+            this.#historyDraft = this.text;
+            this.historyIndex = this.history.length - 1;
+        }
+        else {
+            this.historyIndex = Math.max(0, this.historyIndex - 1);
+        }
+        this.text = this.history[this.historyIndex];
+        this.cursor = cpLength(this.text);
+    }
+    #historyDown() {
+        if (this.historyIndex === null) {
+            return;
+        }
+        if (this.historyIndex === this.history.length - 1) {
+            this.text = this.#historyDraft;
+            this.historyIndex = null;
+        }
+        else {
+            this.historyIndex += 1;
+            this.text = this.history[this.historyIndex];
+        }
+        this.cursor = cpLength(this.text);
+    }
+    #closeCompletionIfContextLost() {
+        if (!this.text.startsWith("/")) {
+            this.#clearCompletions();
+        }
+    }
+    #clearCompletions() {
+        this.completions = [];
+        this.selectedCompletion = null;
+    }
+}
+// ---------------------------------------------------------------------------
+// BasicInputDecoder — default bytes-to-actions pipeline
+// ---------------------------------------------------------------------------
+const ESC = 0x1b;
+const PASTE_START = [0x1b, 0x5b, 0x32, 0x30, 0x30, 0x7e]; // \x1b[200~
+const PASTE_END = [0x1b, 0x5b, 0x32, 0x30, 0x31, 0x7e]; // \x1b[201~
+const CSI_ARROW_ACTIONS = {
+    "\x1b[A": "history_up",
+    "\x1b[B": "history_down",
+    "\x1b[C": "cursor_right",
+    "\x1b[D": "cursor_left",
+    "\x1bOA": "history_up",
+    "\x1bOB": "history_down",
+    "\x1bOC": "cursor_right",
+    "\x1bOD": "cursor_left",
+};
+const CONTROL_ACTIONS = {
+    3: "cancel",
+    4: "eof",
+    9: "complete",
+    8: "backspace",
+    127: "backspace",
+};
+const SPECIAL_ESCAPE_ACTIONS = {
+    "\x1b[13;2u": "newline",
+    "\x1b[57414;2u": "newline",
+    "\x1b[13u": "submit",
+    "\x1b[13;1u": "submit",
+    "\x1b[57414u": "submit",
+    "\x1b[57414;1u": "submit",
+    "\x1b[9u": "complete",
+    "\x1b[9;1u": "complete",
+    "\x1b[127u": "backspace",
+    "\x1b[127;1u": "backspace",
+    "\x1b[27u": "dismiss",
+    "\x1b[27;1u": "dismiss",
+};
+const utf8Decoder = new TextDecoder("utf-8", { fatal: false });
+function findSubsequence(haystack, needle) {
+    outer: for (let index = 0; index + needle.length <= haystack.length; index += 1) {
+        for (let offset = 0; offset < needle.length; offset += 1) {
+            if (haystack[index + offset] !== needle[offset]) {
+                continue outer;
+            }
+        }
+        return index;
+    }
+    return -1;
+}
+/** Split a byte run into complete UTF-8 content and an incomplete tail. */
+function splitIncompleteUtf8(bytes) {
+    let index = bytes.length - 1;
+    let continuation = 0;
+    while (index >= 0 && continuation < 4 && (bytes[index] & 0xc0) === 0x80) {
+        index -= 1;
+        continuation += 1;
+    }
+    if (index < 0) {
+        return [bytes, []];
+    }
+    const lead = bytes[index];
+    const needed = lead < 0x80 ? 1 : lead >= 0xc0 && lead <= 0xdf ? 2 : lead >= 0xe0 && lead <= 0xef ? 3 : lead >= 0xf0 && lead <= 0xf7 ? 4 : 1;
+    if (bytes.length - index < needed) {
+        return [bytes.slice(0, index), bytes.slice(index)];
+    }
+    return [bytes, []];
+}
+function decodeUtf8(bytes) {
+    return utf8Decoder.decode(new Uint8Array(bytes));
+}
+/**
+ * Incremental raw-input decoder with bracketed-paste and keyboard-mode
+ * negotiation handling. Default InputDecoderLike; the input workstream's
+ * pipeline can replace it through the same interface.
+ */
+export class BasicInputDecoder {
+    #hooks;
+    #isAppleTerminal;
+    #shiftPressed;
+    #buffer = [];
+    #pasteMode = false;
+    #pasteBuffer = [];
+    kittyProtocolActive = false;
+    constructor(hooks, options = {}) {
+        this.#hooks = hooks;
+        this.#isAppleTerminal = options.isAppleTerminal ?? (() => false);
+        this.#shiftPressed = options.shiftPressed ?? (() => false);
+    }
+    feed(data) {
+        if (data.length === 0) {
+            return [];
+        }
+        let bytes = [...data];
+        if (bytes.length === 1 && bytes[0] > 127) {
+            bytes = [ESC, bytes[0] - 128];
+        }
+        this.#buffer.push(...bytes);
+        return this.#process();
+    }
+    flush() {
+        if (this.#pasteMode || this.#buffer.length === 0) {
+            return [];
+        }
+        const buffered = this.#buffer;
+        this.#buffer = [];
+        if (buffered.length === 1 && buffered[0] === ESC) {
+            return [{ kind: "dismiss" }];
+        }
+        if (buffered[0] === ESC && buffered[1] === 0x5b) {
+            // A split CSI sequence stays buffered; a genuine one is dropped.
+            return [];
+        }
+        const [actions] = this.#decodeSequences(buffered);
+        return actions;
+    }
+    clear() {
+        this.#buffer = [];
+        this.#pasteBuffer = [];
+        this.#pasteMode = false;
+    }
+    #process() {
+        const actions = [];
+        for (;;) {
+            if (this.#pasteMode) {
+                this.#pasteBuffer.push(...this.#buffer);
+                this.#buffer = [];
+                const end = findSubsequence(this.#pasteBuffer, PASTE_END);
+                if (end === -1) {
+                    return actions;
+                }
+                const pasted = this.#pasteBuffer.slice(0, end);
+                const remaining = this.#pasteBuffer.slice(end + PASTE_END.length);
+                this.#pasteBuffer = [];
+                this.#pasteMode = false;
+                actions.push({ kind: "insert", text: decodeUtf8(pasted) });
+                this.#buffer = [...remaining, ...this.#buffer];
+                continue;
+            }
+            const start = findSubsequence(this.#buffer, PASTE_START);
+            if (start !== -1) {
+                const before = this.#buffer.slice(0, start);
+                const after = this.#buffer.slice(start + PASTE_START.length);
+                const [sequenceActions] = this.#decodeSequences(before);
+                actions.push(...sequenceActions);
+                this.#buffer = [];
+                this.#pasteMode = true;
+                this.#pasteBuffer = after;
+                continue;
+            }
+            const [sequenceActions, remainder] = this.#decodeSequences(this.#buffer);
+            actions.push(...sequenceActions);
+            this.#buffer = remainder;
+            return actions;
+        }
+    }
+    #decodeSequences(bytes) {
+        const actions = [];
+        let index = 0;
+        while (index < bytes.length) {
+            const byte = bytes[index];
+            if (byte === ESC) {
+                const parsed = this.#parseEscape(bytes, index);
+                if (parsed === null) {
+                    break;
+                }
+                index = parsed.next;
+                if (parsed.action !== undefined) {
+                    actions.push(parsed.action);
+                }
+                continue;
+            }
+            if (byte === 10 || byte === 13) {
+                index += 1;
+                if (byte === 13 && this.#isAppleTerminal() && this.#shiftPressed()) {
+                    actions.push({ kind: "newline" });
+                }
+                else {
+                    actions.push({ kind: "submit" });
+                }
+                continue;
+            }
+            const control = CONTROL_ACTIONS[byte];
+            if (control !== undefined) {
+                index += 1;
+                actions.push({ kind: control });
+                continue;
+            }
+            if (byte < 32) {
+                index += 1;
+                continue;
+            }
+            let end = index;
+            while (end < bytes.length && bytes[end] >= 32 && bytes[end] !== 127) {
+                end += 1;
+            }
+            const [complete, tail] = splitIncompleteUtf8(bytes.slice(index, end));
+            if (complete.length > 0) {
+                actions.push({ kind: "insert", text: decodeUtf8(complete) });
+            }
+            index = end - tail.length;
+            if (tail.length > 0) {
+                break;
+            }
+        }
+        return [actions, bytes.slice(index)];
+    }
+    #parseEscape(bytes, start) {
+        if (start + 1 >= bytes.length) {
+            return null;
+        }
+        const second = bytes[start + 1];
+        if (second === 10 || second === 13) {
+            return { next: start + 2, action: { kind: "newline" } };
+        }
+        if (second === 0x5b) {
+            let final = -1;
+            for (let index = start + 2; index < bytes.length; index += 1) {
+                const code = bytes[index];
+                if (code >= 0x40 && code <= 0x7e) {
+                    final = index;
+                    break;
+                }
+            }
+            if (final === -1) {
+                return null;
+            }
+            const sequence = String.fromCharCode(...bytes.slice(start, final + 1));
+            const action = this.#classifyCsi(sequence);
+            return action === undefined
+                ? { next: final + 1 }
+                : { next: final + 1, action };
+        }
+        if (second === 0x4f) {
+            if (start + 2 >= bytes.length) {
+                return null;
+            }
+            const sequence = String.fromCharCode(...bytes.slice(start, start + 3));
+            const kind = CSI_ARROW_ACTIONS[sequence];
+            return kind === undefined
+                ? { next: start + 3 }
+                : { next: start + 3, action: { kind } };
+        }
+        // An unsupported Alt sequence has no editor meaning; retain its character.
+        return { next: start + 1 };
+    }
+    #classifyCsi(sequence) {
+        const kittyFlags = /^\x1b\[\?(\d+)u$/.exec(sequence);
+        if (kittyFlags !== null) {
+            if (Number.parseInt(kittyFlags[1], 10)) {
+                this.#hooks.disableModifyOtherKeys();
+                this.kittyProtocolActive = true;
+            }
+            else {
+                this.#hooks.enableModifyOtherKeys();
+            }
+            return undefined;
+        }
+        if (/^\x1b\[\?[\d;]*c$/.test(sequence)) {
+            if (!this.kittyProtocolActive) {
+                this.#hooks.enableModifyOtherKeys();
+            }
+            return undefined;
+        }
+        if (sequence.startsWith("\x1b[?")) {
+            // Other negotiation responses (or their abandoned tails) are swallowed.
+            return undefined;
+        }
+        const special = SPECIAL_ESCAPE_ACTIONS[sequence];
+        if (special !== undefined) {
+            return { kind: special };
+        }
+        const arrow = CSI_ARROW_ACTIONS[sequence];
+        if (arrow !== undefined) {
+            return { kind: arrow };
+        }
+        if (this.#isKittyRelease(sequence)) {
+            return undefined;
+        }
+        const kittyPrintable = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u$/.exec(sequence);
+        if (kittyPrintable !== null) {
+            const codepoint = Number.parseInt(kittyPrintable[1], 10);
+            const shifted = kittyPrintable[2]
+                ? Number.parseInt(kittyPrintable[2], 10)
+                : null;
+            const modifier = Number.parseInt(kittyPrintable[4] ?? "1", 10) - 1;
+            const lockMask = 64 + 128;
+            if (modifier & ~(1 | lockMask)) {
+                return undefined;
+            }
+            if (modifier & (2 | 4)) {
+                return undefined;
+            }
+            const effective = modifier & 1 && shifted !== null ? shifted : codepoint;
+            if (effective < 32) {
+                return undefined;
+            }
+            try {
+                return { kind: "insert", text: String.fromCodePoint(effective) };
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const modifyOtherKeys = /^\x1b\[27;(\d+);(\d+)~$/.exec(sequence);
+        if (modifyOtherKeys !== null) {
+            const modifier = Number.parseInt(modifyOtherKeys[1], 10) - 1;
+            if (modifier & ~1) {
+                return undefined;
+            }
+            const codepoint = Number.parseInt(modifyOtherKeys[2], 10);
+            if (codepoint < 32) {
+                return undefined;
+            }
+            try {
+                return { kind: "insert", text: String.fromCodePoint(codepoint) };
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    #isKittyRelease(sequence) {
+        if (sequence.includes("\x1b[200~")) {
+            return false;
+        }
+        return [":3u", ":3~", ":3A", ":3B", ":3C", ":3D", ":3H", ":3F"].some((marker) => sequence.includes(marker));
+    }
+}
+export function createTranscriptBlock(kind, key, fields = {}) {
+    return {
+        kind,
+        key,
+        text: fields.text ?? "",
+        mutable: fields.mutable ?? false,
+        name: fields.name ?? "",
+        subject: fields.subject ?? "",
+        status: fields.status ?? "",
+        exitCode: fields.exitCode ?? null,
+        durationMs: fields.durationMs ?? null,
+        streamError: fields.streamError ?? "",
+        style: fields.style ?? "",
+    };
+}
+/** Local command feedback sharing the loop's event queue. */
+class LocalMessage {
+    text;
+    style;
+    constructor(text, style = "") {
+        this.text = text;
+        this.style = style;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Keep captured tool stdout out of user-facing terminal render queues. */
+function isHiddenToolStdout(event) {
+    if (!isRecord(event)) {
+        return false;
+    }
+    if (String(event.kind ?? "") !== "tool.output_delta") {
+        return false;
+    }
+    const payload = event.payload;
+    return isRecord(payload) && String(payload.stream ?? "stdout") === "stdout";
+}
+function eventKind(event) {
+    return isRecord(event) ? String(event.kind ?? "") : "";
+}
+function eventPayload(event) {
+    return isRecord(event) && isRecord(event.payload) ? event.payload : {};
+}
+/** Mirror Python's `int(...)`: truncate numbers, parse numeric strings. */
+function toInt(value) {
+    const parsed = typeof value === "string" ? Number.parseInt(value, 10) : Number(value);
+    return Number.isFinite(parsed) ? Math.trunc(parsed) : 0;
+}
+function projectionDropped(event) {
+    const payload = eventPayload(event);
+    return toInt(payload._projection_dropped ?? 0);
+}
+function clip(value, limit) {
+    return value.length <= limit ? value : `${value.slice(0, limit)}…`;
+}
+const HIGH_FREQUENCY_KINDS = new Set([
+    "model.reasoning_delta",
+    "model.tool_call_delta",
+    "tool.output_delta",
+]);
+// ---------------------------------------------------------------------------
+// ANSI style helpers (rich-style "italic #rrggbb" / "bg:#rrggbb" strings)
+// ---------------------------------------------------------------------------
+const NAMED_COLOR_CODES = {
+    black: "30",
+    red: "31",
+    green: "32",
+    yellow: "33",
+    blue: "34",
+    magenta: "35",
+    cyan: "36",
+    white: "37",
+};
+function hexToRgb(value) {
+    if (!/^#[0-9a-fA-F]{6}$/.test(value)) {
+        return null;
+    }
+    return [
+        Number.parseInt(value.slice(1, 3), 16),
+        Number.parseInt(value.slice(3, 5), 16),
+        Number.parseInt(value.slice(5, 7), 16),
+    ];
+}
+function ansiCodes(style) {
+    const codes = [];
+    let nextColorIsBackground = false;
+    for (const token of style.replace(/bg:/g, " bg:").split(/\s+/).filter(Boolean)) {
+        if (token === "bold") {
+            codes.push("1");
+        }
+        else if (token === "dim") {
+            codes.push("2");
+        }
+        else if (token === "italic") {
+            codes.push("3");
+        }
+        else if (token === "underline") {
+            codes.push("4");
+        }
+        else if (token === "on") {
+            nextColorIsBackground = true;
+        }
+        else if (token.startsWith("bg:#") && token.length === 10) {
+            const rgb = hexToRgb(token.slice(3));
+            if (rgb !== null) {
+                codes.push(`48;2;${rgb[0]};${rgb[1]};${rgb[2]}`);
+            }
+        }
+        else if (token.startsWith("#") && token.length === 7) {
+            const rgb = hexToRgb(token);
+            if (rgb !== null) {
+                const prefix = nextColorIsBackground ? "48" : "38";
+                codes.push(`${prefix};2;${rgb[0]};${rgb[1]};${rgb[2]}`);
+            }
+            nextColorIsBackground = false;
+        }
+        else if (token in NAMED_COLOR_CODES) {
+            let code = NAMED_COLOR_CODES[token];
+            if (nextColorIsBackground) {
+                code = String(Number.parseInt(code, 10) + 10);
+            }
+            codes.push(code);
+            nextColorIsBackground = false;
+        }
+        else {
+            nextColorIsBackground = false;
+        }
+    }
+    return codes;
+}
+function ansiStyledText(style, text) {
+    if (!style || !text) {
+        return text;
+    }
+    const codes = ansiCodes(style);
+    if (codes.length === 0) {
+        return text;
+    }
+    return `\x1b[${codes.join(";")}m${text}\x1b[0m`;
+}
+/** Serialize stdin, UI events, and all terminal writes in one loop. */
+export class InteractiveTerminalLoop {
+    static ESCAPE_TIMEOUT_MS = 50;
+    static WORK_QUEUE_LIMIT = 4_096;
+    #ui;
+    #driver;
+    #work = [];
+    #editor;
+    #decoder;
+    #renderer;
+    #onSubmit = () => { };
+    #exitRequested = false;
+    #closed = false;
+    #running = false;
+    #question = null;
+    #needsRender = true;
+    #terminalModesStarted = false;
+    #keyboardProtocolPushed = false;
+    #modifyOtherKeysActive = false;
+    #exitResolve = null;
+    #escapeTimer = null;
+    #wakeupEnabled = false;
+    #wakeupScheduled = false;
+    writeError = null;
+    constructor(ui, driver, editor, decoderFactory) {
+        this.#ui = ui;
+        this.#driver = driver;
+        this.#editor = editor;
+        this.#decoder = decoderFactory({
+            enableModifyOtherKeys: () => {
+                this.#enableModifyOtherKeys();
+            },
+            disableModifyOtherKeys: () => {
+                this.#disableModifyOtherKeys();
+            },
+        });
+        this.#renderer = new PiMainScreenRenderer(driver);
+    }
+    get editor() {
+        return this.#editor;
+    }
+    get closed() {
+        return this.#closed;
+    }
+    get running() {
+        return this.#running;
+    }
+    start(onSubmit) {
+        this.#onSubmit = onSubmit;
+        this.#exitRequested = false;
+        this.#running = true;
+    }
+    publishEvent(event) {
+        if (this.#closed || isHiddenToolStdout(event)) {
+            return;
+        }
+        if (this.#work.length >= _a.WORK_QUEUE_LIMIT - 128 &&
+            HIGH_FREQUENCY_KINDS.has(eventKind(event))) {
+            return;
+        }
+        this.#work.push({ type: "event", event });
+        this.#scheduleWakeup();
+    }
+    feedInputBytes(data) {
+        if (this.#closed) {
+            return;
+        }
+        this.#work.push({ type: "input", data });
+        this.#scheduleWakeup();
+    }
+    /** Synchronously consume queued work; this is also the test hook. */
+    drain() {
+        const changed = this.#drainWork();
+        if (changed || this.#needsRender) {
+            this.#render();
+        }
+    }
+    ask(message, options = {}) {
+        if (this.#closed || !this.#running) {
+            return Promise.resolve("");
+        }
+        const secret = options.secret ?? false;
+        return new Promise((resolve) => {
+            this.#question = { message, secret, resolve };
+            this.#resetEditor();
+            this.#needsRender = true;
+            this.#scheduleWakeup();
+        });
+    }
+    requestExit() {
+        this.#exitRequested = true;
+        this.#exitResolve?.();
+    }
+    close() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        this.#running = false;
+        const question = this.#question;
+        this.#question = null;
+        question?.resolve("");
+        if (this.#escapeTimer !== null) {
+            clearTimeout(this.#escapeTimer);
+            this.#escapeTimer = null;
+        }
+        this.#stopTerminalModes();
+        try {
+            this.#renderer.close();
+        }
+        catch (error) {
+            if (this.writeError === null) {
+                this.writeError = error;
+            }
+        }
+    }
+    /** Production entry: raw mode, terminal modes, stdin-driven draining. */
+    async run(input) {
+        try {
+            this.#driver.enterRawMode?.();
+            this.startTerminalModes();
+            const onData = (data) => {
+                this.feedInputBytes(data);
+                this.drain();
+                this.#armEscapeTimer();
+            };
+            const onEnd = () => {
+                this.#applyActions(this.#decoder.flush());
+                // Port of terminal_ui.py: EOF applies the editor's exit effect —
+                // exit only when the editor is idle and empty; otherwise the editor
+                // notice ("Clear the editor before exiting.") is shown and the loop
+                // keeps running.
+                this.#applyEof();
+                this.drain();
+            };
+            input?.on("data", onData);
+            input?.on("end", onEnd);
+            this.#wakeupEnabled = true;
+            try {
+                if (!this.#exitRequested) {
+                    await new Promise((resolve) => {
+                        this.#exitResolve = resolve;
+                    });
+                }
+            }
+            finally {
+                this.#wakeupEnabled = false;
+                input?.off?.("data", onData);
+                input?.off?.("end", onEnd);
+            }
+        }
+        catch (error) {
+            this.writeError = error;
+        }
+        finally {
+            if (this.#escapeTimer !== null) {
+                clearTimeout(this.#escapeTimer);
+                this.#escapeTimer = null;
+            }
+            this.close();
+        }
+    }
+    startTerminalModes() {
+        if (this.#terminalModesStarted) {
+            return;
+        }
+        this.#terminalModesStarted = true;
+        this.#driver.write("\x1b[?2004h");
+        this.#keyboardProtocolPushed = true;
+        this.#driver.write("\x1b[>7u\x1b[?u\x1b[c");
+        this.#driver.flush();
+    }
+    #stopTerminalModes() {
+        if (!this.#terminalModesStarted) {
+            return;
+        }
+        this.#terminalModesStarted = false;
+        try {
+            this.#driver.write("\x1b[?2004l");
+            if (this.#keyboardProtocolPushed || this.#decoder.kittyProtocolActive) {
+                this.#driver.write("\x1b[<u");
+                this.#keyboardProtocolPushed = false;
+                this.#decoder.kittyProtocolActive = false;
+            }
+            this.#disableModifyOtherKeys();
+            this.#driver.flush();
+        }
+        finally {
+            this.#decoder.clear();
+        }
+    }
+    #enableModifyOtherKeys() {
+        if (this.#decoder.kittyProtocolActive || this.#modifyOtherKeysActive) {
+            return;
+        }
+        this.#driver.write("\x1b[>4;2m");
+        this.#modifyOtherKeysActive = true;
+    }
+    #disableModifyOtherKeys() {
+        if (!this.#modifyOtherKeysActive) {
+            return;
+        }
+        this.#driver.write("\x1b[>4;0m");
+        this.#modifyOtherKeysActive = false;
+    }
+    #armEscapeTimer() {
+        if (this.#escapeTimer !== null) {
+            clearTimeout(this.#escapeTimer);
+        }
+        this.#escapeTimer = setTimeout(() => {
+            this.#escapeTimer = null;
+            this.#applyActions(this.#decoder.flush());
+            this.drain();
+        }, _a.ESCAPE_TIMEOUT_MS);
+    }
+    /**
+     * Production wakeup: while run() is active, queued work is rendered on the
+     * next event-loop turn — the role of the Python selector loop's wakeup
+     * pipe. Outside run(), drain() stays the synchronous test hook and nothing
+     * is scheduled.
+     */
+    #scheduleWakeup() {
+        if (!this.#wakeupEnabled || this.#wakeupScheduled || this.#closed) {
+            return;
+        }
+        this.#wakeupScheduled = true;
+        setImmediate(() => {
+            this.#wakeupScheduled = false;
+            this.drain();
+        });
+    }
+    #drainWork() {
+        let changed = false;
+        let item = this.#work.shift();
+        while (item !== undefined) {
+            if (item.type === "input") {
+                this.#applyActions(this.#decoder.feed(item.data));
+                changed = true;
+            }
+            else if (item.event instanceof LocalMessage) {
+                const message = item.event;
+                this.#ui.appendTranscript(createTranscriptBlock("notice", this.#ui.newBlockId(), {
+                    text: message.text,
+                    style: message.style,
+                }));
+            }
+            else {
+                this.#ui.applyProjectedEvent(item.event);
+                changed = true;
+            }
+            item = this.#work.shift();
+        }
+        return changed;
+    }
+    #render() {
+        this.#needsRender = false;
+        try {
+            const question = this.#question;
+            this.#renderer.render(this.#ui.buildFrame({
+                width: Math.max(1, this.#driver.getSize().columns),
+                editor: this.#editor,
+                prompt: question !== null ? `${question.message} ` : "❯ ",
+                secret: question !== null && question.secret,
+            }));
+        }
+        catch (error) {
+            this.writeError = error;
+            this.requestExit();
+        }
+    }
+    #applyActions(actions) {
+        for (const action of actions) {
+            if (this.#applyQuestionAction(action)) {
+                this.#needsRender = true;
+                continue;
+            }
+            const effect = this.#editor.apply(action, {
+                runtimeActive: this.#ui.isRunning(),
+            });
+            this.#applyEffect(effect);
+            this.#refreshCompletions();
+            this.#needsRender = true;
+        }
+    }
+    #applyEof() {
+        const effect = this.#editor.apply({ kind: "eof" }, { runtimeActive: this.#ui.isRunning() });
+        this.#applyEffect(effect);
+        this.#needsRender = true;
+    }
+    #applyEffect(effect) {
+        if (effect.submit !== null && effect.submit !== undefined) {
+            this.#ui.acceptUserInput(effect.submit);
+            this.#onSubmit(effect.submit);
+        }
+        if (effect.cancelRequested) {
+            this.#ui.cancelFromKeybinding();
+        }
+        if (effect.notice) {
+            this.#ui.appendTranscript(createTranscriptBlock("notice", this.#ui.newBlockId(), {
+                text: effect.notice,
+                style: "yellow",
+            }));
+        }
+        if (effect.exitRequested) {
+            this.requestExit();
+        }
+    }
+    #applyQuestionAction(action) {
+        const question = this.#question;
+        if (question === null) {
+            return false;
+        }
+        if (action.kind === "submit") {
+            const answer = this.#editor.text;
+            if (this.#question === question) {
+                this.#question = null;
+            }
+            this.#resetEditor();
+            question.resolve(answer);
+            return true;
+        }
+        if (action.kind === "cancel" || action.kind === "eof") {
+            if (this.#question === question) {
+                this.#question = null;
+            }
+            this.#resetEditor();
+            question.resolve("");
+            return true;
+        }
+        const effect = this.#editor.apply(action, { runtimeActive: false });
+        if (effect.notice) {
+            this.#ui.appendTranscript(createTranscriptBlock("notice", this.#ui.newBlockId(), {
+                text: effect.notice,
+                style: "yellow",
+            }));
+        }
+        return true;
+    }
+    #resetEditor() {
+        this.#editor.text = "";
+        this.#editor.cursor = 0;
+        this.#editor.historyIndex = null;
+        this.#editor.setCompletions([]);
+    }
+    #refreshCompletions() {
+        if (this.#question !== null) {
+            this.#editor.setCompletions([]);
+            return;
+        }
+        const registry = this.#ui.commandRegistry;
+        if (registry !== null) {
+            this.#editor.setCompletions(registry.complete(this.#editor.text, {
+                state: this.#ui.isRunning() ? "RUNNING_MODEL" : this.#ui.state.sessionState,
+            }));
+        }
+    }
+}
+_a = InteractiveTerminalLoop;
+/**
+ * Width used when the real terminal width cannot be determined — the same
+ * default Rich's Console falls back to on an unknown-size terminal.
+ */
+const FALLBACK_MARKDOWN_WIDTH = 80;
+/**
+ * Best-effort terminal width for the plain (loop-less) fallback writer, so
+ * markdown output wraps at the real terminal width instead of being
+ * hard-wrapped mid-word by the terminal itself.
+ */
+function resolveFallbackMarkdownWidth() {
+    const columns = process.stdout?.columns;
+    return typeof columns === "number" && columns > 0 ? columns : FALLBACK_MARKDOWN_WIDTH;
+}
+/**
+ * Render interactive agent sessions with the append-only transcript model.
+ *
+ * With a terminal driver, all painting goes through the raw interactive
+ * loop; without one the UI is a headless transcript plus a plain fallback
+ * writer (non-interactive sessions should prefer PlainEventSink).
+ */
+export class TerminalUI {
+    theme;
+    state;
+    reducer;
+    commandRegistry;
+    cancelCallback;
+    runtimeRunningCallback = null;
+    projectRoot;
+    provider;
+    model;
+    dashboardUrl;
+    #output;
+    #askFallback;
+    #loop = null;
+    #transcript = [];
+    #byCorrelation = new Map();
+    #nextBlockId = 0;
+    constructor(options = {}) {
+        this.theme = resolveTerminalTheme(options.theme);
+        this.projectRoot = options.projectRoot ?? null;
+        this.provider = options.provider ?? null;
+        this.model = options.model ?? null;
+        this.dashboardUrl = options.dashboardUrl ?? null;
+        this.commandRegistry = options.commandRegistry ?? null;
+        this.cancelCallback = options.cancelCallback ?? null;
+        this.#output = options.output ?? ((text) => console.log(text));
+        this.#askFallback = options.askFallback ?? null;
+        this.state = createUIState();
+        this.state.provider = options.provider ?? "";
+        this.state.model = options.model ?? "";
+        this.reducer = new UIEventReducer(this.state);
+        if (options.driver) {
+            const editorFactory = options.editorFactory ?? (() => new BasicEditorState());
+            const decoderFactory = options.decoderFactory ?? ((hooks) => new BasicInputDecoder(hooks));
+            this.#loop = new InteractiveTerminalLoop(this, options.driver, editorFactory(), decoderFactory);
+        }
+    }
+    get interactiveLoop() {
+        return this.#loop;
+    }
+    get renderError() {
+        return this.#loop?.writeError ?? null;
+    }
+    // -- prompts ------------------------------------------------------------
+    prompt(message) {
+        if (this.#loop !== null && this.#loop.running) {
+            return this.#loop.ask(message ?? "Input:");
+        }
+        if (this.#askFallback !== null) {
+            return this.#askFallback(message ?? "", false);
+        }
+        return Promise.reject(new Error("interactive prompt requires a running terminal loop"));
+    }
+    promptSecret(message) {
+        if (this.#loop !== null && this.#loop.running) {
+            return this.#loop.ask(message, { secret: true });
+        }
+        if (this.#askFallback !== null) {
+            return this.#askFallback(message, true);
+        }
+        return Promise.reject(new Error("interactive prompt requires a running terminal loop"));
+    }
+    // -- loop lifecycle -----------------------------------------------------
+    /** Run the single-owner interactive terminal for the whole session. */
+    async run(onSubmit) {
+        if (this.#loop === null) {
+            throw new Error("single-renderer mode is unavailable for this UI");
+        }
+        this.#loop.start(onSubmit);
+        await this.#loop.run();
+    }
+    requestExit() {
+        this.#loop?.requestExit();
+    }
+    close() {
+        this.#loop?.close();
+    }
+    startLoop(onSubmit) {
+        if (this.#loop === null) {
+            throw new Error("a terminal driver is required");
+        }
+        this.#loop.start(onSubmit);
+        this.#loop.startTerminalModes();
+    }
+    feedInputBytes(data) {
+        if (this.#loop === null) {
+            throw new Error("a terminal driver is required");
+        }
+        this.#loop.feedInputBytes(data);
+    }
+    drainLoop() {
+        this.#loop?.drain();
+    }
+    flushEventRenderer() {
+        this.#loop?.drain();
+    }
+    // -- callbacks ----------------------------------------------------------
+    setCommandRegistry(registry) {
+        this.commandRegistry = registry;
+    }
+    setCancelCallback(callback) {
+        this.cancelCallback = callback;
+    }
+    setRuntimeRunningCallback(callback) {
+        this.runtimeRunningCallback = callback;
+    }
+    isRunning() {
+        if (this.runtimeRunningCallback !== null) {
+            return Boolean(this.runtimeRunningCallback());
+        }
+        return ["RUNNING_MODEL", "RUNNING_TOOL", "RUNNING_TOOLS", "CANCELLING"].includes(this.state.sessionState);
+    }
+    cancelFromKeybinding() {
+        if (this.state.sessionState === "CANCELLING") {
+            this.write("Cancelling…");
+            return;
+        }
+        this.cancelCallback?.();
+    }
+    // -- transcript ---------------------------------------------------------
+    newBlockId() {
+        this.#nextBlockId += 1;
+        return `local-${this.#nextBlockId}`;
+    }
+    appendTranscript(block) {
+        this.#transcript.push(block);
+        if (block.key) {
+            this.#byCorrelation.set(`${block.kind}:${block.key}`, block);
+        }
+    }
+    acceptUserInput(text) {
+        this.appendTranscript(createTranscriptBlock("user", this.newBlockId(), { text }));
+    }
+    blockFor(kind, key) {
+        const block = this.#byCorrelation.get(`${kind}:${key}`);
+        if (block === undefined) {
+            throw new Error(`no transcript block for ${kind}:${key}`);
+        }
+        return block;
+    }
+    /** Build every persisted transcript line; never crop history here. */
+    buildHistoryLines(width) {
+        return this.#buildHistoryFrameParts(width).lines;
+    }
+    #buildHistoryFrameParts(width) {
+        const usableWidth = Math.max(12, width);
+        const blocks = [...this.#transcript];
+        const lines = [];
+        let activeStart = null;
+        for (const block of blocks) {
+            if (block.mutable && activeStart === null) {
+                activeStart = lines.length;
+            }
+            if (block.kind === "assistant") {
+                lines.push(...renderMarkdownLines(block.text, usableWidth, this.theme));
+            }
+            else {
+                for (const [style, text] of this.#renderTranscriptItem(block, usableWidth)) {
+                    lines.push(ansiStyledText(style, text.replace(/\n+$/u, "")));
+                }
+            }
+        }
+        return { lines, activeStart };
+    }
+    buildFrame(options) {
+        const { width, editor } = options;
+        const prompt = options.prompt ?? "❯ ";
+        const secret = options.secret ?? false;
+        const { lines: history, activeStart } = this.#buildHistoryFrameParts(width);
+        const editorResult = editor.renderLines(width, { prompt, mask: secret });
+        const completion = this.#completionLines(width, editor);
+        const footer = this.#footerLine(width);
+        const rows = [
+            ...history,
+            "─".repeat(width),
+            ...editorResult.lines,
+            "─".repeat(width),
+            ...completion,
+            ...(footer !== null ? [footer] : []),
+        ];
+        const editorStart = history.length + 1;
+        return {
+            lines: rows,
+            activeStart: activeStart ?? editorStart,
+            cursorRow: editorStart + editorResult.cursorRow,
+            cursorCol: editorResult.cursorCol,
+        };
+    }
+    #completionLines(width, editor) {
+        const rows = [];
+        editor.completions.slice(0, 6).forEach((item, index) => {
+            const marker = index === editor.selectedCompletion ? "›" : " ";
+            const text = `${marker} ${item.value}  ${item.description}`.replace(/\s+$/u, "");
+            rows.push(truncateToWidth(text, width));
+        });
+        return rows;
+    }
+    #footerLine(width) {
+        const text = this.#footerText();
+        return text ? truncateToWidth(text, width) : null;
+    }
+    #footerText() {
+        const details = [];
+        if (this.projectRoot !== null) {
+            details.push(this.projectRoot);
+        }
+        if (this.state.pendingCount || this.state.heldCount) {
+            details.push(`queue ${this.state.pendingCount} pending / ${this.state.heldCount} held`);
+        }
+        if (this.state.totalTokens) {
+            details.push(`↑${this.state.inputTokens} ↓${this.state.outputTokens}`);
+        }
+        const model = this.state.model || (this.model ?? "");
+        if (model) {
+            const provider = this.state.provider || (this.provider ?? "");
+            details.push(provider ? `${provider}/${model}` : model);
+        }
+        return details.join(" · ");
+    }
+    #renderTranscriptItem(item, width) {
+        if (item.kind === "user") {
+            return this.#backgroundLines(item.text, width, "user_bg", "text");
+        }
+        if (item.kind === "thinking") {
+            return this.#plainLines(`thinking  ${item.text}`, width, `italic ${this.theme.color("thinking")}`);
+        }
+        if (item.kind === "tool") {
+            const status = item.status || "running";
+            const isRunning = status === "running";
+            const background = isRunning
+                ? "tool_pending_bg"
+                : status === "completed"
+                    ? "tool_success_bg"
+                    : "tool_error_bg";
+            const accent = isRunning
+                ? "accent"
+                : status === "completed"
+                    ? "success"
+                    : "warning";
+            let title = `● ${item.name || "tool"}`;
+            if (item.subject) {
+                title += `  ${clip(item.subject, 180)}`;
+            }
+            if (item.key) {
+                title += `  [${item.key.slice(-8)}]`;
+            }
+            let detail = isRunning ? "Running…" : status;
+            if (item.exitCode !== null) {
+                detail += ` · exit ${item.exitCode}`;
+            }
+            if (item.durationMs !== null) {
+                detail += ` · ${item.durationMs}ms`;
+            }
+            if (item.streamError) {
+                detail += `\n${clip(item.streamError, 1_200)}`;
+            }
+            const rendered = this.#backgroundLines(`${title}\n${detail}`, width, background, "text");
+            const first = rendered[0];
+            if (first !== undefined) {
+                rendered[0] = [
+                    first[0].replace(this.theme.color("text"), this.theme.color(accent)),
+                    first[1],
+                ];
+            }
+            return rendered;
+        }
+        return this.#plainLines(item.text, width, item.style || this.theme.color("text"));
+    }
+    #backgroundLines(text, width, background, foreground) {
+        const style = `bg:${this.theme.color(background)} ${this.theme.color(foreground)}`;
+        return wrapTextToWidth(text, width).map((line) => [
+            style,
+            _b.#padLine(line, width) + "\n",
+        ]);
+    }
+    #plainLines(text, width, style) {
+        return wrapTextToWidth(text, width).map((line) => [style, `${line}\n`]);
+    }
+    static #padLine(line, width) {
+        return line + " ".repeat(Math.max(0, width - visibleWidth(line)));
+    }
+    // -- events ---------------------------------------------------------------
+    /** Queue a projected event; the loop is the sole event writer. */
+    publishEvent(event) {
+        if (this.#loop !== null) {
+            this.#loop.publishEvent(event);
+            return;
+        }
+        if (event instanceof LocalMessage) {
+            this.appendTranscript(createTranscriptBlock("notice", this.newBlockId(), {
+                text: event.text,
+                style: event.style,
+            }));
+            return;
+        }
+        if (isHiddenToolStdout(event)) {
+            return;
+        }
+        const dropped = projectionDropped(event);
+        if (dropped) {
+            this.appendTranscript(createTranscriptBlock("notice", this.newBlockId(), {
+                text: `… 省略了 ${dropped} 个流式展示事件；Agent 仍继续运行。`,
+                style: "yellow",
+            }));
+        }
+        this.applyProjectedEvent(event);
+    }
+    /** Reduce a projected event and apply its append-only block change. */
+    applyProjectedEvent(event) {
+        if (isHiddenToolStdout(event)) {
+            return;
+        }
+        const update = this.reducer.apply(event);
+        if (update !== null) {
+            this.applyTranscriptUpdate(update);
+        }
+    }
+    /** Mutate transcript state; the raw loop paints it later. */
+    applyTranscriptUpdate(update) {
+        const kind = update.kind;
+        const correlationId = update.correlationId;
+        if (kind === "ui.message") {
+            this.appendTranscript(createTranscriptBlock("notice", this.newBlockId(), {
+                text: update.text,
+                style: String(update.payload.style ?? ""),
+            }));
+            return;
+        }
+        if (kind === "model.text_delta") {
+            this.#freezeThinking();
+            const key = `assistant:${correlationId}`;
+            let item = this.#byCorrelation.get(key);
+            if (item === undefined) {
+                item = createTranscriptBlock("assistant", correlationId, { mutable: true });
+                this.#transcript.push(item);
+                this.#byCorrelation.set(key, item);
+            }
+            if (item.mutable) {
+                item.text += update.text;
+            }
+            return;
+        }
+        if (kind === "model.reasoning_delta") {
+            const key = `thinking:${correlationId}`;
+            let item = this.#byCorrelation.get(key);
+            if (item === undefined) {
+                item = createTranscriptBlock("thinking", correlationId, { mutable: true });
+                this.#transcript.push(item);
+                this.#byCorrelation.set(key, item);
+            }
+            if (item.mutable) {
+                item.text += update.text;
+            }
+            return;
+        }
+        if (kind === "model.response_committed" ||
+            kind === "model.response_aborted" ||
+            kind === "model.request_failed") {
+            for (const blockKind of ["assistant", "thinking"]) {
+                const block = this.#byCorrelation.get(`${blockKind}:${correlationId}`);
+                if (block !== undefined) {
+                    block.mutable = false;
+                }
+            }
+            return;
+        }
+        if (kind === "tool.started") {
+            this.#freezeThinking();
+            const args = update.payload.arguments;
+            let subject = "";
+            if (isRecord(args)) {
+                subject = String(args.command || args.path || "");
+            }
+            this.appendTranscript(createTranscriptBlock("tool", correlationId, {
+                mutable: true,
+                name: String(update.payload.name ?? "tool"),
+                subject,
+                status: "running",
+            }));
+            return;
+        }
+        if (kind === "tool.output_delta" && update.stream === "stderr") {
+            const item = this.#byCorrelation.get(`tool:${correlationId}`);
+            if (item !== undefined) {
+                item.streamError = (item.streamError + update.text).slice(-20_000);
+            }
+            return;
+        }
+        if (kind === "tool.finished") {
+            const key = `tool:${correlationId}`;
+            let item = this.#byCorrelation.get(key);
+            if (item === undefined) {
+                item = createTranscriptBlock("tool", correlationId);
+                this.#transcript.push(item);
+                this.#byCorrelation.set(key, item);
+            }
+            item.status = String(update.payload.status ?? "completed");
+            const rawExitCode = update.payload.exit_code;
+            item.exitCode = typeof rawExitCode === "number" ? Math.trunc(rawExitCode) : null;
+            const rawDuration = update.payload.duration_ms;
+            item.durationMs = typeof rawDuration === "number" ? Math.trunc(rawDuration) : null;
+            item.mutable = false;
+            return;
+        }
+        if (kind === "task.cancelled") {
+            this.appendTranscript(createTranscriptBlock("notice", this.newBlockId(), {
+                text: "任务已取消；已经完成的文件修改不会自动撤销。",
+                style: "yellow",
+            }));
+            return;
+        }
+        if (kind === "task.failed") {
+            this.appendTranscript(createTranscriptBlock("notice", this.newBlockId(), {
+                text: `Error: ${String(update.payload.error ?? "Task failed")}`,
+                style: `bold ${this.theme.color("error")}`,
+            }));
+        }
+    }
+    #freezeThinking() {
+        for (const block of this.#transcript) {
+            if (block.kind === "thinking") {
+                block.mutable = false;
+            }
+        }
+    }
+    // -- direct user-facing writes -------------------------------------------
+    write(message) {
+        this.#writeLocal(message);
+    }
+    showError(message) {
+        this.#writeLocal(`Error: ${message}`, `bold ${this.theme.color("error")}`);
+    }
+    showInterrupted(options = {}) {
+        const message = options.operation ? "Operation interrupted." : "Interrupted.";
+        this.#writeLocal(message, this.theme.color("warning"));
+    }
+    showGoodbye() {
+        if (this.#loop !== null) {
+            if (!this.#loop.closed) {
+                this.#writeLocal("Goodbye.", this.theme.color("dim"));
+                this.flushEventRenderer();
+            }
+            return;
+        }
+        this.#output(ansiStyledText(this.theme.color("dim"), "Goodbye."));
+    }
+    showAssistant(response) {
+        if (this.#loop !== null) {
+            this.appendTranscript(createTranscriptBlock("assistant", this.newBlockId(), { text: response }));
+            return;
+        }
+        for (const line of renderMarkdownLines(response, resolveFallbackMarkdownWidth(), this.theme)) {
+            this.#output(line);
+        }
+    }
+    showWelcome() {
+        const details = [];
+        if (this.projectRoot !== null) {
+            details.push(this.projectRoot);
+        }
+        if (this.provider && this.model) {
+            details.push(`${this.provider}/${this.model}`);
+        }
+        if (this.dashboardUrl) {
+            details.push(`trace: ${this.dashboardUrl}`);
+        }
+        if (this.#loop !== null) {
+            this.appendTranscript(createTranscriptBlock("notice", this.newBlockId(), {
+                text: "laoHuangCode  /help for commands",
+                style: `bold ${this.theme.color("accent")}`,
+            }));
+            if (details.length > 0) {
+                this.appendTranscript(createTranscriptBlock("notice", this.newBlockId(), {
+                    text: details.join(" · "),
+                    style: this.theme.color("dim"),
+                }));
+            }
+            return;
+        }
+        this.#output(ansiStyledText(`bold ${this.theme.color("accent")}`, "laoHuangCode") +
+            "  " +
+            ansiStyledText(this.theme.color("dim"), "/help for commands"));
+        if (details.length > 0) {
+            this.#output(ansiStyledText(this.theme.color("dim"), details.join(" · ")));
+        }
+    }
+    #writeLocal(message, style = "") {
+        if (this.#loop !== null) {
+            if (!this.#loop.closed) {
+                this.#loop.publishEvent(new LocalMessage(message, style));
+                return;
+            }
+            this.#output(ansiStyledText(style, message));
+            return;
+        }
+        this.#output(ansiStyledText(style, message));
+    }
+}
+_b = TerminalUI;
+// ---------------------------------------------------------------------------
+// PlainEventSink — append-only renderer for non-interactive stdio
+// ---------------------------------------------------------------------------
+/**
+ * Append-only renderer used when stdin/stdout are not interactive TTYs.
+ *
+ * The Python original renders from a background thread fed by a bounded
+ * queue; the TS event loop is single-threaded, so events render
+ * synchronously in publication order and flush()/stop() are lifecycle
+ * no-ops kept for API parity. Render errors are captured, never thrown
+ * back into the event bus.
+ */
+export class PlainEventSink {
+    outputFn;
+    #stopped = false;
+    #modelBuffers = new Map();
+    renderError = null;
+    constructor(outputFn = (text) => console.log(text)) {
+        this.outputFn = outputFn;
+    }
+    publishEvent(event) {
+        if (this.#stopped || isHiddenToolStdout(event)) {
+            return;
+        }
+        try {
+            this.#renderEvent(event);
+        }
+        catch (error) {
+            this.renderError = error;
+        }
+    }
+    write(message) {
+        if (!this.#stopped) {
+            this.outputFn(message);
+        }
+    }
+    flush() {
+        // Synchronous rendering drains on every publish; nothing to wait for.
+    }
+    stop(_options = {}) {
+        this.#stopped = true;
+    }
+    #renderEvent(event) {
+        if (!isRecord(event)) {
+            return;
+        }
+        const kind = String(event.kind ?? "");
+        const payload = eventPayload(event);
+        if (kind === "tool.output_delta" && String(payload.stream ?? "stdout") === "stdout") {
+            return;
+        }
+        const dropped = toInt(payload._projection_dropped ?? 0);
+        if (dropped) {
+            this.outputFn(`[stream output omitted: ${dropped} event(s); runtime continued]`);
+        }
+        const correlationId = String(event.correlation_id ?? "").slice(-8);
+        if (kind === "model.text_delta") {
+            const text = String(payload.text ?? payload.chunk ?? "");
+            if (text) {
+                const buffer = this.#modelBuffers.get(correlationId) ?? [];
+                buffer.push(text);
+                this.#modelBuffers.set(correlationId, buffer);
+            }
+        }
+        else if (kind === "model.response_committed") {
+            const text = (this.#modelBuffers.get(correlationId) ?? []).join("");
+            this.#modelBuffers.delete(correlationId);
+            if (text) {
+                this.outputFn(text);
+            }
+        }
+        else if (kind === "model.response_aborted" || kind === "model.request_failed") {
+            const text = (this.#modelBuffers.get(correlationId) ?? []).join("");
+            this.#modelBuffers.delete(correlationId);
+            if (text) {
+                this.outputFn(text);
+                this.outputFn("[response interrupted; not added to context]");
+            }
+        }
+        else if (kind === "ui.message") {
+            this.outputFn(String(payload.text ?? ""));
+        }
+        else if (kind === "tool.started") {
+            const name = String(payload.name ?? "tool");
+            this.outputFn(`[tool:${correlationId || "unknown"}] ${name} started`);
+        }
+        else if (kind === "tool.output_delta") {
+            const stream = String(payload.stream ?? "stdout");
+            const text = String(payload.text ?? payload.chunk ?? "");
+            if (text) {
+                this.outputFn(`[${correlationId || "unknown"}:${stream}] ${text}`);
+            }
+        }
+        else if (kind === "tool.finished") {
+            const status = String(payload.status ?? "completed");
+            this.outputFn(`[tool:${correlationId || "unknown"}] ${status}`);
+        }
+        else if (kind === "task.failed") {
+            this.outputFn(`Error: ${String(payload.error ?? "Task failed")}`);
+        }
+        else if (kind === "task.cancelled") {
+            this.outputFn("Task cancelled; completed file changes were not reverted.");
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// StdTerminalDriver — the small POSIX adapter used by the regular-screen loop
+// ---------------------------------------------------------------------------
+/**
+ * Make terminal control bytes visible for the debug capture log: ESC becomes
+ * the literal text `\x1b`, CR becomes `\r`, other C0/DEL bytes become `\xHH`.
+ * Newlines are kept so the log stays line-oriented.
+ */
+function escapeDebugCapture(data) {
+    let escaped = "";
+    for (const char of data) {
+        const code = char.codePointAt(0) ?? 0;
+        if (char === "\r") {
+            escaped += "\\r";
+        }
+        else if ((code < 0x20 && char !== "\n") || code === 0x7f) {
+            escaped += `\\x${code.toString(16).padStart(2, "0")}`;
+        }
+        else {
+            escaped += char;
+        }
+    }
+    return escaped;
+}
+/** Production terminal driver over process stdin/stdout. */
+export class StdTerminalDriver {
+    #rawModeActive = false;
+    /**
+     * Debug capture target from LAOHUANG_DEBUG_LOG: when set, every write is
+     * teed to this file with escape sequences made visible (for diagnosing
+     * stray-character bugs in the field). Null keeps write() zero-cost.
+     */
+    #debugLogPath;
+    constructor() {
+        const path = process.env.LAOHUANG_DEBUG_LOG?.trim();
+        this.#debugLogPath = path ? path : null;
+    }
+    get inputStream() {
+        return process.stdin;
+    }
+    enterRawMode() {
+        if (!process.stdin.isTTY) {
+            return;
+        }
+        process.stdin.setRawMode(true);
+        this.#rawModeActive = true;
+    }
+    write(data) {
+        if (this.#debugLogPath !== null) {
+            try {
+                appendFileSync(this.#debugLogPath, escapeDebugCapture(data));
+            }
+            catch {
+                // Debug capture is best-effort and must never break the UI.
+            }
+        }
+        process.stdout.write(data);
+    }
+    flush() {
+        // process.stdout.write is already unbuffered from our perspective.
+    }
+    getSize() {
+        return {
+            columns: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+        };
+    }
+    restore() {
+        if (this.#rawModeActive) {
+            process.stdin.setRawMode(false);
+            this.#rawModeActive = false;
+        }
+    }
+}
+//# sourceMappingURL=ui.js.map