atom-agent 0.3.0 → 1.1.0

package/dist/ui/markdown.js

@@ -0,0 +1,525 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { theme } from "./theme.js";
+// Split `s` on inline-code spans first (code content is never formatted),
+// then links, then bold/italic/strikethrough inside the remaining text.
+export function parseInline(s) {
+    const out = [];
+    const parts = s.split(/(`[^`]*`)/g);
+    for (const part of parts) {
+        if (!part)
+            continue;
+        if (part.startsWith("`") && part.endsWith("`") && part.length >= 2) {
+            out.push({ kind: "code", text: part.slice(1, -1) });
+            continue;
+        }
+        out.push(...parseInlineRich(part));
+    }
+    return out;
+}
+function parseInlineRich(s) {
+    const out = [];
+    // Links: [text](url). Autolinks (bare https://…) paint as plain text.
+    const re = /\[([^\]]*)\]\(([^)\s]+)\)|(\*\*[^*]+?\*\*)|(__[^_]+?__)|(~~[^~\n]+?~~)|(\*[^*\n]+?\*)|(_[^_\n]+?_)/g;
+    let last = 0;
+    let m;
+    const pushText = (t) => {
+        if (t)
+            out.push({ kind: "text", text: t });
+    };
+    // Single-char markers must not fire intra-word (`my_var`, `2*3*4` stay
+    // literal — CommonMark flanking, simplified to word boundaries).
+    const isWord = (c) => c !== undefined && /[\w]/.test(c);
+    while ((m = re.exec(s)) !== null) {
+        const raw = m[0];
+        const single = raw.startsWith("~~") || (raw.startsWith("*") && !raw.startsWith("**")) || (raw.startsWith("_") && !raw.startsWith("__"));
+        if (single) {
+            const before = m.index > 0 ? s[m.index - 1] : undefined;
+            const after = m.index + raw.length < s.length ? s[m.index + raw.length] : undefined;
+            if (isWord(before) || isWord(after)) {
+                pushText(s.slice(last, m.index + raw.length));
+                last = m.index + raw.length;
+                continue;
+            }
+        }
+        pushText(s.slice(last, m.index));
+        last = m.index + raw.length;
+        if (m[1] !== undefined && m[2] !== undefined) {
+            out.push({ kind: "link", text: m[1], url: m[2] });
+        }
+        else {
+            const inner = raw.startsWith("**") || raw.startsWith("__")
+                ? raw.slice(2, -2)
+                : raw.slice(1, -1);
+            out.push({
+                kind: "text",
+                text: inner,
+                bold: (raw.startsWith("**") || raw.startsWith("__")) || undefined,
+                italic: (!raw.startsWith("**") && !raw.startsWith("__") && !raw.startsWith("~~")) || undefined,
+                strike: raw.startsWith("~~") || undefined,
+            });
+        }
+    }
+    pushText(s.slice(last));
+    // Coalesce adjacent plain runs (literal fallbacks split them) — fewer
+    // nodes, and plain text stays one contiguous run.
+    const merged = [];
+    for (const r of out) {
+        const prev = merged[merged.length - 1];
+        if (r.kind === "text" && !r.bold && !r.italic && !r.strike &&
+            prev?.kind === "text" && !prev.bold && !prev.italic && !prev.strike) {
+            prev.text += r.text;
+        }
+        else {
+            merged.push(r.kind === "text" ? { ...r } : r);
+        }
+    }
+    return merged;
+}
+function expandTabs(line) {
+    return line.replace(/\t/g, "  ");
+}
+// --- Tables (GFM, terminal-quiet) ---------------------------------------
+// Tables render where feasible: header + dim separator + left-aligned rows,
+// columns joined with `│`. Column widths come from cell content, capped so
+// one long cell (a path, URL, stack line) never blows out an 80-col
+// terminal; over-long cells truncate with `…`. No outer borders: nothing
+// extra lands on copy/paste beyond the cell text itself.
+export const TABLE_MAX_COL = 40;
+function splitTableRow(line) {
+    if (!line.includes("|"))
+        return null;
+    // Split on unescaped pipes; `\|` stays a literal pipe inside the cell.
+    const cells = [];
+    let cur = "";
+    for (let k = 0; k < line.length; k++) {
+        const c = line[k];
+        if (c === "\\" && line[k + 1] === "|") {
+            cur += "|";
+            k += 1;
+            continue;
+        }
+        if (c === "|") {
+            cells.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += c;
+    }
+    cells.push(cur);
+    // Drop the empty caps from leading/trailing pipes: `| a | b |` -> [a, b].
+    if (cells.length > 0 && cells[0].trim() === "")
+        cells.shift();
+    if (cells.length > 0 && cells[cells.length - 1].trim() === "")
+        cells.pop();
+    if (cells.length === 0)
+        return null;
+    return cells.map((c) => c.trim());
+}
+function isTableDelimiter(line) {
+    const cells = splitTableRow(line);
+    if (!cells || cells.length === 0)
+        return false;
+    return cells.every((c) => /^:?-{1,}:?$/.test(c));
+}
+// Rendered plain width of a cell: links read as `text (url)`, code as bare
+// text — the width must match what Ink actually paints.
+function cellPlain(runs) {
+    return runs
+        .map((r) => {
+        if (r.kind === "code")
+            return r.text;
+        if (r.kind === "link") {
+            return r.text && r.text !== r.url ? `${r.text} (${r.url})` : r.text || r.url;
+        }
+        return r.text;
+    })
+        .join("");
+}
+function truncatePlain(s, max) {
+    if ([...s].length <= max)
+        return s;
+    return [...s].slice(0, Math.max(0, max - 1)).join("") + theme.symbol.ellipsis;
+}
+// ATX closing hashes (`## Title ##`) are decoration, not content.
+function stripAtxClose(s) {
+    return s.replace(/\s+#+$/, "").trim();
+}
+// Line-based block parser. Unclosed fences run to end of input (streaming
+// cutoffs still render). Lists keep nesting as 2-space indents (capped —
+// terminal width is scarce, deep nesting is re-indented, not tree-rendered).
+// Tables parse only with a valid delimiter row; anything malformed stays a
+// plain paragraph so streaming partials never flash a broken grid.
+export function parseMarkdown(src) {
+    const lines = src.replace(/\r\n?/g, "\n").split("\n");
+    const blocks = [];
+    let para = [];
+    const flushPara = () => {
+        if (para.length === 0)
+            return;
+        blocks.push({ kind: "paragraph", runs: parseInline(para.join(" ")) });
+        para = [];
+    };
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const fence = line.match(/^(\s*)(`{3,}|~{3,})\s*(\S*)\s*$/);
+        if (fence) {
+            flushPara();
+            const marker = fence[2].startsWith("`") ? "`" : "~";
+            const fenceRe = marker === "`" ? /^\s*`{3,}\s*$/ : /^\s*~{3,}\s*$/;
+            const lang = fence[3] ?? "";
+            const body = [];
+            i += 1;
+            while (i < lines.length && !fenceRe.test(lines[i])) {
+                body.push(expandTabs(lines[i]));
+                i += 1;
+            }
+            i += 1; // consume closing fence (or run past end when unclosed)
+            blocks.push({ kind: "code", lang, lines: body });
+            continue;
+        }
+        const heading = line.match(/^(#{1,6})\s+(.*)$/);
+        if (heading) {
+            flushPara();
+            const text = stripAtxClose(heading[2] ?? "");
+            blocks.push({
+                kind: "heading",
+                level: heading[1].length,
+                runs: parseInline(text || " "),
+            });
+            i += 1;
+            continue;
+        }
+        // Setext headings: `Text\n===` (H1) and `Text\n---` (H2). A `---` with
+        // no pending paragraph stays a horizontal rule (spacing carries it).
+        if (/^=+\s*$/.test(line) && para.length > 0) {
+            blocks.push({ kind: "heading", level: 1, runs: parseInline(para.join(" ")) });
+            para = [];
+            i += 1;
+            continue;
+        }
+        if (/^-{3,}\s*$/.test(line) && para.length > 0 && !line.includes("|")) {
+            blocks.push({ kind: "heading", level: 2, runs: parseInline(para.join(" ")) });
+            para = [];
+            i += 1;
+            continue;
+        }
+        const hr = /^\s*([-*_]\s*){3,}$/.test(line);
+        if (hr) {
+            flushPara();
+            i += 1;
+            continue; // spacing around neighbors carries the separation; no chrome
+        }
+        // GFM table: header row + delimiter row, then 0+ body rows. A header
+        // without a delimiter is an ordinary paragraph (streaming partials).
+        if (line.includes("|") && i + 1 < lines.length && isTableDelimiter(lines[i + 1])) {
+            const headerCells = splitTableRow(line);
+            if (headerCells) {
+                flushPara();
+                const headers = headerCells.map((c) => parseInline(c));
+                const rows = [];
+                i += 2;
+                while (i < lines.length) {
+                    const rowLine = lines[i];
+                    if (!rowLine.includes("|") || /^\s*$/.test(rowLine))
+                        break;
+                    if (isTableDelimiter(rowLine))
+                        break;
+                    // A new block (fence/heading/quote/list) ends the table.
+                    if (/^(\s*)(`{3,}|~{3,})/.test(rowLine))
+                        break;
+                    if (/^(#{1,6})\s+/.test(rowLine))
+                        break;
+                    if (/^>\s?/.test(rowLine))
+                        break;
+                    if (/^(\s*)([-*+]|\d+[.)])\s+/.test(rowLine))
+                        break;
+                    const cells = splitTableRow(rowLine);
+                    if (!cells)
+                        break;
+                    while (cells.length < headerCells.length)
+                        cells.push("");
+                    rows.push(cells.slice(0, headerCells.length).map((c) => parseInline(c)));
+                    i += 1;
+                }
+                blocks.push({ kind: "table", headers, rows });
+                continue;
+            }
+        }
+        const quote = line.match(/^>\s?(.*)$/);
+        if (quote) {
+            flushPara();
+            const cited = [quote[1] ?? ""];
+            i += 1;
+            while (i < lines.length) {
+                const cont = lines[i].match(/^>\s?(.*)$/);
+                if (!cont)
+                    break;
+                cited.push(cont[1] ?? "");
+                i += 1;
+            }
+            blocks.push({ kind: "quote", runs: parseInline(cited.join(" ")) });
+            continue;
+        }
+        const item = line.match(/^(\s*)([-*+]|\d+[.)])\s+(.*)$/);
+        if (item) {
+            flushPara();
+            const items = [];
+            let raws = [];
+            const pushItem = () => {
+                const prev = items[items.length - 1];
+                if (!prev)
+                    return;
+                prev.runs = parseInline(raws.join(" "));
+                raws = [];
+            };
+            while (i < lines.length) {
+                const it = lines[i].match(/^(\s*)([-*+]|\d+[.)])\s+(.*)$/);
+                if (it) {
+                    if (items.length > 0)
+                        pushItem();
+                    const indentSpaces = expandTabs(it[1] ?? "").length;
+                    const indent = Math.min(Math.floor(indentSpaces / 2), 4);
+                    const ordered = /^\d/.test(it[2]);
+                    let content = it[3] ?? "";
+                    let marker = ordered ? `${it[2]}` : theme.symbol.bullet;
+                    // Task lists: `- [ ] todo` / `- [x] done` read as ballot boxes.
+                    const task = content.match(/^\[([ xX])\]\s+(.*)$/);
+                    if (!ordered && task) {
+                        marker = task[1].toLowerCase() === "x" ? `${theme.symbol.bullet} ☑` : `${theme.symbol.bullet} ☐`;
+                        content = task[2] ?? "";
+                    }
+                    items.push({ marker, indent, runs: [] });
+                    raws = [content];
+                    i += 1;
+                    continue;
+                }
+                // Indented continuation lines join the current item (multi-line
+                // list bodies); anything else ends the list.
+                if (items.length > 0 && /^(\s+)\S/.test(lines[i]) && !/^\s*$/.test(lines[i])) {
+                    raws.push(lines[i].trim());
+                    i += 1;
+                    continue;
+                }
+                break;
+            }
+            if (items.length > 0)
+                pushItem();
+            blocks.push({ kind: "list", items });
+            continue;
+        }
+        if (/^\s*$/.test(line)) {
+            flushPara();
+            i += 1;
+            continue;
+        }
+        para.push(line.trim());
+        i += 1;
+    }
+    flushPara();
+    return blocks;
+}
+// Bounded parse cache: Static items render once, but timer-tick re-renders,
+// /resume restores, and tests re-render the same turns — never re-parse.
+const PARSE_CACHE_CAP = 300;
+const parseCache = new Map();
+export function parseMarkdownCached(src) {
+    const hit = parseCache.get(src);
+    if (hit)
+        return hit;
+    const blocks = parseMarkdown(src);
+    parseCache.set(src, blocks);
+    if (parseCache.size > PARSE_CACHE_CAP) {
+        const oldest = parseCache.keys().next();
+        if (!oldest.done)
+            parseCache.delete(oldest.value);
+    }
+    return blocks;
+}
+function InlineRuns({ runs }) {
+    return (_jsx(_Fragment, { children: runs.map((r, k) => {
+            if (r.kind === "code") {
+                return (_jsx(Text, { color: theme.color.code, children: r.text }, k));
+            }
+            if (r.kind === "link") {
+                return (_jsxs(Text, { children: [_jsx(Text, { color: theme.color.link, underline: true, children: r.text || r.url }), r.text && r.text !== r.url ? _jsxs(Text, { dimColor: true, children: [" (", r.url, ")"] }) : null] }, k));
+            }
+            return (_jsx(Text, { bold: r.bold, italic: r.italic, strikethrough: r.strike, children: r.text }, k));
+        }) }));
+}
+// Tables paint as plain aligned columns: bold header, one dim separator
+// row, left-aligned body. No outer borders or boxes (copy/paste stays the
+// cell text). Widths derive from truncated cell plains so a single long
+// cell never pushes the grid off-screen; Ink wraps the row if the terminal
+// is narrower still, preserving content over grid shape.
+function TableView({ block, gap, }) {
+    const cols = block.headers.length;
+    const headPlains = block.headers.map((h) => truncatePlain(cellPlain(h), TABLE_MAX_COL));
+    const bodyPlains = block.rows.map((r) => Array.from({ length: cols }, (_, c) => truncatePlain(cellPlain(r[c] ?? []), TABLE_MAX_COL)));
+    const widths = Array.from({ length: cols }, (_, c) => {
+        let w = [...(headPlains[c] ?? "")].length;
+        for (const row of bodyPlains)
+            w = Math.max(w, [...(row[c] ?? "")].length);
+        return Math.max(w, 1);
+    });
+    const colSep = ` ${theme.symbol.quoteBar} `;
+    const joint = "┼";
+    const ruleRow = widths.map((w) => theme.symbol.rule.repeat(w)).join(`${theme.symbol.rule}${joint}${theme.symbol.rule}`);
+    // Long cells render as truncated plain text (shape over formatting);
+    // short cells keep their runs (bold/code/links) plus space padding.
+    const renderCell = (runs, plain, width, boldCell) => {
+        const full = cellPlain(runs);
+        if (full !== plain) {
+            return _jsx(Text, { bold: boldCell, children: plain + " ".repeat(Math.max(0, width - [...plain].length)) });
+        }
+        return (_jsxs(Text, { bold: boldCell, children: [_jsx(InlineRuns, { runs: runs }), width > [...plain].length ? " ".repeat(width - [...plain].length) : null] }));
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginTop: gap ? 1 : 0, children: [_jsx(Text, { children: block.headers.map((h, c) => (_jsxs(Text, { children: [c > 0 ? colSep : null, renderCell(h, headPlains[c] ?? "", widths[c] ?? 1, true)] }, c))) }), _jsx(Text, { dimColor: true, children: ruleRow }), block.rows.map((r, k) => (_jsx(Text, { children: Array.from({ length: cols }, (_, c) => (_jsxs(Text, { children: [c > 0 ? colSep : null, renderCell(r[c] ?? [], bodyPlains[k]?.[c] ?? "", widths[c] ?? 1, false)] }, c))) }, k)))] }));
+}
+function BlockView({ block, gap }) {
+    const top = gap ? 1 : 0;
+    switch (block.kind) {
+        case "heading":
+            return (_jsx(Box, { marginTop: top, children: _jsx(Text, { bold: true, children: _jsx(InlineRuns, { runs: block.runs }) }) }));
+        case "list":
+            return (_jsx(Box, { flexDirection: "column", marginTop: top, children: block.items.map((it, k) => (_jsxs(Text, { children: ["  ".repeat(it.indent), it.marker, " ", _jsx(InlineRuns, { runs: it.runs })] }, k))) }));
+        case "table":
+            return _jsx(TableView, { block: block, gap: top > 0 });
+        case "quote":
+            return (_jsx(Box, { marginTop: top, children: _jsxs(Text, { dimColor: true, children: [theme.symbol.quoteBar, " ", _jsx(InlineRuns, { runs: block.runs })] }) }));
+        case "code":
+            return (_jsxs(Box, { flexDirection: "column", marginTop: top, children: [block.lang ? _jsx(Text, { dimColor: true, children: block.lang }) : null, block.lines.map((ln, k) => (_jsx(Text, { children: ln.length > 0 ? `${theme.spacing.codeIndent}${ln}` : " " }, k)))] }));
+        case "paragraph":
+            return (_jsx(Box, { marginTop: top, children: _jsx(Text, { children: _jsx(InlineRuns, { runs: block.runs }) }) }));
+    }
+}
+// --- Streaming variant --------------------------------------------------
+// Mid-stream partials end with unclosed markers (`**bold`, `*italic`,
+// `~~strike`, `` `code ``, `[text](url`). Committed rendering would leak
+// the raw markers, so the streaming pass auto-closes a trailing opener
+// before parsing — the paint then matches the final shape instead of
+// flashing broken markdown. Closers apply only with markdown-flanking
+// (opener glued to content, not `a ** b`; intra-word `my_var`/`2*3*4`
+// stay literal), so literal asterisks never misfire mid-stream. Fences
+// (```/~~~) need no help: the block parser already runs unclosed fences
+// to end of input. Tables need no help either: a header without its
+// delimiter row parses as plain text until the delimiter streams in.
+function unclosedMarker(s, m) {
+    let count = 0;
+    let idx = -1;
+    for (;;) {
+        idx = s.indexOf(m, idx + 1);
+        if (idx === -1)
+            break;
+        count += 1;
+    }
+    if (count % 2 === 0)
+        return false;
+    const last = s.lastIndexOf(m);
+    const after = s[last + m.length];
+    const before = last > 0 ? s[last - 1] : undefined;
+    if (after === undefined || /\s/.test(after))
+        return false;
+    if (before !== undefined && /[\w]/.test(before) && /[\w]/.test(after))
+        return false;
+    return true;
+}
+// Single `*`/`_` closers ignore characters already paired as `**`/`__`
+// doubles, then apply the same flanking + intra-word guards as the parser.
+function unclosedSingle(s, ch, double) {
+    const withoutDoubles = s.split(double).join("");
+    let count = 0;
+    for (const c of withoutDoubles)
+        if (c === ch)
+            count += 1;
+    if (count % 2 === 0)
+        return false;
+    const last = withoutDoubles.lastIndexOf(ch);
+    const after = withoutDoubles[last + 1];
+    const before = last > 0 ? withoutDoubles[last - 1] : undefined;
+    if (after === undefined || /\s/.test(after))
+        return false;
+    // The appended closer lands at end-of-string (non-word), so the
+    // committed full match is literal only when the opener sits intra-word
+    // (`my_var`) — matching the parser's own single-marker guard.
+    if (before !== undefined && /[\w]/.test(before))
+        return false;
+    return true;
+}
+export function closeStreamingMarkers(s) {
+    // Code spans protect their contents from marker counting.
+    const fenceless = s.replace(/^(\s*)(`{3,}|~{3,}).*$/gm, "");
+    const stripped = fenceless.replace(/`[^`\n]*`/g, "");
+    let out = s;
+    if (unclosedMarker(stripped, "**"))
+        out += "**";
+    if (unclosedMarker(stripped, "__"))
+        out += "__";
+    if (unclosedMarker(stripped, "~~"))
+        out += "~~";
+    if (unclosedSingle(stripped, "*", "**"))
+        out += "*";
+    if (unclosedSingle(stripped, "_", "__"))
+        out += "_";
+    const ticks = stripped.split("").filter((c) => c === "`").length;
+    if (ticks % 2 === 1) {
+        const lastTick = stripped.lastIndexOf("`");
+        const after = stripped[lastTick + 1];
+        if (after !== undefined && !/\s/.test(after))
+            out += "`";
+    }
+    // Unclosed link destination: `[text](https://…` streams char-by-char;
+    // closing it renders the link shape instead of flashing raw brackets.
+    if (/\[[^\]\n]*\]\([^)\s]*$/.test(stripped))
+        out += ")";
+    return out;
+}
+// Streaming answer draft: same grammar as the committed body, but parsed
+// fresh per paint (partials churn — caching them would evict committed
+// turns' entries for zero hits) with transient markers closed and the
+// block cursor riding the final run. Converges to MarkdownText byte-for-
+// byte once the stream completes (cursor aside), so commit never visually
+// jumps.
+export function MarkdownStream({ text }) {
+    const blocks = parseMarkdown(closeStreamingMarkers(text) + theme.symbol.cursorBar);
+    return (_jsx(Box, { flexDirection: "column", children: blocks.map((b, k) => (_jsx(BlockView, { block: b, gap: k > 0 }, k))) }));
+}
+// Assistant body: full markdown when the text parses into structure,
+// byte-identical plain text otherwise (a single paragraph paints its runs;
+// with no formatting syntax those runs are the input verbatim).
+export function MarkdownText({ text }) {
+    const blocks = parseMarkdownCached(text);
+    return (_jsx(Box, { flexDirection: "column", children: blocks.map((b, k) => (_jsx(BlockView, { block: b, gap: k > 0 }, k))) }));
+}
+// Compact tool/activity line. The call row keeps its loop-produced text
+// byte-identical (`⚙ name target` is pinned by tests + help), and state
+// reads from shape, not decoration:
+// - success: dim call row, plus a `· Ns` suffix when the TUI measured a
+//   slow run (TOOL_SLOW_MS threshold — fast tools stay one clean line).
+// - failed: the red `↳ detail` row the loop commits (error flag forces red
+//   on any shape, so unknown future shapes still read as failures).
+// - warning (`⚠ `): warning color — the one hue escalation, marking "needs
+//   attention" without a box.
+// - denied (`⊘ `), retry (`↻ `), cancel notices, boundaries, and multi-line
+//   outputs (todo checklists): full fidelity, dim, untouched.
+// Results are deliberately NOT echoed on success (the model owns them, not
+// the transcript — pinned by plan-mode tests); large outputs never dump.
+// True folding needs interactive history (Static items freeze on commit);
+// this component is that chunk's seam.
+export const TOOL_SLOW_MS = 2000;
+export function ToolLine({ content, error, ms }) {
+    if (error) {
+        return _jsx(Text, { color: theme.color.toolError, children: content });
+    }
+    if (content.startsWith("⚠ ")) {
+        return _jsx(Text, { color: theme.color.warning, children: content });
+    }
+    if (content.startsWith(`${theme.symbol.toolMark} `) &&
+        !content.includes("\n") &&
+        ms !== undefined &&
+        ms >= TOOL_SLOW_MS) {
+        return (_jsxs(Text, { color: theme.color.tool, dimColor: true, children: [content, " ", theme.symbol.separator, " ", Math.round(ms / 1000), "s"] }));
+    }
+    return (_jsx(Text, { color: theme.color.tool, dimColor: true, children: content }));
+}

package/dist/ui/modals.js

@@ -0,0 +1,47 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+// Modal leaves: the tool-approval and ask_question dialogs. Prop-driven.
+// All paint comes from ui/theme tokens. The approval tool-call description
+// arrives pre-formatted (describeToolCall stays in App) so this module
+// couples to no tool internals — the approval-redesign chunk owns it.
+import React from "react";
+import { Box, Text } from "ink";
+import { SideBySideDiffView } from "./side-by-side.js";
+import { theme } from "./theme.js";
+// Max diff body lines inside the approval modal (hunk headers excluded;
+// the trailer names the remainder). Keeps the modal scannable while the
+// 1s busy tick repaints around it.
+export const APPROVAL_DIFF_MAX_LINES = 40;
+export const APPROVAL_OPTIONS = ["once", "always", "trustAll", "no"];
+// Command/file preview: the audit description minus its `⚙ name` prefix
+// (the tool name already headlines above). Falls back to the full text
+// when the shape is unexpected — never invents content.
+export function approvalPreview(toolName, description) {
+    const prefix = `⚙ ${toolName} `;
+    if (description.startsWith(prefix))
+        return description.slice(prefix.length);
+    return description;
+}
+export function approvalTitle(toolName) {
+    return toolName.length > 0 ? toolName[0].toUpperCase() + toolName.slice(1) : toolName;
+}
+// Render-count probes for the flicker tests: the 1s busy tick and unrelated
+// parent churn must skip both modals (only changed props repaint — nav
+// selection still paints exactly once per keypress).
+export const approvalRenderProbe = { count: 0 };
+export const questionRenderProbe = { count: 0 };
+export const ApprovalBox = React.memo(function ApprovalBox({ toolName, description, selected, diff }) {
+    approvalRenderProbe.count += 1;
+    const rows = [
+        // Labels keep the historical [y]/[a]/[t]/[n] shortcuts (pinned by tests
+        // + muscle memory): arrows are additive, shortcuts never move.
+        { label: "[y]es once", option: "once" },
+        { label: `[a]lways allow ${toolName} this session`, option: "always" },
+        { label: "[t]rust all write/edit/bash this session", option: "trustAll" },
+        { label: "[n]o — deny this call", option: "no" },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.approval, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { bold: true, color: theme.color.warning, children: [theme.symbol.warningMark, " Atom permission \u2014 allow this tool?"] }), _jsx(Text, { bold: true, children: approvalTitle(toolName) }), _jsx(Text, { color: theme.color.code, children: approvalPreview(toolName, description) }), diff ? _jsx(SideBySideDiffView, { oldText: diff.oldText, newText: diff.newText, lang: diff.lang, maxRows: APPROVAL_DIFF_MAX_LINES }) : null, rows.map((r, i) => (_jsxs(Text, { color: i === selected ? theme.color.selection : undefined, children: [i === selected ? `${theme.symbol.select} ` : theme.spacing.rowIndent, r.label] }, r.option))), _jsx(Text, { dimColor: true, children: "\u2191/\u2193 + Enter selects \u00B7 y/a/t/n shortcuts \u00B7 Esc denies" })] }));
+});
+export const QuestionBox = React.memo(function QuestionBox({ question, options, allowCustom, askCustom, askSelIndex }) {
+    questionRenderProbe.count += 1;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.question, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { bold: true, children: ["Atom question \u2014 ", question] }), options.map((o, i) => (_jsxs(Text, { color: i === askSelIndex ? theme.color.questionSelection : undefined, children: [i === askSelIndex ? `${theme.symbol.select} ` : theme.spacing.rowIndent, o] }, `${o}-${i}`))), allowCustom ? (_jsxs(Text, { dimColor: true, children: ["Type a custom answer + Enter to send it", askCustom ? `: ${askCustom}` : "", " \u00B7 \u2191/\u2193 + Enter picks \u00B7 Esc cancels"] })) : (_jsx(Text, { dimColor: true, children: "\u2191/\u2193 + Enter to pick \u00B7 Esc cancels" }))] }));
+});

package/dist/ui/palette.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Command-palette panel (Ctrl+P): grouped, searchable, keyboard-driven.
+// Owns its display types (categories, hints); App builds the entries from
+// the SLASH_COMMANDS registry (single command system) and owns the run
+// gating. Windowed like every other popup; headers render for groups
+// present in the window (plus the open group when sliced mid-way).
+import React from "react";
+import { Box, Text } from "ink";
+import { PickerMoreAbove, PickerMoreBelow, pickerWindow } from "./pickers.js";
+import { theme } from "./theme.js";
+export const PALETTE_WINDOW = 12;
+export const PALETTE_CATEGORY_ORDER = ["Model", "Session", "Tools", "Skills", "Flow", "Help"];
+const PALETTE_CATEGORIES = {
+    "/model": "Model",
+    "/provider": "Model",
+    "/effort": "Model",
+    "/compact": "Session",
+    "/clear": "Session",
+    "/new": "Session",
+    "/resume": "Session",
+    "/rewind": "Session",
+    "/context": "Session",
+    "/telemetry": "Session",
+    "/dashboard": "Session",
+    "/tools": "Tools",
+    "/mode": "Tools",
+    "/trust": "Tools",
+    "/allow": "Tools",
+    "/deny": "Tools",
+    "/rules": "Tools",
+    "/skills": "Skills",
+    "/skill": "Skills",
+    "/queue": "Flow",
+    "/steer": "Flow",
+    "/autoscroll": "Flow",
+    "/thinking": "Flow",
+    "/help": "Help",
+    "/exit": "Help",
+    "/quit": "Help",
+};
+export function paletteCategory(name) {
+    return PALETTE_CATEGORIES[name] ?? "Help";
+}
+// Real key bindings only — shown as row hints, never invented.
+// (Mode switching lives on Tab alone now, so no command carries it.)
+export const PALETTE_HINTS = {
+    "/exit": "Ctrl+C",
+    "/quit": "Ctrl+C",
+};
+export const PalettePanel = React.memo(function PalettePanel({ entries, index, filter }) {
+    const hi = entries.length === 0 ? 0 : Math.max(0, Math.min(index, entries.length - 1));
+    const win = pickerWindow(entries.length, hi, PALETTE_WINDOW);
+    const slice = entries.slice(win.start, win.end);
+    const rows = [];
+    let lastCat = null;
+    if (slice.length > 0 && win.start > 0) {
+        // Sliced mid-group: name the open group so rows never float headerless.
+        lastCat = slice[0].category;
+        rows.push(_jsx(Text, { dimColor: true, children: lastCat }, `cat-${lastCat}`));
+    }
+    slice.forEach((e, k) => {
+        const i = win.start + k;
+        if (e.category !== lastCat) {
+            lastCat = e.category;
+            rows.push(_jsx(Text, { dimColor: true, children: e.category }, `cat-${e.category}-${i}`));
+        }
+        rows.push(_jsxs(Text, { color: i === hi ? theme.color.menuSelection : undefined, children: [i === hi ? `${theme.symbol.select} ` : theme.spacing.rowIndent, e.name, e.description ? ` ${theme.symbol.descSeparator} ${e.description}` : "", e.hint ? _jsxs(Text, { dimColor: true, children: [" \u00B7 ", e.hint] }) : null] }, `${e.name}-${i}`));
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.menu, paddingX: theme.spacing.pickerPadX, children: [_jsx(Text, { bold: true, children: "Search commands \u2014 type to filter (\u2191/\u2193 + Enter to run, Esc closes):" }), _jsxs(Text, { children: [_jsxs(Text, { color: theme.color.inputPrompt, bold: true, children: [theme.symbol.inputPrompt, " "] }), filter, _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBlock })] }), _jsx(PickerMoreAbove, { count: win.start }), rows, _jsx(PickerMoreBelow, { count: entries.length - win.end }), entries.length === 0 ? _jsx(Text, { dimColor: true, children: "No commands match \u2014 backspace to widen." }) : null] }));
+});