amness 0.0.0-stage → 0.1.2

package/dist/cli/tui/blocks.d.ts

@@ -0,0 +1,151 @@
+import type { Message } from "../../src/index.ts";
+export type Edit = {
+    path: string;
+    created: boolean;
+    added: number;
+    removed: number;
+    diff: string;
+};
+export type Block = {
+    id: number;
+    kind: "user";
+    text: string;
+    note?: string;
+    queued?: boolean;
+} | {
+    id: number;
+    kind: "assistant";
+    text: string;
+    streaming: boolean;
+} | {
+    id: number;
+    kind: "tool";
+    callId: string;
+    name: string;
+    args: string;
+    status: "running" | "ok" | "fail";
+    result?: string;
+    edit?: Edit;
+    agent?: string; /** call id of the subagent card this step belongs to */
+    parent?: string;
+    t0: number;
+    ms?: number;
+    expanded?: boolean; /** show every diff row, not just the first screenful */
+    more?: boolean;
+} | {
+    id: number;
+    kind: "thinking";
+    text: string;
+    active: boolean;
+    t0: number;
+    ms?: number;
+    expanded?: boolean;
+} | {
+    id: number;
+    kind: "notice";
+    level: "info" | "warn" | "error" | "ok";
+    text: string;
+} | {
+    id: number;
+    kind: "summary";
+    text: string;
+} | {
+    id: number;
+    kind: "raw";
+    lines: string[];
+};
+export type BlockKind = Block["kind"];
+export declare class BlockStore {
+    blocks: Block[];
+    version: number;
+    private n;
+    private openAssistant?;
+    private openThinking?;
+    private add;
+    get(id: number): Block | undefined;
+    private last;
+    clear(): void;
+    addUser(text: string, note?: string, queued?: boolean): {
+        id: number;
+        kind: "user";
+        text: string;
+        note?: string;
+        queued?: boolean;
+    };
+    /** Append streamed assistant text (starts a new block if none is open). */
+    streamAssistant(delta: string): void;
+    /** The model's complete message (used when nothing was streamed). */
+    setAssistant(text: string): void;
+    endAssistant(): void;
+    streamThinking(delta: string): void;
+    endThinking(): void;
+    toolStart(id: string, name: string, args: string, agent?: string, parent?: string): {
+        id: number;
+        kind: "tool";
+        callId: string;
+        name: string;
+        args: string;
+        status: "running" | "ok" | "fail";
+        result?: string;
+        edit?: Edit;
+        agent?: string; /** call id of the subagent card this step belongs to */
+        parent?: string;
+        t0: number;
+        ms?: number;
+        expanded?: boolean; /** show every diff row, not just the first screenful */
+        more?: boolean;
+    };
+    /** The steps a subagent card ran, in order. */
+    kids(callId: string): {
+        id: number;
+        kind: "tool";
+        callId: string;
+        name: string;
+        args: string;
+        status: "running" | "ok" | "fail";
+        result?: string;
+        edit?: Edit;
+        agent?: string; /** call id of the subagent card this step belongs to */
+        parent?: string;
+        t0: number;
+        ms?: number;
+        expanded?: boolean; /** show every diff row, not just the first screenful */
+        more?: boolean;
+    }[];
+    tool(callId: string): Extract<Block, {
+        kind: "tool";
+    }> | undefined;
+    toolEnd(callId: string, result: string, edit?: Edit): void;
+    /** A turn has ended (finished, interrupted or failed): any tool card still "running" can never complete, so close it instead of leaving a spinner on screen. */
+    closeRunning(note?: string): number;
+    notice(level: "info" | "warn" | "error" | "ok", text: string): {
+        id: number;
+        kind: "notice";
+        level: "info" | "warn" | "error" | "ok";
+        text: string;
+    };
+    summary(text: string): {
+        id: number;
+        kind: "summary";
+        text: string;
+    };
+    raw(lines: string[]): {
+        id: number;
+        kind: "raw";
+        lines: string[];
+    };
+    toggle(id: number): void;
+    /** Every user message with its block index (for sticky headers and prompt jumping). */
+    prompts(): {
+        block: {
+            id: number;
+            kind: "user";
+            text: string;
+            note?: string;
+            queued?: boolean;
+        };
+        index: number;
+    }[];
+    /** Rebuild from a saved conversation (resume, undo, compact). Tool results are matched to their calls; edit diffs are reconstructed from the call arguments. */
+    loadMessages(messages: Message[]): void;
+}

