amness 0.0.0-stage → 0.1.2

package/dist/cli/tui/overlays.js

@@ -0,0 +1,237 @@
+// Modal pieces drawn in the live region in place of the input box: choices, pickers, text input, help.
+import { bold, cyan, dim, gray } from "../ui.js";
+import { Editor } from "./editor.js";
+import { cellWidth, clipWidth, strip } from "./text.js";
+import { framed, helpLines, optionList } from "./view.js";
+/** Standard text-editing keys, shared by the main input and text overlays. Returns true if the key was consumed. */
+export function editKey(ed, k) {
+    if (k.name === "paste") {
+        ed.paste(k.text ?? "");
+        return true;
+    }
+    if (k.name === "char") {
+        if (k.alt && k.text === "b")
+            ed.wordLeft();
+        else if (k.alt && k.text === "f")
+            ed.wordRight();
+        else if (k.alt && k.text === "d") {
+            ed.wordRight();
+            ed.deleteWordBack();
+        }
+        else if (!k.alt && !k.ctrl)
+            ed.insert(k.text ?? "");
+        else
+            return false;
+        return true;
+    }
+    if (k.ctrl && !k.alt) {
+        switch (k.name) {
+            case "a":
+                ed.home();
+                return true;
+            case "e":
+                ed.end();
+                return true;
+            case "b":
+                ed.left();
+                return true;
+            case "f":
+                ed.right();
+                return true;
+            case "k":
+                ed.killToEnd();
+                return true;
+            case "u":
+                ed.killToStart();
+                return true;
+            case "w":
+                ed.deleteWordBack();
+                return true;
+            case "h":
+                ed.backspace();
+                return true;
+            case "j":
+                ed.newline();
+                return true;
+            case "d":
+                if (!ed.empty) {
+                    ed.del();
+                    return true;
+                }
+                return false;
+            case "left":
+                ed.wordLeft();
+                return true;
+            case "right":
+                ed.wordRight();
+                return true;
+        }
+    }
+    switch (k.name) {
+        case "left":
+            k.alt || k.ctrl ? ed.wordLeft() : ed.left();
+            return true;
+        case "right":
+            k.alt || k.ctrl ? ed.wordRight() : ed.right();
+            return true;
+        case "home":
+            ed.home();
+            return true;
+        case "end":
+            ed.end();
+            return true;
+        case "backspace":
+            k.alt ? ed.deleteWordBack() : ed.backspace();
+            return true;
+        case "delete":
+            ed.del();
+            return true;
+        case "enter":
+            if (k.alt || k.shift) {
+                ed.newline();
+                return true;
+            }
+            return false;
+    }
+    return false;
+}
+/** Numbered choices inside a titled box (permission prompts). Resolves with the chosen index, or undefined on Esc. */
+export class ChoiceOverlay {
+    sel = 0;
+    title;
+    body;
+    question;
+    options;
+    done;
+    detail;
+    constructor(title, body, question, options, done, paint, detail) {
+        this.title = title;
+        this.body = body;
+        this.question = question;
+        this.options = options;
+        this.done = done;
+        this.paint = paint;
+        this.detail = detail;
+    }
+    paint;
+    render(width) {
+        return { lines: [...framed(this.title, this.body, Math.min(width, 100), this.paint), " " + bold(this.question), ...optionList(this.options, this.sel).map((l) => " " + l), dim("  ↑/↓ choose · enter confirm · esc cancel")] };
+    }
+    key(k) {
+        if (k.name === "up" || (k.name === "char" && k.text === "k"))
+            this.sel = (this.sel + this.options.length - 1) % this.options.length;
+        else if (k.name === "down" || k.name === "tab" || (k.name === "char" && k.text === "j"))
+            this.sel = (this.sel + 1) % this.options.length;
+        else if (k.name === "char" && /^[1-9]$/.test(k.text ?? "") && Number(k.text) <= this.options.length)
+            this.done(Number(k.text) - 1);
+        else if (k.name === "enter")
+            this.done(this.sel);
+        else if (k.name === "escape" || (k.ctrl && k.name === "c"))
+            this.done(undefined);
+    }
+}
+/** Filterable list. Type to filter, ↑/↓ to move, enter to pick, esc to cancel. */
+export class PickerOverlay {
+    sel = 0;
+    filter = "";
+    title;
+    items;
+    done;
+    max;
+    constructor(title, items, done, initial = 0, max = 10) { this.title = title; this.items = items; this.done = done; this.sel = initial; this.max = max; }
+    visible() { const f = this.filter.toLowerCase(); return f ? this.items.filter((i) => `${i.label} ${i.hint ?? ""}`.toLowerCase().includes(f)) : this.items; }
+    /** Called whenever the highlighted item changes (live theme preview). */
+    onMove;
+    /** Choose the i-th visible item (mouse click). */
+    pick(i) { const it = this.visible()[i]; if (it)
+        this.done(it.value); }
+    moved() { this.onMove?.(this.visible()[this.sel]?.value); }
+    render(width) {
+        const list = this.visible();
+        this.sel = Math.max(0, Math.min(this.sel, list.length - 1));
+        const top = Math.max(0, Math.min(this.sel - Math.floor(this.max / 2), list.length - this.max)), slice = list.slice(top, top + this.max);
+        const lw = Math.min(40, Math.max(0, ...slice.map((i) => cellWidth(i.label))));
+        const rows = slice.map((it, k) => {
+            const on = top + k === this.sel, label = clipWidth(it.label, lw) + " ".repeat(Math.max(0, lw - cellWidth(it.label)));
+            const line = (on ? cyan("❯ ") + bold(cyan(label)) : "  " + label) + (it.hint ? "  " + (on ? gray(it.hint) : dim(it.hint)) : "");
+            return cellWidth(strip(line)) > width - 1 ? line.slice(0, width + 10) : line;
+        });
+        const head = bold(this.title) + (this.filter ? "  " + cyan("/") + this.filter : dim(this.items.length > this.max ? "  (type to filter)" : ""));
+        return { lines: [head, ...(top > 0 ? [dim(`  ↑ ${top} more`)] : []), ...rows, ...(top + this.max < list.length ? [dim(`  ↓ ${list.length - top - this.max} more`)] : []), ...(list.length ? [] : [dim("  no matches")]), dim("  ↑/↓ move · enter select · esc cancel")] };
+    }
+    key(k) {
+        const list = this.visible();
+        if (k.name === "up") {
+            this.sel = (this.sel + list.length - 1) % Math.max(1, list.length);
+            this.moved();
+        }
+        else if (k.name === "down") {
+            this.sel = (this.sel + 1) % Math.max(1, list.length);
+            this.moved();
+        }
+        else if (k.name === "enter") {
+            if (list.length)
+                this.done(list[this.sel].value);
+        }
+        else if (k.name === "escape" || (k.ctrl && k.name === "c"))
+            this.done(undefined);
+        else if (k.name === "backspace") {
+            this.filter = this.filter.slice(0, -1);
+            this.sel = 0;
+        }
+        else if (k.name === "char" && !k.alt && !k.ctrl) {
+            this.filter += k.text;
+            this.sel = 0;
+        }
+    }
+}
+/** One-shot text prompt ("what should it do instead?", API key). Esc cancels. */
+export class InputOverlay {
+    ed = new Editor();
+    prompt;
+    secret;
+    done;
+    hint;
+    constructor(prompt, done, o = {}) {
+        this.prompt = prompt;
+        this.done = done;
+        this.secret = !!o.secret;
+        this.hint = o.hint ?? "enter to confirm · esc to cancel";
+        if (o.initial)
+            this.ed.insert(o.initial);
+    }
+    render(width) {
+        if (this.secret) {
+            const n = this.ed.text.length;
+            return { lines: [" " + bold(this.prompt), "❯ " + "•".repeat(n), dim("  " + this.hint)], cursor: { row: 1, col: 2 + n } };
+        }
+        const r = this.ed.render(width - 1);
+        return { lines: [" " + bold(this.prompt), ...r.lines, dim("  " + this.hint)], cursor: { row: 1 + r.cursor.row, col: r.cursor.col } };
+    }
+    key(k) {
+        if (k.name === "escape" || (k.ctrl && k.name === "c"))
+            return this.done(undefined);
+        if (k.name === "enter" && !k.alt && !k.shift)
+            return this.done(this.ed.text.trim());
+        if (k.name === "paste" && this.secret)
+            return void this.ed.insert((k.text ?? "").replace(/\s+/g, ""));
+        editKey(this.ed, k);
+    }
+}
+/** Static text (help) closed by any key. */
+export class TextOverlay {
+    lines;
+    done;
+    scroll = 0;
+    title;
+    constructor(lines, done, title = "Help") { this.lines = lines; this.done = done; this.title = title; }
+    render() { return { lines: [...this.lines, dim("  press any key to close")] }; }
+    key(k) {
+        const step = k?.name === "up" ? -1 : k?.name === "down" ? 1 : k?.name === "pageup" ? -10 : k?.name === "pagedown" ? 10 : k?.name === "home" ? -1e6 : k?.name === "end" ? 1e6 : 0;
+        if (step)
+            this.scroll = Math.max(0, this.scroll + step);
+        else
+            this.done(); // arrows scroll long text; anything else closes it
+    }
+}
+export const helpOverlay = (cmds, done, width) => new TextOverlay(helpLines(cmds, width), done);

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

