atom-agent 1.0.0 → 1.1.0

package/dist/ui/diff.js

@@ -0,0 +1,422 @@
+// Mirrors Claude's StructuredDiffFallback threshold: when the share of
+// changed words in a paired line exceeds this, word highlighting would
+// be noise — render the whole line flat instead.
+export const CHANGE_THRESHOLD = 0.4;
+// Mirrors Claude's DiffDetailView guards.
+export const MAX_FILE_BYTES = 1_000_000;
+export const MAX_CHANGED_LINES = 400;
+export const DIFF_CONTEXT = 3;
+// Worst-case guards for the O(ND) Myers pass + O(w1*w2) word pass.
+const MAX_MYERS_LINES = 1000;
+const MAX_WORD_TOKENS = 200;
+function splitLines(s) {
+    if (s === "")
+        return [];
+    return s.replace(/\r\n?/g, "\n").split("\n");
+}
+function isBinary(s) {
+    return s.includes("\0");
+}
+// Tokenize into words + whitespace runs (whitespace kept so runs
+// rejoin byte-identical to the source line).
+function tokenize(line) {
+    const out = line.split(/(\s+)/g).filter((t) => t.length > 0);
+    return out.length > 0 ? out : [line];
+}
+function isWord(tok) {
+    return /\S/.test(tok);
+}
+// LCS table for small sequences (lines or words). Returns the matched
+// index pairs in order.
+function lcsPairs(a, b, eq) {
+    const n = a.length;
+    const m = b.length;
+    if (n === 0 || m === 0)
+        return [];
+    // Uint16 caps at 65535 — sequences here are small (words) or
+    // Myers-capped (lines); guard anyway.
+    const use32 = n > 6000 || m > 6000;
+    const w = m + 1;
+    const dp = use32 ? new Uint32Array((n + 1) * w) : new Uint16Array((n + 1) * w);
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            const v = eq(a[i - 1], b[j - 1])
+                ? dp[(i - 1) * w + (j - 1)] + 1
+                : Math.max(dp[(i - 1) * w + j], dp[i * w + (j - 1)]);
+            dp[i * w + j] = v > 65535 && !use32 ? 65535 : v;
+        }
+    }
+    const pairs = [];
+    let i = n;
+    let j = m;
+    while (i > 0 && j > 0) {
+        if (eq(a[i - 1], b[j - 1])) {
+            pairs.push([i - 1, j - 1]);
+            i -= 1;
+            j -= 1;
+        }
+        else if (dp[(i - 1) * w + j] >= dp[i * w + (j - 1)]) {
+            i -= 1;
+        }
+        else {
+            j -= 1;
+        }
+    }
+    pairs.reverse();
+    return pairs;
+}
+// Myers O(ND) line diff with a hard cell budget — falls back to a
+// single del/add block when the files are too big to trace exactly.
+// Returns ops over old lines (a) and new lines (b).
+function myersOps(a, b) {
+    const n = a.length;
+    const m = b.length;
+    if (n === 0)
+        return b.map((_, j) => ({ kind: "add", b: j }));
+    if (m === 0)
+        return a.map((_, i) => ({ kind: "del", a: i }));
+    if (n + m > MAX_MYERS_LINES) {
+        // Linear fallback: common prefix/suffix, middle is one block.
+        let pre = 0;
+        while (pre < n && pre < m && a[pre] === b[pre])
+            pre += 1;
+        let suf = 0;
+        while (suf < n - pre && suf < m - pre && a[n - 1 - suf] === b[m - 1 - suf])
+            suf += 1;
+        const ops = [];
+        for (let i = 0; i < pre; i++)
+            ops.push({ kind: "same", a: i, b: i });
+        for (let i = pre; i < n - suf; i++)
+            ops.push({ kind: "del", a: i });
+        for (let j = pre; j < m - suf; j++)
+            ops.push({ kind: "add", b: j });
+        for (let k = 0; k < suf; k++)
+            ops.push({ kind: "same", a: n - suf + k, b: m - suf + k });
+        return ops;
+    }
+    // Exact Myers when small: LCS pairs, then expand to ops.
+    const pairs = lcsPairs(a, b, (x, y) => x === y);
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    for (const [pi, pj] of pairs) {
+        while (i < pi)
+            ops.push({ kind: "del", a: i++ });
+        while (j < pj)
+            ops.push({ kind: "add", b: j++ });
+        ops.push({ kind: "same", a: i++, b: j++ });
+    }
+    while (i < n)
+        ops.push({ kind: "del", a: i++ });
+    while (j < m)
+        ops.push({ kind: "add", b: j++ });
+    return ops;
+}
+function flatRuns(text) {
+    return text === "" ? [] : [{ text, changed: false }];
+}
+// Word-level pairing for one del/add line pair. Returns runs for both
+// sides; falls back to flat (line-level) when the pair is too big or
+// too changed (CHANGE_THRESHOLD). Exported: the side-by-side builder
+// below and the cell renderer (ui/diff-view) share it.
+export function wordRuns(delText, addText) {
+    const dt = tokenize(delText);
+    const at = tokenize(addText);
+    if (dt.length > MAX_WORD_TOKENS || at.length > MAX_WORD_TOKENS) {
+        return { del: flatRuns(delText), add: flatRuns(addText) };
+    }
+    const pairs = lcsPairs(dt, at, (x, y) => x === y);
+    const delKeep = new Set(pairs.map(([i]) => i));
+    const addKeep = new Set(pairs.map(([, j]) => j));
+    const dw = dt.filter((t, i) => !delKeep.has(i) && isWord(t)).length;
+    const aw = at.filter((t, j) => !addKeep.has(j) && isWord(t)).length;
+    // Share of changed words over ALL tokens (whitespace included — it
+    // almost always matches, so a single changed word in a normal line
+    // stays well under the threshold while near-total rewrites exceed
+    // it and fall back to line-level).
+    const denom = Math.max(dt.length, at.length, 1);
+    if ((dw + aw) / denom > CHANGE_THRESHOLD) {
+        return { del: flatRuns(delText), add: flatRuns(addText) };
+    }
+    const build = (toks, keep) => {
+        const runs = [];
+        for (let k = 0; k < toks.length; k++) {
+            const changed = !keep.has(k) && isWord(toks[k]);
+            const prev = runs[runs.length - 1];
+            if (prev && prev.changed === changed)
+                prev.text += toks[k];
+            else
+                runs.push({ text: toks[k], changed });
+        }
+        return runs;
+    };
+    return { del: build(dt, delKeep), add: build(at, addKeep) };
+}
+export function computeDiff(oldText, newText) {
+    const empty = {
+        hunks: [],
+        adds: 0,
+        dels: 0,
+        truncated: false,
+        skipped: null,
+        isNewFile: oldText === null,
+    };
+    if (isBinary(newText) || (oldText !== null && isBinary(oldText))) {
+        return { ...empty, skipped: "binary file — diff skipped" };
+    }
+    if (newText.length > MAX_FILE_BYTES || (oldText !== null && oldText.length > MAX_FILE_BYTES)) {
+        return { ...empty, skipped: "file over 1MB — diff skipped" };
+    }
+    const oldLines = oldText === null ? [] : splitLines(oldText);
+    const newLines = splitLines(newText);
+    if (oldText !== null && oldText === newText)
+        return empty;
+    const ops = myersOps(oldLines, newLines);
+    const raw = ops.map((op) => op.kind === "same"
+        ? { kind: "same", text: oldLines[op.a] }
+        : op.kind === "del"
+            ? { kind: "del", text: oldLines[op.a] }
+            : { kind: "add", text: newLines[op.b] });
+    const changeIdx = raw.map((r, i) => (r.kind === "same" ? -1 : i)).filter((i) => i >= 0);
+    if (changeIdx.length === 0)
+        return empty;
+    const hunks = [];
+    let adds = 0;
+    let dels = 0;
+    let truncated = false;
+    let hunkStart = Math.max(0, changeIdx[0] - DIFF_CONTEXT);
+    let hunkEnd = Math.min(raw.length, changeIdx[0] + DIFF_CONTEXT + 1);
+    const flush = (s, e) => {
+        const slice = raw.slice(s, e);
+        // Old/new line numbers at hunk start.
+        let o = 0;
+        let nn = 0;
+        for (let k = 0; k < s; k++) {
+            if (raw[k].kind !== "add")
+                o += 1;
+            if (raw[k].kind !== "del")
+                nn += 1;
+        }
+        const oldStart = o + 1;
+        const newStart = nn + 1;
+        let oCount = 0;
+        let nCount = 0;
+        // Pair consecutive del/add runs for word highlighting.
+        const lines = [];
+        let k = 0;
+        while (k < slice.length) {
+            const r = slice[k];
+            if (r.kind === "same") {
+                lines.push({ kind: "context", text: r.text });
+                oCount += 1;
+                nCount += 1;
+                k += 1;
+                continue;
+            }
+            const delRun = [];
+            const addRun = [];
+            while (k < slice.length && slice[k].kind === "del") {
+                delRun.push(slice[k].text);
+                k += 1;
+            }
+            while (k < slice.length && slice[k].kind === "add") {
+                addRun.push(slice[k].text);
+                k += 1;
+            }
+            const paired = Math.min(delRun.length, addRun.length);
+            for (let p = 0; p < paired; p++) {
+                const { del, add } = wordRuns(delRun[p], addRun[p]);
+                lines.push({ kind: "del", text: delRun[p], runs: del });
+                lines.push({ kind: "add", text: addRun[p], runs: add });
+            }
+            for (let p = paired; p < delRun.length; p++) {
+                lines.push({ kind: "del", text: delRun[p], runs: flatRuns(delRun[p]) });
+            }
+            for (let p = paired; p < addRun.length; p++) {
+                lines.push({ kind: "add", text: addRun[p], runs: flatRuns(addRun[p]) });
+            }
+            dels += delRun.length;
+            adds += addRun.length;
+            oCount += delRun.length;
+            nCount += addRun.length;
+        }
+        hunks.push({ oldStart, oldLines: oCount, newStart, newLines: nCount, lines });
+    };
+    let changed = 0;
+    for (let c = 1; c < changeIdx.length; c++) {
+        const prev = changeIdx[c - 1];
+        const cur = changeIdx[c];
+        if (cur - prev <= DIFF_CONTEXT * 2 + 1) {
+            hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
+        }
+        else {
+            flush(hunkStart, hunkEnd);
+            changed = hunks.reduce((t, h) => t + h.lines.filter((l) => l.kind !== "context").length, 0);
+            if (changed >= MAX_CHANGED_LINES) {
+                truncated = true;
+                return { hunks, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
+            }
+            hunkStart = Math.max(0, cur - DIFF_CONTEXT);
+            hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
+        }
+    }
+    flush(hunkStart, hunkEnd);
+    changed = hunks.reduce((t, h) => t + h.lines.filter((l) => l.kind !== "context").length, 0);
+    if (changed > MAX_CHANGED_LINES) {
+        // Trim trailing hunks past the budget (keep the head — the user
+        // reviews top-down; the notice names the remainder).
+        let kept = 0;
+        const out = [];
+        for (const h of hunks) {
+            const n = h.lines.filter((l) => l.kind !== "context").length;
+            if (kept + n > MAX_CHANGED_LINES)
+                break;
+            out.push(h);
+            kept += n;
+        }
+        truncated = true;
+        return { hunks: out, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
+    }
+    return { hunks, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
+}
+export function computeSideBySide(oldText, newText) {
+    if (isBinary(newText) || (oldText !== null && isBinary(oldText))) {
+        return { kind: "binary" };
+    }
+    if (newText.length > MAX_FILE_BYTES || (oldText !== null && oldText.length > MAX_FILE_BYTES)) {
+        return { kind: "skipped", reason: "file over 1MB — diff skipped" };
+    }
+    if (oldText !== null && oldText === newText)
+        return { kind: "same" };
+    const oldLines = oldText === null ? [] : splitLines(oldText);
+    const newLines = splitLines(newText);
+    const ops = myersOps(oldLines, newLines);
+    // Numbered raw lines (1-based per side).
+    const raw = [];
+    let o = 0;
+    let nn = 0;
+    for (const op of ops) {
+        if (op.kind === "same") {
+            o += 1;
+            nn += 1;
+            raw.push({ kind: "same", text: oldLines[op.a], oldNo: o, newNo: nn });
+        }
+        else if (op.kind === "del") {
+            o += 1;
+            raw.push({ kind: "del", text: oldLines[op.a], oldNo: o, newNo: null });
+        }
+        else {
+            nn += 1;
+            raw.push({ kind: "add", text: newLines[op.b], oldNo: null, newNo: nn });
+        }
+    }
+    const changeIdx = raw.map((r, i) => (r.kind === "same" ? -1 : i)).filter((i) => i >= 0);
+    if (changeIdx.length === 0)
+        return { kind: "same" };
+    const rows = [];
+    let adds = 0;
+    let dels = 0;
+    let truncated = false;
+    const changedSoFar = () => dels + adds;
+    // Returns false when the change budget is exhausted (stop windowing).
+    const flushSlice = (s, e) => {
+        const slice = raw.slice(s, e);
+        let k = 0;
+        while (k < slice.length) {
+            const r = slice[k];
+            if (r.kind === "same") {
+                rows.push({ kind: "context", oldNo: r.oldNo, newNo: r.newNo, text: r.text });
+                k += 1;
+                continue;
+            }
+            const delRun = [];
+            const addRun = [];
+            while (k < slice.length && slice[k].kind === "del") {
+                delRun.push({ text: slice[k].text, no: slice[k].oldNo });
+                k += 1;
+            }
+            while (k < slice.length && slice[k].kind === "add") {
+                addRun.push({ text: slice[k].text, no: slice[k].newNo });
+                k += 1;
+            }
+            const paired = Math.min(delRun.length, addRun.length);
+            for (let p = 0; p < paired; p++) {
+                const { del, add } = wordRuns(delRun[p].text, addRun[p].text);
+                rows.push({
+                    kind: "change",
+                    oldNo: delRun[p].no,
+                    oldText: delRun[p].text,
+                    oldRuns: del,
+                    newNo: addRun[p].no,
+                    newText: addRun[p].text,
+                    newRuns: add,
+                });
+            }
+            for (let p = paired; p < delRun.length; p++) {
+                rows.push({
+                    kind: "change",
+                    oldNo: delRun[p].no,
+                    oldText: delRun[p].text,
+                    oldRuns: flatRuns(delRun[p].text),
+                    newNo: null,
+                    newText: null,
+                    newRuns: [],
+                });
+            }
+            for (let p = paired; p < addRun.length; p++) {
+                rows.push({
+                    kind: "change",
+                    oldNo: null,
+                    oldText: null,
+                    oldRuns: [],
+                    newNo: addRun[p].no,
+                    newText: addRun[p].text,
+                    newRuns: flatRuns(addRun[p].text),
+                });
+            }
+            dels += delRun.length;
+            adds += addRun.length;
+            if (changedSoFar() >= MAX_CHANGED_LINES) {
+                truncated = true;
+                return false;
+            }
+        }
+        return true;
+    };
+    let hunkStart = Math.max(0, changeIdx[0] - DIFF_CONTEXT);
+    let hunkEnd = Math.min(raw.length, changeIdx[0] + DIFF_CONTEXT + 1);
+    for (let c = 1; c < changeIdx.length; c++) {
+        const prev = changeIdx[c - 1];
+        const cur = changeIdx[c];
+        if (cur - prev <= DIFF_CONTEXT * 2 + 1) {
+            hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
+        }
+        else {
+            if (!flushSlice(hunkStart, hunkEnd)) {
+                return { kind: "diff", rows, adds, dels, truncated, isNewFile: oldText === null };
+            }
+            hunkStart = Math.max(0, cur - DIFF_CONTEXT);
+            hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
+        }
+    }
+    flushSlice(hunkStart, hunkEnd);
+    if (dels + adds > MAX_CHANGED_LINES) {
+        // Single-hunk overflow: the slice already pushed past the budget —
+        // trim trailing rows past 400 changes (keep the head; the notice
+        // names the remainder). Mirrors computeDiff's trailing-hunk trim.
+        let kept = 0;
+        let cut = rows.length;
+        for (let i = 0; i < rows.length; i++) {
+            if (rows[i].kind === "change") {
+                kept += 1;
+                if (kept > MAX_CHANGED_LINES) {
+                    cut = i;
+                    break;
+                }
+            }
+        }
+        rows.length = cut;
+        truncated = true;
+    }
+    return { kind: "diff", rows, adds, dels, truncated, isNewFile: oldText === null };
+}

package/dist/ui/highlight.js

@@ -0,0 +1,120 @@
+const C_KEYWORDS = new Set("break case catch class const continue debugger default delete do else enum export extends finally for function if implements import interface let new return static super switch this throw try typeof var void while with yield async await".split(" "));
+const PY_KEYWORDS = new Set("def class return if elif else for while in is not and or import from as try except finally with lambda pass break continue raise True False None async await".split(" "));
+const SH_KEYWORDS = new Set("if then else elif fi for while do done case esac function return exit echo local export readonly".split(" "));
+function keywordsFor(lang) {
+    if (lang === "c")
+        return C_KEYWORDS;
+    if (lang === "py")
+        return PY_KEYWORDS;
+    if (lang === "sh")
+        return SH_KEYWORDS;
+    return null; // "data": no keywords
+}
+function commentStyle(lang) {
+    if (lang === "c")
+        return "slash";
+    if (lang === "data")
+        return "hash";
+    return "hash"; // py + sh
+}
+// Master token pattern over the code part of a line: strings (with
+// escapes, incl. unterminated tails so streaming/odd lines still paint),
+// numbers, words, and single fallback chars.
+const TOKEN_RE = /'(?:[^'\\\n]|\\.)*(?:'|$)|"(?:[^"\\\n]|\\.)*(?:"|$)|`(?:[^`\\]|\\.)*(?:`|$)|[0-9][0-9_]*(?:\.[0-9_]+)?\b|[A-Za-z_$][A-Za-z0-9_$]*|\s+|./g;
+const NUMBER_RE = /^[0-9][0-9_]*(?:\.[0-9_]+)?\b$/;
+const WORD_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+// Split off a trailing line comment, honoring string spans: `//` inside
+// a string is code, and (for hash style) `#` inside a string is code.
+// Single-line `/* … */` pairs are treated as comments when both halves
+// sit on this line; an unterminated opener is left as code (multi-line
+// state is the documented non-goal).
+function splitComment(line, lang) {
+    const style = commentStyle(lang);
+    let inStr = null;
+    let escaped = false;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (inStr !== null) {
+            if (escaped)
+                escaped = false;
+            else if (c === "\\")
+                escaped = true;
+            else if (c === inStr)
+                inStr = null;
+            continue;
+        }
+        if (c === "'" || c === '"' || c === "`") {
+            inStr = c;
+            continue;
+        }
+        if (style === "slash" && c === "/" && line[i + 1] === "/") {
+            return { code: line.slice(0, i), comment: line.slice(i) };
+        }
+        if (style === "hash" && c === "#") {
+            // Shebang or comment to end of line.
+            return { code: line.slice(0, i), comment: line.slice(i) };
+        }
+    }
+    if (style === "slash") {
+        const open = line.indexOf("/*");
+        const close = open >= 0 ? line.indexOf("*/", open + 2) : -1;
+        if (open >= 0 && close > open) {
+            // Keep it simple: trailing block comment paints as comment; an
+            // embedded one splits code around it via the token pass below
+            // (rare — paint the whole tail as comment only when the opener
+            // starts after code we already keep plain).
+            return { code: line.slice(0, open), comment: line.slice(open) };
+        }
+    }
+    return { code: line, comment: "" };
+}
+function highlightCode(code, lang, base) {
+    const runs = [];
+    const keywords = keywordsFor(lang);
+    TOKEN_RE.lastIndex = 0;
+    let m;
+    while ((m = TOKEN_RE.exec(code)) !== null) {
+        const text = m[0];
+        const start = base + (m.index ?? 0);
+        let kind = "plain";
+        const first = text[0];
+        if (first === "'" || first === '"' || first === "`")
+            kind = "string";
+        else if (NUMBER_RE.test(text))
+            kind = "number";
+        else if (keywords !== null && WORD_RE.test(text) && keywords.has(text))
+            kind = "keyword";
+        runs.push({ text, kind, start, end: start + text.length });
+    }
+    return runs;
+}
+// Bounded highlight cache: diff hunks re-render on busy ticks and the
+// same lines repeat across hunks/turns — tokenize once per unique line.
+const HIGHLIGHT_CACHE_CAP = 2000;
+const highlightCache = new Map();
+export function highlightLine(line, lang) {
+    if (lang !== "c" && lang !== "py" && lang !== "sh" && lang !== "data") {
+        return line === "" ? [] : [{ text: line, kind: "plain", start: 0, end: line.length }];
+    }
+    const key = `${lang} ${line}`;
+    const hit = highlightCache.get(key);
+    if (hit)
+        return hit;
+    const { code, comment } = splitComment(line, lang);
+    const runs = highlightCode(code, lang, 0);
+    if (comment) {
+        runs.push({ text: comment, kind: "comment", start: code.length, end: line.length });
+    }
+    const out = runs.length > 0 ? runs : [];
+    highlightCache.set(key, out);
+    if (highlightCache.size > HIGHLIGHT_CACHE_CAP) {
+        const oldest = highlightCache.keys().next();
+        if (!oldest.done)
+            highlightCache.delete(oldest.value);
+    }
+    return out;
+}
+// Test seam: current cache size (eviction behavior).
+export function highlightCacheSize() {
+    return highlightCache.size;
+}

package/dist/ui/live-tail.js

@@ -3,7 +3,7 @@ import { Box, Text } from "ink";
 import { activityText } from "./activity.js";
 import { MarkdownStream } from "./markdown.js";
 import { theme } from "./theme.js";
-export function LiveTail({ isEmpty, sessionHint, draft, thinking, busy, held, toolHint, toolElapsedSecs, elapsedSecs }) {
+export function LiveTail({ isEmpty, sessionHint, draft, thinking, busy, held, toolHint, toolElapsedSecs, elapsedSecs, showThinking = true }) {
     // Held view (user scrolled up mid-turn): the growing draft/thinking blocks
     // are replaced by one static line so the frame stops gaining terminal
     // lines — the terminal stops yanking and scrollback stays readable. The
@@ -11,5 +11,5 @@ export function LiveTail({ isEmpty, sessionHint, draft, thinking, busy, held, to
     // status (tool hint, thinking tick) keeps updating in place: same line,
     // no growth, no yank.
     const freezeLive = held === true && busy;
-    return (_jsxs(Box, { flexDirection: "column", marginY: theme.spacing.liveTailMarginY, children: [isEmpty ? (_jsx(Text, { dimColor: true, children: "Say hi to Atom \u2014 or type / for commands, /provider to pick a provider + key, /model to switch models." })) : null, sessionHint && isEmpty ? (_jsx(Text, { dimColor: true, children: "(last session available \u2014 /resume to restore)" })) : null, freezeLive ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 turn running \u00B7 End to follow"] })) : null, !freezeLive && draft ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsxs(Text, { color: theme.color.assistant, bold: true, children: [theme.symbol.speakerAssistant, " "] }) }), _jsx(MarkdownStream, { text: draft })] })) : null, !freezeLive && thinking ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " ", thinking, _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBar })] })) : null, busy && toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workTool, " ", activityText(toolHint), toolElapsedSecs !== null && toolElapsedSecs >= 2 ? (_jsxs(_Fragment, { children: [" ", theme.symbol.separator, " ", toolElapsedSecs, "s"] })) : (theme.symbol.ellipsis)] })) : null, !freezeLive && busy && !draft && !thinking && !toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workThinking, " Thinking", theme.symbol.ellipsis, " ", theme.symbol.separator, " ", elapsedSecs, "s"] })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", marginY: theme.spacing.liveTailMarginY, children: [isEmpty ? (_jsx(Text, { dimColor: true, children: "Say hi to Atom \u2014 or type / for commands, /provider to pick a provider + key, /model to switch models." })) : null, sessionHint && isEmpty ? (_jsx(Text, { dimColor: true, children: "(last session available \u2014 /resume to restore)" })) : null, freezeLive ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 turn running \u00B7 End to follow"] })) : null, !freezeLive && draft ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsxs(Text, { color: theme.color.assistant, bold: true, children: [theme.symbol.speakerAssistant, " "] }) }), _jsx(MarkdownStream, { text: draft })] })) : null, !freezeLive && thinking && showThinking ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " ", thinking, _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBar })] })) : null, busy && toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workTool, " ", activityText(toolHint), toolElapsedSecs !== null && toolElapsedSecs >= 2 ? (_jsxs(_Fragment, { children: [" ", theme.symbol.separator, " ", toolElapsedSecs, "s"] })) : (theme.symbol.ellipsis)] })) : null, !freezeLive && busy && !draft && !thinking && !toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workThinking, " Thinking", theme.symbol.ellipsis, " ", theme.symbol.separator, " ", elapsedSecs, "s"] })) : null] }));
 }

package/dist/ui/modals.js

@@ -1,6 +1,16 @@
 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
@@ -14,7 +24,13 @@ export function approvalPreview(toolName, description) {
 export function approvalTitle(toolName) {
     return toolName.length > 0 ? toolName[0].toUpperCase() + toolName.slice(1) : toolName;
 }
-export function ApprovalBox({ toolName, description, selected }) {
+// 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.
@@ -23,8 +39,9 @@ export function ApprovalBox({ toolName, description, selected }) {
         { 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) }), 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 function QuestionBox({ question, options, allowCustom, askCustom, askSelIndex }) {
+    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

@@ -1,4 +1,10 @@
 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";
@@ -26,6 +32,8 @@ const PALETTE_CATEGORIES = {
     "/skill": "Skills",
     "/queue": "Flow",
     "/steer": "Flow",
+    "/autoscroll": "Flow",
+    "/thinking": "Flow",
     "/help": "Help",
     "/exit": "Help",
     "/quit": "Help",
@@ -39,7 +47,7 @@ export const PALETTE_HINTS = {
     "/exit": "Ctrl+C",
     "/quit": "Ctrl+C",
 };
-export function PalettePanel({ entries, index, filter }) {
+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);
@@ -59,4 +67,4 @@ export function PalettePanel({ entries, index, filter }) {
         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] }));
-}
+});