package/dist/cli/tui/blocks.js

@@ -0,0 +1,128 @@
+import { unifiedDiff } from "../../src/diff.js";
+const failed = (r) => /^(ERROR|DENIED|REJECTED)/.test(r) || /^stopped: (interrupted|no progress|no measurable)/.test(r) || /^exit=(?!0\b)/.test(r);
+export class BlockStore {
+    blocks = [];
+    version = 0;
+    n = 0;
+    openAssistant;
+    openThinking;
+    add(b) { const blk = { ...b, id: ++this.n }; this.blocks.push(blk); this.version++; return blk; }
+    get(id) { return this.blocks.find((b) => b.id === id); }
+    last(kind, open) { return open === undefined ? undefined : this.blocks.find((b) => b.id === open && b.kind === kind); }
+    clear() { this.blocks = []; this.openAssistant = this.openThinking = undefined; this.version++; }
+    addUser(text, note, queued) { this.endAssistant(); return this.add({ kind: "user", text, note, queued }); }
+    /** Append streamed assistant text (starts a new block if none is open). */
+    streamAssistant(delta) {
+        this.endThinking();
+        let b = this.last("assistant", this.openAssistant);
+        if (!b) {
+            b = this.add({ kind: "assistant", text: "", streaming: true });
+            this.openAssistant = b.id;
+        }
+        b.text += delta;
+        this.version++;
+    }
+    /** The model's complete message (used when nothing was streamed). */
+    setAssistant(text) { if (!this.last("assistant", this.openAssistant))
+        this.streamAssistant(text); }
+    endAssistant() { const b = this.last("assistant", this.openAssistant); if (b) {
+        b.streaming = false;
+        this.version++;
+    } this.openAssistant = undefined; }
+    streamThinking(delta) {
+        let b = this.last("thinking", this.openThinking);
+        if (!b) {
+            b = this.add({ kind: "thinking", text: "", active: true, t0: Date.now() });
+            this.openThinking = b.id;
+        }
+        b.text += delta;
+        this.version++;
+    }
+    endThinking() { const b = this.last("thinking", this.openThinking); if (b) {
+        b.active = false;
+        b.ms = Date.now() - b.t0;
+        this.version++;
+    } this.openThinking = undefined; }
+    toolStart(id, name, args, agent, parent) { this.endAssistant(); this.endThinking(); return this.add({ kind: "tool", callId: id, name, args, status: "running", agent, parent, t0: Date.now() }); }
+    /** The steps a subagent card ran, in order. */
+    kids(callId) { return this.blocks.filter((b) => b.kind === "tool" && b.parent === callId); }
+    tool(callId) { return [...this.blocks].reverse().find((b) => b.kind === "tool" && b.callId === callId); }
+    toolEnd(callId, result, edit) {
+        const b = this.tool(callId);
+        if (!b)
+            return;
+        b.result = result;
+        b.status = failed(result) ? "fail" : "ok";
+        b.ms = Date.now() - b.t0;
+        if (edit)
+            b.edit = edit;
+        this.version++;
+    }
+    /** A turn has ended (finished, interrupted or failed): any tool card still "running" can never complete, so close it instead of leaving a spinner on screen. */
+    closeRunning(note = "interrupted") {
+        let n = 0;
+        for (const b of this.blocks)
+            if (b.kind === "tool" && b.status === "running") {
+                b.status = "fail";
+                b.result = b.result ?? `(${note})`;
+                b.ms = Date.now() - b.t0;
+                n++;
+            }
+        if (n)
+            this.version++;
+        return n;
+    }
+    notice(level, text) { this.endAssistant(); return this.add({ kind: "notice", level, text }); }
+    summary(text) { this.endAssistant(); return this.add({ kind: "summary", text }); }
+    raw(lines) { return this.add({ kind: "raw", lines }); }
+    toggle(id) { const b = this.get(id); if (b && (b.kind === "tool" || b.kind === "thinking")) {
+        if (b.kind === "tool")
+            b.more = false;
+        b.expanded = !(b.expanded ?? (b.kind === "tool" && !!(b.edit || b.status === "fail")));
+        this.version++;
+    } }
+    /** Every user message with its block index (for sticky headers and prompt jumping). */
+    prompts() { return this.blocks.flatMap((b, i) => (b.kind === "user" ? [{ block: b, index: i }] : [])); }
+    /** Rebuild from a saved conversation (resume, undo, compact). Tool results are matched to their calls; edit diffs are reconstructed from the call arguments. */
+    loadMessages(messages) {
+        this.clear();
+        const results = new Map();
+        for (const m of messages)
+            if (m.role === "tool" && m.tool_call_id)
+                results.set(m.tool_call_id, m.content ?? "");
+        for (const m of messages) {
+            if (m.role === "user") {
+                const t = (m.content ?? "").split("\n\n<attached>")[0].split("\n\n## ")[0].replace(/^\[mode:[^\]]*\]\n\n/, "");
+                if (t.trim())
+                    this.addUser(t);
+            }
+            else if (m.role === "assistant") {
+                if (m.content?.trim()) {
+                    this.streamAssistant(m.content);
+                    this.endAssistant();
+                }
+                for (const c of m.tool_calls ?? []) {
+                    if (c.function.name === "finish")
+                        continue;
+                    const b = this.toolStart(c.id, c.function.name, c.function.arguments), res = results.get(c.id);
+                    let edit;
+                    try {
+                        const a = JSON.parse(c.function.arguments);
+                        if (c.function.name === "edit_file" && a.old !== undefined)
+                            edit = { path: a.path, created: false, ...(({ added, removed, diff }) => ({ added, removed, diff }))(unifiedDiff(a.path, a.old, a.new ?? "")) };
+                        else if (c.function.name === "write_file")
+                            edit = { path: a.path, created: true, ...(({ added, removed, diff }) => ({ added, removed, diff }))(unifiedDiff(a.path, null, a.content ?? "")) };
+                    }
+                    catch { /* unparsable arguments: show the call without a diff */ }
+                    if (res !== undefined) {
+                        this.toolEnd(c.id, res, res && !failed(res) ? edit : undefined);
+                        b.ms = undefined;
+                    }
+                    else {
+                        b.status = "ok";
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/cli/tui/brand.d.ts

@@ -0,0 +1,9 @@
+import type { Theme } from "./themes.ts";
+/** Provider/model identity (glyph + colour) for the active theme. */
+export declare function brandOfModel(model: string, provider: string, t: Theme): {
+    icon: string;
+    color: number;
+    name: string;
+};
+/** Pixel mascot + wordmark (plain text; colour is applied per theme). */
+export declare const LOGO_ART: string[];

package/dist/cli/tui/brand.js

@@ -0,0 +1,16 @@
+/** Provider/model identity (glyph + colour) for the active theme. */
+export function brandOfModel(model, provider, t) {
+    if (/claude|fable|mythos/i.test(model) || provider === "anthropic")
+        return { icon: "✻", color: 0xd97757, name: "Claude" };
+    if (/gpt|o[134]-|openai/i.test(model) || provider === "openai")
+        return { icon: "◈", color: 0x10a37f, name: "OpenAI" };
+    if (/llama|qwen|mistral|gemma|phi|deepseek|ollama/i.test(model) || provider === "ollama")
+        return { icon: "⬢", color: t.dim, name: "Local" };
+    return { icon: "◆", color: t.info, name: "Custom" };
+}
+/** Pixel mascot + wordmark (plain text; colour is applied per theme). */
+export const LOGO_ART = [
+    "    ▗▄▄▄▄▄▄▖",
+    "    █ ◖  ◗ █     ▄▀█ █▀▄▀█ █▄ █ █▀▀ █▀ █▀",
+    "    ▝▀▀▀▀▀▀▘     █▀█ █ ▀ █ █ ▀█ ██▄ ▄█ ▄█",
+];

package/dist/cli/tui/canvas.d.ts

@@ -0,0 +1,92 @@
+import { type Cell } from "./ansi.ts";
+export type Style = {
+    fg?: number;
+    bg?: number;
+    attr?: number;
+};
+export declare const BORDERS: {
+    readonly round: {
+        readonly tl: "╭";
+        readonly tr: "╮";
+        readonly bl: "╰";
+        readonly br: "╯";
+        readonly h: "─";
+        readonly v: "│";
+    };
+    readonly square: {
+        readonly tl: "┌";
+        readonly tr: "┐";
+        readonly bl: "└";
+        readonly br: "┘";
+        readonly h: "─";
+        readonly v: "│";
+    };
+    readonly thick: {
+        readonly tl: "┏";
+        readonly tr: "┓";
+        readonly bl: "┗";
+        readonly br: "┛";
+        readonly h: "━";
+        readonly v: "┃";
+    };
+    readonly double: {
+        readonly tl: "╔";
+        readonly tr: "╗";
+        readonly bl: "╚";
+        readonly br: "╝";
+        readonly h: "═";
+        readonly v: "║";
+    };
+};
+/** Reduce a 24-bit colour to what the terminal can show. level: 3 truecolor, 2 = 256 colours, 1 = 16 colours, 0 = none. */
+export declare function quantize(c: number, level: 0 | 1 | 2 | 3, isBg?: boolean): number;
+export declare class Canvas {
+    w: number;
+    h: number;
+    ch: string[];
+    fg: Int32Array;
+    bg: Int32Array;
+    attr: Uint8Array;
+    private prev?;
+    cursor: {
+        x: number;
+        y: number;
+    } | null;
+    level: 0 | 1 | 2 | 3;
+    defaultBg: number;
+    constructor(w: number, h: number, defaultBg?: number);
+    private i;
+    inside(x: number, y: number): boolean;
+    clear(bg?: number, fg?: number): void;
+    /** Fill a rectangle with a background (and optionally a glyph). */
+    fill(x: number, y: number, w: number, h: number, bg: number, ch?: string, fg?: number): void;
+    /** Blank whatever wide glyph occupies cell (x,y) (either half), so no orphaned half is left behind. */
+    private breakGlyph;
+    setCell(x: number, y: number, c: Cell, keepBg?: boolean): void;
+    /** Draw styled cells; returns the width used. Cells with the default background keep what is underneath. */
+    put(x: number, y: number, cells: Cell[], maxW?: number): number;
+    /** Draw a plain string with one style. */
+    text(x: number, y: number, s: string, st?: Style, maxW?: number): number;
+    /** Draw an ANSI string (as produced by the renderers). */
+    ansi(x: number, y: number, s: string, base?: Style, maxW?: number): number;
+    hline(x: number, y: number, w: number, ch: string, st: Style): void;
+    /** A bordered box; the interior is filled with `bg`. A title sits in the top border. */
+    box(x: number, y: number, w: number, h: number, o?: {
+        border?: number;
+        bg?: number;
+        style?: keyof typeof BORDERS;
+        title?: string;
+        titleFg?: number;
+        titleBg?: number;
+    }): void;
+    /** Fade everything inside a rectangle toward `toward` (modal backdrop). */
+    dim(x: number, y: number, w: number, h: number, t: number, toward: number, defFg: number, defBg: number): void;
+    /** Tint the background of a rectangle (selection, hover). */
+    tint(x: number, y: number, w: number, h: number, bg: number): void;
+    /** Text of a row range (for copy), trailing spaces trimmed. */
+    readRow(y: number, x0?: number, x1?: number): string;
+    /** Emit the minimal escape sequence that turns the previous frame into this one. `full` repaints everything. */
+    flush(full?: boolean): string;
+    /** Forget what is on the terminal (after a resize or an external clear) so the next flush repaints everything. */
+    invalidate(): void;
+}

package/dist/cli/tui/canvas.js

@@ -0,0 +1,199 @@
+// A character-cell canvas. Draw into it freely, then `flush()` emits only the cells that changed since the last frame
+// (inside synchronized-output markers), which is what makes a full-screen UI flicker-free and cheap over SSH.
+import { A, DEFAULT, mix, parseAnsi, sgrFor, toRgb } from "./ansi.js";
+import { cpWidth } from "./text.js";
+export const BORDERS = {
+    round: { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" },
+    square: { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│" },
+    thick: { tl: "┏", tr: "┓", bl: "┗", br: "┛", h: "━", v: "┃" },
+    double: { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║" },
+};
+/** Reduce a 24-bit colour to what the terminal can show. level: 3 truecolor, 2 = 256 colours, 1 = 16 colours, 0 = none. */
+export function quantize(c, level, isBg = false) {
+    if (c === DEFAULT || level === 0 || c >= 0x1000000)
+        return level === 0 ? DEFAULT : c;
+    if (level === 3)
+        return c;
+    const r = (c >> 16) & 255, g = (c >> 8) & 255, b = c & 255;
+    if (level === 2) {
+        if (Math.abs(r - g) < 9 && Math.abs(g - b) < 9) {
+            const v = Math.round(((r + g + b) / 3 - 8) / 10);
+            return 0x1000000 + (v < 0 ? 16 : v > 23 ? 231 : 232 + v);
+        }
+        const q = (x) => Math.round((x / 255) * 5);
+        return 0x1000000 + 16 + 36 * q(r) + 6 * q(g) + q(b);
+    }
+    const bright = Math.max(r, g, b) > (isBg ? 230 : 190), idx = (r > 127 ? 1 : 0) | (g > 127 ? 2 : 0) | (b > 127 ? 4 : 0);
+    return 0x1000000 + (bright && !isBg ? 8 : 0) + (idx === 0 && !bright ? 0 : idx || 7);
+}
+export class Canvas {
+    w;
+    h;
+    ch;
+    fg;
+    bg;
+    attr;
+    prev;
+    cursor = null;
+    level = 3;
+    defaultBg;
+    constructor(w, h, defaultBg = DEFAULT) {
+        this.w = w;
+        this.h = h;
+        this.defaultBg = defaultBg;
+        this.ch = new Array(w * h).fill(" ");
+        this.fg = new Int32Array(w * h).fill(DEFAULT);
+        this.bg = new Int32Array(w * h).fill(defaultBg);
+        this.attr = new Uint8Array(w * h);
+    }
+    i(x, y) { return y * this.w + x; }
+    inside(x, y) { return x >= 0 && y >= 0 && x < this.w && y < this.h; }
+    clear(bg = this.defaultBg, fg = DEFAULT) { this.ch.fill(" "); this.fg.fill(fg); this.bg.fill(bg); this.attr.fill(0); }
+    /** Fill a rectangle with a background (and optionally a glyph). */
+    fill(x, y, w, h, bg, ch = " ", fg = DEFAULT) {
+        for (let yy = Math.max(0, y); yy < Math.min(this.h, y + h); yy++)
+            for (let xx = Math.max(0, x); xx < Math.min(this.w, x + w); xx++) {
+                this.breakGlyph(xx, yy);
+                const i = this.i(xx, yy);
+                this.ch[i] = ch;
+                this.bg[i] = bg;
+                this.fg[i] = fg;
+                this.attr[i] = 0;
+            }
+    }
+    /** Blank whatever wide glyph occupies cell (x,y) (either half), so no orphaned half is left behind. */
+    breakGlyph(x, y) {
+        const i = this.i(x, y);
+        if (this.ch[i] === "" && x > 0)
+            this.ch[i - 1] = " "; // overwriting the right half destroys the glyph
+        if (x + 1 < this.w && this.ch[i + 1] === "")
+            this.ch[i + 1] = " "; // overwriting the left half orphans the right half
+    }
+    setCell(x, y, c, keepBg = false) {
+        if (!this.inside(x, y))
+            return;
+        if (c.w === 2 && x + 1 >= this.w) {
+            c = { ...c, ch: " ", w: 1 };
+        } // a wide glyph never straddles the edge
+        this.breakGlyph(x, y);
+        if (c.w === 2)
+            this.breakGlyph(x + 1, y);
+        const i = this.i(x, y);
+        this.ch[i] = c.ch;
+        this.fg[i] = c.fg;
+        this.attr[i] = c.attr;
+        if (!keepBg || c.bg !== DEFAULT)
+            this.bg[i] = c.bg;
+        if (c.w === 2) {
+            const j = i + 1;
+            this.ch[j] = "";
+            this.fg[j] = c.fg;
+            this.bg[j] = this.bg[i];
+            this.attr[j] = c.attr;
+        }
+    }
+    /** Draw styled cells; returns the width used. Cells with the default background keep what is underneath. */
+    put(x, y, cells, maxW = this.w - x) {
+        let used = 0;
+        for (const c of cells) {
+            if (used + c.w > maxW)
+                break;
+            this.setCell(x + used, y, c, true);
+            used += c.w;
+        }
+        return used;
+    }
+    /** Draw a plain string with one style. */
+    text(x, y, s, st = {}, maxW = this.w - x) {
+        const cells = [];
+        for (const g of s) {
+            const w = cpWidth(g.codePointAt(0));
+            if (w === 0)
+                continue;
+            cells.push({ ch: g, w, fg: st.fg ?? DEFAULT, bg: st.bg ?? DEFAULT, attr: st.attr ?? 0 });
+        }
+        return this.put(x, y, cells, maxW);
+    }
+    /** Draw an ANSI string (as produced by the renderers). */
+    ansi(x, y, s, base = {}, maxW = this.w - x) { return this.put(x, y, parseAnsi(s, base), maxW); }
+    hline(x, y, w, ch, st) { for (let k = 0; k < w; k++)
+        this.text(x + k, y, ch, st); }
+    /** A bordered box; the interior is filled with `bg`. A title sits in the top border. */
+    box(x, y, w, h, o = {}) {
+        const b = BORDERS[o.style ?? "round"], st = { fg: o.border ?? DEFAULT, bg: o.bg ?? DEFAULT };
+        if (w < 2 || h < 2)
+            return;
+        if (o.bg !== undefined)
+            this.fill(x, y, w, h, o.bg);
+        this.text(x, y, b.tl + b.h.repeat(w - 2) + b.tr, st);
+        this.text(x, y + h - 1, b.bl + b.h.repeat(w - 2) + b.br, st);
+        for (let yy = y + 1; yy < y + h - 1; yy++) {
+            this.text(x, yy, b.v, st);
+            this.text(x + w - 1, yy, b.v, st);
+        }
+        if (o.title)
+            this.text(x + 2, y, ` ${o.title} `, { fg: o.titleFg ?? o.border, bg: o.titleBg ?? o.bg, attr: A.bold }, w - 4);
+    }
+    /** Fade everything inside a rectangle toward `toward` (modal backdrop). */
+    dim(x, y, w, h, t, toward, defFg, defBg) {
+        for (let yy = Math.max(0, y); yy < Math.min(this.h, y + h); yy++)
+            for (let xx = Math.max(0, x); xx < Math.min(this.w, x + w); xx++) {
+                const i = this.i(xx, yy);
+                this.fg[i] = mix(toRgb(this.fg[i], defFg), toward, t);
+                this.bg[i] = mix(toRgb(this.bg[i], defBg), toward, t * 0.8);
+            }
+    }
+    /** Tint the background of a rectangle (selection, hover). */
+    tint(x, y, w, h, bg) { for (let yy = Math.max(0, y); yy < Math.min(this.h, y + h); yy++)
+        for (let xx = Math.max(0, x); xx < Math.min(this.w, x + w); xx++)
+            this.bg[this.i(xx, yy)] = bg; }
+    /** Text of a row range (for copy), trailing spaces trimmed. */
+    readRow(y, x0 = 0, x1 = this.w) { let s = ""; for (let x = x0; x < x1; x++)
+        s += this.ch[this.i(x, y)]; return s.replace(/\s+$/, ""); }
+    /** Emit the minimal escape sequence that turns the previous frame into this one. `full` repaints everything. */
+    flush(full = false) {
+        for (let i = 0; i < this.ch.length; i++)
+            if (this.ch[i] === "" && i % this.w > 0) {
+                this.bg[i] = this.bg[i - 1];
+                this.fg[i] = this.fg[i - 1];
+                this.attr[i] = this.attr[i - 1];
+            }
+        const prev = full ? undefined : this.prev;
+        let out = "", lastFg = -2, lastBg = -2, lastAttr = -1, penX = -1, penY = -1;
+        const q = (c, bg) => quantize(c, this.level, bg);
+        for (let y = 0; y < this.h; y++) {
+            let x = 0;
+            while (x < this.w) {
+                const i = this.i(x, y);
+                if (prev && prev.ch[i] === this.ch[i] && prev.fg[i] === this.fg[i] && prev.bg[i] === this.bg[i] && prev.attr[i] === this.attr[i]) {
+                    x++;
+                    continue;
+                }
+                if (this.ch[i] === "") {
+                    x++;
+                    continue;
+                } // second half of a wide character
+                if (x !== penX || y !== penY)
+                    out += `\x1b[${y + 1};${x + 1}H`;
+                const f = q(this.fg[i], false), b = q(this.bg[i], true), a = this.attr[i];
+                if (f !== lastFg || b !== lastBg || a !== lastAttr) {
+                    out += sgrFor(f, b, a);
+                    lastFg = f;
+                    lastBg = b;
+                    lastAttr = a;
+                }
+                out += this.ch[i];
+                const w = x + 1 < this.w && this.ch[i + 1] === "" ? 2 : 1;
+                x += w;
+                penX = x;
+                penY = y;
+            }
+        }
+        if (out)
+            out += "\x1b[0m";
+        this.prev = { ch: this.ch.slice(), fg: this.fg.slice(), bg: this.bg.slice(), attr: this.attr.slice() };
+        return out;
+    }
+    /** Forget what is on the terminal (after a resize or an external clear) so the next flush repaints everything. */
+    invalidate() { this.prev = undefined; }
+}

package/dist/cli/tui/cards.d.ts

@@ -0,0 +1,44 @@
+import type { Block } from "./blocks.ts";
+import { type Cell } from "./ansi.ts";
+import type { Theme } from "./themes.ts";
+export type RenderCtx = {
+    theme: Theme;
+    width: number;
+    now: number;
+    frame: number;
+    expandAll: boolean;
+    live: boolean;
+    /** the steps a subagent card ran (full-screen view nests them inside the card) */ kids?: (callId: string) => ToolBlock[];
+    brand: {
+        icon: string;
+        color: number;
+    };
+    diffMode: "auto" | "stacked" | "split";
+    /** The block above is also a tool call: draw no blank line between them, so a run of tool calls reads as one unit. */
+    tight?: boolean;
+};
+export type Hit = {
+    row: number;
+    x0: number;
+    x1: number;
+    kind: "toggle" | "more" | "copy";
+    id: number; /** for "copy": what lands on the clipboard */
+    text?: string;
+};
+export type Rendered = {
+    rows: Cell[][];
+    hits: Hit[];
+    text: string[];
+};
+/** Short, honest one-line summary of a tool result for the card header. */
+export declare function summarize(name: string, raw: string, result: string): string;
+type ToolBlock = Extract<Block, {
+    kind: "tool";
+}>;
+/** Tool calls that only look at things. A run of them collapses into one "Explored" row; edits, commands and failures always stand alone. */
+export declare const isQuiet: (b: Block) => b is ToolBlock;
+/** "3 files read · 2 searches": what a group of quiet tool calls did, in one phrase. */
+export declare function groupSummary(bs: ToolBlock[]): string;
+export declare function renderGroup(bs: ToolBlock[], open: boolean, c: RenderCtx): Rendered;
+export declare function renderBlock(b: Block, c: RenderCtx): Rendered;
+export {};