@@ -0,0 +1,15 @@
+import type { Message } from "../../src/index.ts";
+import type { Key } from "./keys.ts";
+import type { Out } from "./screen.ts";
+export declare function transcriptLines(messages: Message[], width: number): string[];
+export declare class Pager {
+    top: number;
+    lines: string[];
+    out: Out;
+    done: () => void;
+    title: string;
+    constructor(lines: string[], out: Out, done: () => void, title?: string, start?: "top" | "bottom");
+    private page;
+    draw(): void;
+    key(k: Key): void;
+}

package/dist/cli/tui/pager.js

@@ -0,0 +1,66 @@
+import { bold, cyan, dim, gray, green, red } from "../ui.js";
+import { renderMarkdown } from "./markdown.js";
+import { clipAnsi, wrapAnsi } from "./text.js";
+import { argSummary, isFailure, toolLabel } from "./view.js";
+export function transcriptLines(messages, width) {
+    const out = [], names = new Map();
+    for (const m of messages) {
+        if (m.role === "system")
+            continue;
+        if (m.role === "user") {
+            out.push("", ...wrapAnsi(m.content ?? "", width - 2).map((l, i) => (i ? "  " : bold(cyan("❯ "))) + bold(l)));
+            continue;
+        }
+        if (m.role === "assistant") {
+            if (m.content?.trim())
+                out.push("", ...renderMarkdown(m.content, width - 2).map((l, i) => (i ? "  " : bold("● ")) + l));
+            for (const c of m.tool_calls ?? []) {
+                names.set(c.id, c.function.name);
+                out.push(`${bold(green("●"))} ${bold(toolLabel(c.function.name))}${dim("(")}${argSummary(c.function.name, c.function.arguments)}${dim(")")}`);
+            }
+            continue;
+        }
+        const body = (m.content ?? "").split("\n"), name = names.get(m.tool_call_id ?? "") ?? "";
+        const paint = isFailure(m.content ?? "") ? red : gray;
+        out.push(...body.slice(0, 400).flatMap((l) => wrapAnsi(paint(l), width - 5, 0)).map((l) => dim("  ⎿  ") + l));
+        if (body.length > 400)
+            out.push(dim(`  ⎿  … +${body.length - 400} more lines (${name})`));
+    }
+    return out;
+}
+export class Pager {
+    top = 0;
+    lines;
+    out;
+    done;
+    title;
+    constructor(lines, out, done, title = "transcript", start = "bottom") { this.lines = lines; this.out = out; this.done = done; this.title = title; this.top = start === "top" ? 0 : Math.max(0, lines.length - this.page()); this.draw(); }
+    page() { return Math.max(3, (this.out.rows || 24) - 2); }
+    draw() {
+        const cols = this.out.columns || 80, page = this.page(), max = Math.max(0, this.lines.length - page);
+        this.top = Math.max(0, Math.min(this.top, max));
+        const pct = this.lines.length <= page ? 100 : Math.round((this.top / max) * 100);
+        const body = this.lines.slice(this.top, this.top + page).map((l) => clipAnsi(l, cols));
+        while (body.length < page)
+            body.push("");
+        this.out.write("\x1b[H\x1b[2J" + body.join("\r\n") + "\r\n" + dim(`  ${this.title} · ${pct}% · ↑/↓ j/k scroll · space/b page · g/G top/bottom · q/esc/ctrl+o close`));
+    }
+    key(k) {
+        const page = this.page();
+        if (k.name === "escape" || (k.name === "char" && k.text === "q") || (k.ctrl && (k.name === "o" || k.name === "c")))
+            return this.done();
+        if (k.name === "up" || (k.name === "char" && k.text === "k"))
+            this.top--;
+        else if (k.name === "down" || (k.name === "char" && k.text === "j") || k.name === "enter")
+            this.top++;
+        else if (k.name === "pagedown" || (k.name === "char" && k.text === " "))
+            this.top += page - 1;
+        else if (k.name === "pageup" || (k.name === "char" && k.text === "b"))
+            this.top -= page - 1;
+        else if (k.name === "home" || (k.name === "char" && k.text === "g"))
+            this.top = 0;
+        else if (k.name === "end" || (k.name === "char" && k.text === "G"))
+            this.top = this.lines.length;
+        this.draw();
+    }
+}

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

@@ -0,0 +1,9 @@
+export declare const priceOf: (model: string) => [RegExp, number, number] | undefined;
+export declare const contextWindow: (model: string) => number;
+/** Estimated dollars for a token split, or null when the model's price is unknown. */
+/** Cached input is billed at roughly a tenth of the normal input price on both OpenAI and Anthropic; this is an estimate, not an invoice. */
+export declare const CACHED_RATE = 0.1;
+export declare function estimateCost(model: string, promptTokens: number, completionTokens: number, cachedTokens?: number): number | null;
+export declare const fmtCost: (c: number | null) => string;
+export declare const fmtTokens: (n: number) => string;
+export declare const fmtDuration: (ms: number) => string;

package/dist/cli/tui/pricing.js

@@ -0,0 +1,23 @@
+// Rough price + context-window tables so the footer can show cost and context use. Estimates only: cache discounts are not modelled.
+const PRICES = [
+    [/gpt-6-astra/, 10, 50], [/gpt-6(\.\d+)?-sol/, 2, 10], [/gpt-6(\.\d+)?-terra/, 1, 5], [/gpt-6(\.\d+)?-luna/, 0.1, 0.5],
+    [/claude-fable/, 10, 50], [/claude-mythos/, 10, 50], [/claude-opus-5-5/, 4, 20], [/claude-opus/, 5, 25],
+    [/claude-sonnet-5/, 2, 10], [/claude-sonnet/, 3, 15], [/claude-haiku-5/, 0.1, 0.5], [/claude-haiku/, 1, 5],
+    [/gpt-4\.1-mini/, 0.4, 1.6], [/gpt-4\.1/, 2, 8], [/gpt-4o-mini/, 0.15, 0.6], [/gpt-4o/, 2.5, 10], [/gpt-5/, 1.25, 10], [/o[134]-?mini/, 1.1, 4.4],
+];
+const WINDOWS = [[/gpt-6|gpt-5\.[5-9]/, 1_050_000], [/claude-(fable|mythos|opus-[45]|sonnet-[45]|haiku-5)/, 1_000_000], [/claude/, 200_000], [/gpt-4\.1/, 1_000_000], [/gpt-5/, 400_000], [/gpt-4o|o[134]/, 128_000]];
+export const priceOf = (model) => PRICES.find(([re]) => re.test(model));
+export const contextWindow = (model) => WINDOWS.find(([re]) => re.test(model))?.[1] ?? 128_000;
+/** Estimated dollars for a token split, or null when the model's price is unknown. */
+/** Cached input is billed at roughly a tenth of the normal input price on both OpenAI and Anthropic; this is an estimate, not an invoice. */
+export const CACHED_RATE = 0.1;
+export function estimateCost(model, promptTokens, completionTokens, cachedTokens = 0) {
+    const p = priceOf(model);
+    if (!p)
+        return null;
+    const cached = Math.min(cachedTokens, promptTokens);
+    return ((promptTokens - cached) * p[1] + cached * p[1] * CACHED_RATE + completionTokens * p[2]) / 1_000_000;
+}
+export const fmtCost = (c) => (c === null ? "" : c < 0.01 ? "<$0.01" : "$" + c.toFixed(2));
+export const fmtTokens = (n) => (n >= 1_000_000 ? (n / 1e6).toFixed(1) + "M" : n >= 1000 ? (n / 1000).toFixed(n >= 10_000 ? 0 : 1) + "k" : String(n));
+export const fmtDuration = (ms) => { const s = Math.round(ms / 1000); return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`; };

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

@@ -0,0 +1,16 @@
+import { type Skin } from "./markdown.ts";
+import type { Theme } from "./themes.ts";
+export declare const F: (c: number, s: string) => string;
+export declare const B: (c: number, s: string) => string;
+export declare const BOLD: (s: string) => string;
+export declare const DIMM: (s: string) => string;
+export declare const ITAL: (s: string) => string;
+export declare const UNDER: (s: string) => string;
+export declare const STRIKE: (s: string) => string;
+/** Make `content` exactly `width` columns: clip if longer, pad with spaces on background `bg` if shorter. */
+export declare function fit(content: string, width: number, bg: number): string;
+/** Left part, flexible gap, right part, all on one background. */
+export declare function split(left: string, right: string, width: number, bg: number): string;
+/** A small pill: padded text on its own background. */
+export declare const chip: (text: string, fg: number, bg: number, bold?: boolean) => string;
+export declare function themeSkin(t: Theme): Skin;

package/dist/cli/tui/rich.js

@@ -0,0 +1,72 @@
+// Row-building helpers and the themed markdown skin for the full-screen UI.
+// Convention: helpers reset only what they set (fg -> 39, bg -> 49, bold -> 22), so a row can carry one background across many styled spans.
+import { bgSeq, fgSeq } from "./ansi.js";
+import { highlightWith } from "./markdown.js";
+import { cellWidth, clipAnsi, strip, wrapAnsi } from "./text.js";
+export const F = (c, s) => (s ? fgSeq(c) + s + "\x1b[39m" : s);
+export const B = (c, s) => (s ? bgSeq(c) + s + "\x1b[49m" : s);
+export const BOLD = (s) => `\x1b[1m${s}\x1b[22m`;
+export const DIMM = (s) => `\x1b[2m${s}\x1b[22m`;
+export const ITAL = (s) => `\x1b[3m${s}\x1b[23m`;
+export const UNDER = (s) => `\x1b[4m${s}\x1b[24m`;
+export const STRIKE = (s) => `\x1b[9m${s}\x1b[29m`;
+/** Make `content` exactly `width` columns: clip if longer, pad with spaces on background `bg` if shorter. */
+export function fit(content, width, bg) {
+    const w = cellWidth(content), b = bgSeq(bg);
+    const c = (w > width ? clipAnsi(content, width) : content).replace(/\x1b\[49m/g, b).replace(/\x1b\[0m/g, "\x1b[0m" + b); // inner resets must fall back to the ROW background, not the terminal's
+    return b + c + b + " ".repeat(Math.max(0, width - Math.min(w, width))) + "\x1b[49m";
+}
+/** Left part, flexible gap, right part, all on one background. */
+export function split(left, right, width, bg) {
+    const gap = width - cellWidth(left) - cellWidth(right);
+    return gap >= 1 ? fit(left + " ".repeat(gap) + right, width, bg) : fit(left, width, bg);
+}
+/** A small pill: padded text on its own background. */
+export const chip = (text, fg, bg, bold = false) => bgSeq(bg) + fgSeq(fg) + (bold ? "\x1b[1m" : "") + ` ${text} ` + (bold ? "\x1b[22m" : "") + "\x1b[39m\x1b[49m";
+export function themeSkin(t) {
+    const hl = (k, s) => (k === "plain" ? F(t.syn.plain, s) : F(t.syn[k === "keyword" ? "keyword" : k === "string" ? "string" : k === "number" ? "number" : "comment"], k === "comment" ? ITAL(s) : s));
+    const skin = {
+        bold: BOLD, italic: ITAL, strike: STRIKE, dim: (s) => F(t.dim, s),
+        code: (s) => B(t.inlineCodeBg, F(t.inlineCode, ` ${s} `)),
+        link: (text, url) => F(t.link, UNDER(text)) + F(t.faint, ` ${url}`),
+        heading(level, text, width) {
+            if (level === 1)
+                return [BOLD(F(t.accent, strip(text).toUpperCase() === strip(text) ? text : text)), F(t.border, "━".repeat(Math.min(width, Math.max(10, cellWidth(strip(text))))))];
+            if (level === 2)
+                return [BOLD(F(t.accent2, text)), F(t.border, "─".repeat(Math.min(width, Math.max(8, cellWidth(strip(text))))))];
+            return [BOLD(F(t.text, text))];
+        },
+        quote: (inner) => F(t.accent, "▎ ") + ITAL(F(t.dim, inner)),
+        bullet: (m) => F(t.accent, m),
+        hr: (w) => F(t.border, "─".repeat(Math.min(w, 72))),
+        hl,
+        codeBlock(body, lang, width) {
+            const out = [], inner = width - 4;
+            const head = split(" " + F(t.dim, (lang || "text").toLowerCase()), F(t.faint, "copy "), width, t.surface2);
+            out.push(head);
+            for (const b of body.length ? body : [""]) {
+                const styled = lang === "diff" ? (b.startsWith("+") ? F(t.addFg, b) : b.startsWith("-") ? F(t.delFg, b) : b.startsWith("@@") ? F(t.accent2, b) : F(t.dim, b)) : highlightWith(b, lang, hl);
+                const rows = wrapAnsi(styled, inner, 2);
+                for (const r of rows)
+                    out.push(fit("  " + r, width, t.surface));
+            }
+            out.push(fit("", width, t.surface));
+            return out;
+        },
+        table(rows, width) {
+            const n = Math.max(...rows.map((r) => r.length)), cellOf = (s) => inlineCell(s, skin);
+            const widths = Array.from({ length: n }, (_, i) => Math.max(...rows.map((r) => cellWidth(cellOf(r[i] ?? "")))));
+            if (widths.reduce((a, b) => a + b, 0) + 3 * n + 1 > width)
+                return rows.map((r, i) => (i === 0 ? BOLD(r.join(" │ ")) : r.join(" │ ")));
+            const v = F(t.border, "│"), rule = (l, m, r) => F(t.border, l + widths.map((w) => "─".repeat(w + 2)).join(m) + r);
+            const line = (r, head) => {
+                const cells = widths.map((w, i) => { const c = cellOf(r[i] ?? ""); return " " + (head ? BOLD(F(t.accent2, c)) : c) + " ".repeat(w - cellWidth(c)) + " "; });
+                return v + cells.map((c) => (head ? B(t.surface2, c) : c)).join(v) + v;
+            };
+            return [rule("╭", "┬", "╮"), line(rows[0], true), rule("├", "┼", "┤"), ...rows.slice(1).map((r) => line(r, false)), rule("╰", "┴", "╯")];
+        },
+    };
+    return skin;
+}
+import { inline } from "./markdown.js";
+const inlineCell = (s, skin) => inline(s, skin);

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

@@ -0,0 +1,30 @@
+export type Out = {
+    write(s: string): unknown;
+    columns?: number;
+    rows?: number;
+    isTTY?: boolean;
+};
+export declare class Screen {
+    out: Out;
+    private cursorRow;
+    private cursorCol;
+    private lastCols;
+    private lastWidths;
+    height: number;
+    alt: boolean;
+    constructor(out: Out);
+    get cols(): number;
+    get rows(): number;
+    /**
+     * One atomic frame: erase the old live region, print `committed` lines into scrollback, draw the new live region and park the cursor at `cursor`.
+     * Wrapped in synchronized-output markers so supporting terminals never show a half-drawn frame.
+     */
+    frame(committed: string[], live: string[], cursor?: {
+        row: number;
+        col: number;
+    }): void;
+    /** Remove the live region entirely (before exiting, or before handing the terminal to something else). */
+    clear(): void;
+    enterAlt(): void;
+    leaveAlt(): void;
+}

package/dist/cli/tui/screen.js

@@ -0,0 +1,62 @@
+// Inline terminal renderer: finished output goes into normal scrollback; a small "live region" (status, input box, overlays)
+// is redrawn in place at the bottom. Same model as Claude Code / Copilot CLI: no alternate screen, so native scrollback and copy/paste still work.
+import { cellWidth, clipAnsi } from "./text.js";
+export class Screen {
+    out;
+    cursorRow = 0; // where the cursor sits inside the live region (0 = its first line)
+    cursorCol = 0;
+    lastCols = 0;
+    lastWidths = [];
+    height = 0; // lines currently occupied by the live region
+    alt = false;
+    constructor(out) { this.out = out; }
+    get cols() { return Math.max(20, this.out.columns || 80); }
+    get rows() { return Math.max(6, this.out.rows || 24); }
+    /**
+     * One atomic frame: erase the old live region, print `committed` lines into scrollback, draw the new live region and park the cursor at `cursor`.
+     * Wrapped in synchronized-output markers so supporting terminals never show a half-drawn frame.
+     */
+    frame(committed, live, cursor) {
+        if (this.alt)
+            return;
+        const cols = this.cols, maxLive = this.rows - 1;
+        const lines = (live.length > maxLive ? live.slice(live.length - maxLive) : live).map((l) => clipAnsi(l, cols));
+        const shifted = live.length - lines.length; // rows dropped from the top when the region is taller than the terminal
+        let s = "\x1b[?2026h\x1b[?25l";
+        if (this.height > 0) {
+            let up = this.cursorRow;
+            if (this.lastCols && this.lastCols !== cols) { // the window was resized: terminals re-wrap old rows, so count how many rows the region really spans now
+                const rows = (w) => Math.max(1, Math.ceil(w / cols));
+                up = this.lastWidths.slice(0, this.cursorRow).reduce((n, w) => n + rows(w), 0) + Math.floor(this.cursorCol / cols);
+            }
+            s += (up > 0 ? `\x1b[${up}A` : "") + "\r\x1b[J";
+        }
+        for (const l of committed)
+            s += l + "\x1b[0m\r\n";
+        s += lines.join("\r\n");
+        let row = Math.max(0, lines.length - 1);
+        if (lines.length && cursor) {
+            const target = Math.max(0, Math.min(lines.length - 1, cursor.row - shifted));
+            if (row > target)
+                s += `\x1b[${row - target}A`;
+            s += "\r" + (cursor.col > 0 ? `\x1b[${Math.min(cursor.col, cols - 1)}C` : "");
+            row = target;
+        }
+        s += "\x1b[?25h\x1b[?2026l";
+        this.out.write(s);
+        this.cursorRow = row;
+        this.height = lines.length;
+        this.cursorCol = cursor ? Math.min(cursor.col, cols - 1) : cellWidth(lines.at(-1) ?? "");
+        this.lastCols = cols;
+        this.lastWidths = lines.map((l) => cellWidth(l));
+    }
+    /** Remove the live region entirely (before exiting, or before handing the terminal to something else). */
+    clear() {
+        if (this.height > 0)
+            this.out.write((this.cursorRow > 0 ? `\x1b[${this.cursorRow}A` : "") + "\r\x1b[J");
+        this.height = 0;
+        this.cursorRow = 0;
+    }
+    enterAlt() { this.alt = true; this.out.write("\x1b[?1049h\x1b[?25l"); }
+    leaveAlt() { this.alt = false; this.out.write("\x1b[?1049l\x1b[?25h"); }
+}

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

@@ -0,0 +1,77 @@
+import type { Message } from "../../src/index.ts";
+import type { Snapshots } from "../../src/index.ts";
+export type Turn = {
+    shell?: {
+        tree?: string;
+        cmds: string[];
+        irreversible: string[];
+    };
+    at: number;
+    text: string;
+    t: number; /** path -> content before this turn's first edit (null = file did not exist) */
+    snaps: Record<string, string | null>;
+};
+export type SessionData = {
+    /** set on a branch: the conversation it was forked from and the turn it was forked after */ parent?: {
+        id: string;
+        turn: number;
+    };
+    id: string;
+    created: string;
+    updated: string;
+    title: string;
+    cwd: string;
+    model: string;
+    messages: Message[];
+    turns: Turn[];
+    usage: {
+        prompt: number;
+        completion: number;
+        calls: number; /** prompt tokens of each request, newest last */
+        series?: number[]; /** prompt tokens served from the provider cache / output tokens spent reasoning */
+        cached?: number;
+        reasoning?: number;
+    };
+};
+export type SessionInfo = {
+    id: string;
+    title: string;
+    updated: string;
+    turns: number;
+    model: string;
+};
+export declare const newSession: (cwd: string, model: string) => SessionData;
+export declare class SessionStore {
+    dir: string;
+    constructor(cwd: string);
+    private file;
+    save(s: SessionData): void;
+    load(id: string): SessionData | undefined;
+    list(): SessionInfo[];
+    latest(): SessionData | undefined;
+    remove(id: string): void;
+}
+/** Record the pre-edit content for `path` the first time this turn touches it. */
+export declare function snapshot(turn: Turn | undefined, path: string, before: string | null | undefined): void;
+/**
+ * Roll the conversation back to just before turn `idx`: truncate messages, drop later turns, and restore every file those turns changed
+ * (the earliest snapshot wins). Never touches paths outside `cwd`.
+ */
+export declare function rewind(s: SessionData, cwd: string, idx: number): {
+    restored: string[];
+    removed: string[];
+    skipped: string[];
+};
+/** Like `rewind`, but first puts the working tree back to the earliest shell snapshot in the turns being undone (undoing what commands did), and reports what could not be undone. */
+export declare function rewindFull(s: SessionData, cwd: string, idx: number, snaps?: Snapshots): Promise<ReturnType<typeof rewind> & {
+    tree?: {
+        restored: string[];
+        removed: string[];
+    };
+    irreversible: string[];
+    treeError?: string;
+}>;
+/** A new conversation that continues from the end of turn `idx` (0-based) of `s`. The original is untouched. */
+export declare function forkSession(s: SessionData, idx: number): SessionData;
+/** Every conversation connected to `id` by branching (its ancestors, descendants and siblings), `id` itself included. */
+export declare function relatives(all: Pick<SessionData, "id" | "parent">[], id: string): string[];