atom-agent 1.0.0 → 1.2.0

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-host.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Live-tail host: the subscription boundary between App and the streaming UI.
+//
+// App renders this host with LOW-frequency props only (busy/held/empty flags,
+// elapsed seconds, tool hint). The HIGH-frequency streaming text (draft +
+// thinking, up to ~15 paints/sec via DRAFT_THROTTLE_MS) flows through the
+// StreamStore instead: this host subscribes via useSyncExternalStore, so a
+// token paint re-renders this host + LiveTail alone — App's body,
+// reconciliation of every other leaf, and their prop assembly never run.
+//
+// LiveTail itself is untouched (same props API, same paint), so all existing
+// LiveTail tests keep passing; only the delivery path changed.
+import React, { useSyncExternalStore } from "react";
+import { LiveTail } from "./live-tail.js";
+export const LiveTailHost = React.memo(function LiveTailHost({ store, isEmpty, sessionHint, emptySessionTitle, busy, held, toolHint, toolElapsedSecs, elapsedSecs, showThinking, }) {
+    const snap = useSyncExternalStore(store.subscribe, store.getSnapshot);
+    return (_jsx(LiveTail, { isEmpty: isEmpty, sessionHint: sessionHint, emptySessionTitle: emptySessionTitle, draft: snap.draft, thinking: snap.thinking, busy: busy, held: held, toolHint: toolHint, toolElapsedSecs: toolElapsedSecs, elapsedSecs: elapsedSecs, showThinking: showThinking }));
+});

package/dist/ui/live-tail.js

@@ -1,9 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Live-tail leaf: the dynamic zone between the committed <Static>
+// transcript and the modals — empty-state hints, the streaming answer
+// draft, the transient thinking block, and the tool-call hint. Re-renders
+// every tick by design (unlike TranscriptView/InputBox); all paint comes
+// from ui/theme tokens. The streaming-markdown chunk owns this file next.
+import React from "react";
 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 const LiveTail = React.memo(function LiveTail({ isEmpty, sessionHint, emptySessionTitle, 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 +17,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, isEmpty && emptySessionTitle && emptySessionTitle.trim() ? (_jsxs(Text, { dimColor: true, children: ["Session: ", emptySessionTitle.trim()] })) : 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/markdown.js

@@ -1,4 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Zero-dependency markdown renderer for assistant transcript turns.
+//
+// Terminal-native hierarchy, no boxes: headings are bold, lists use one
+// consistent bullet (nesting as 2-space indents, task lists as ballot
+// boxes), code blocks are indentation + a dim language label (```/~~~
+// fences, unclosed runs to end of input), tables are aligned columns with
+// one dim separator row, links read as `text (url)`. Soft line breaks join
+// (true markdown); blank lines separate paragraphs. Raw fences/bold-markers
+// never leak: when the model emits plain text, it paints back byte-identical.
+// Long code lines are never pre-wrapped or truncated — Ink wraps them and
+// the source line stays intact for copy/paste; long table cells truncate
+// with `…` so one cell never blows out the grid.
+//
+// Performance: parsed blocks are cached per exact input (bounded FIFO), so
+// re-renders and long sessions never re-parse. Parsing is linear in input
+// size; rendering stays one <Text> per run (no per-character nodes).
+import React from "react";
 import { Box, Text } from "ink";
 import { theme } from "./theme.js";
 // Split `s` on inline-code spans first (code content is never formatted),
@@ -481,10 +498,17 @@ export function closeStreamingMarkers(s) {
 // 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 }) {
+//
+// Memoized on `text` — the ONLY parse input (TABLE_MAX_COL is a fixed
+// const, wrapping is Ink's job, the cursor glyph is a module const). A 1s
+// busy tick re-renders the parent with identical text and must NOT reparse:
+// same text bails here, changed text re-parses (one linear pass).
+export const streamParseProbe = { count: 0 };
+export const MarkdownStream = React.memo(function MarkdownStream({ text }) {
+    streamParseProbe.count += 1;
     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).

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";
@@ -12,6 +18,8 @@ const PALETTE_CATEGORIES = {
     "/clear": "Session",
     "/new": "Session",
     "/resume": "Session",
+    "/rename": "Session",
+    "/session": "Session",
     "/rewind": "Session",
     "/context": "Session",
     "/telemetry": "Session",
@@ -26,6 +34,8 @@ const PALETTE_CATEGORIES = {
     "/skill": "Skills",
     "/queue": "Flow",
     "/steer": "Flow",
+    "/autoscroll": "Flow",
+    "/thinking": "Flow",
     "/help": "Help",
     "/exit": "Help",
     "/quit": "Help",
@@ -39,7 +49,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 +69,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] }));
-}
+});

package/dist/ui/side-by-side.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Side-by-side diff view for write/edit results: BEFORE pane (left) vs
+// AFTER pane (right), aligned rows, preserved line numbers.
+//
+// Requirements it answers (presentation only — data comes from the
+// existing approve-time preview / commit slot, tool behavior untouched):
+// - left = original, right = result; additions right, removals left,
+//   context on both sides; paired changes share ONE row so corresponding
+//   lines align; changed regions pop via the existing word-background +
+//   add/del line-number treatment; syntax colors reused per cell.
+// - hunks only (configurable context in the engine) — never whole files.
+// - width-aware: panes split the measured terminal (local useStdout, same
+//   pattern as StatusBarHost); long lines truncate per pane with …
+//   (code-point safe); below NARROW_COLUMNS the view degrades to the
+//   stacked unified DiffView instead of destroying the layout.
+// - computed once per mount (useMemo, keyed on inputs + pane width) and
+//   capped (maxRows + trailer) — never recomputed per tick, never floods.
+// All paint comes from ui/theme tokens.
+import React from "react";
+import { Box, Text } from "ink";
+import { useStdout } from "ink";
+import { computeSideBySide, wordRuns } from "./diff.js";
+import { DiffView, LineBody } from "./diff-view.js";
+import { theme } from "./theme.js";
+// Below this width two panes cannot breathe — stack unified instead.
+export const SBS_NARROW_COLUMNS = 70;
+// Committed-transcript cap (rows, context + change): the scrollback shows
+// the reviewable head; the file on disk is the whole truth. The engine
+// still truncates past 400 changed lines with its own notice.
+export const TRANSCRIPT_DIFF_MAX_LINES = 120;
+function truncateTo(s, width) {
+    const chars = [...s];
+    if (chars.length <= width)
+        return s;
+    if (width < 4)
+        return "";
+    return chars.slice(0, width - 1).join("") + theme.symbol.ellipsis;
+}
+// Fit engine rows to a pane content width: truncate cell texts (with …)
+// and re-derive word runs on the truncated pair so offsets always tile
+// the displayed text. Runs once per mount/width — never per tick.
+function fitRows(rows, contentW) {
+    return rows.map((r) => {
+        if (r.kind === "context") {
+            return {
+                kind: "context",
+                left: { no: r.oldNo, text: truncateTo(r.text, contentW) },
+                right: { no: r.newNo, text: truncateTo(r.text, contentW) },
+            };
+        }
+        const tOld = r.oldText !== null ? truncateTo(r.oldText, contentW) : null;
+        const tNew = r.newText !== null ? truncateTo(r.newText, contentW) : null;
+        let oldRuns = [];
+        let newRuns = [];
+        if (tOld !== null && tNew !== null) {
+            const w = wordRuns(tOld, tNew);
+            oldRuns = w.del;
+            newRuns = w.add;
+        }
+        else if (tOld !== null) {
+            oldRuns = tOld === "" ? [] : [{ text: tOld, changed: false }];
+        }
+        else if (tNew !== null) {
+            newRuns = tNew === "" ? [] : [{ text: tNew, changed: false }];
+        }
+        const changed = oldRuns.some((x) => x.changed) ||
+            newRuns.some((x) => x.changed) ||
+            (r.oldText === null) !== (r.newText === null);
+        return {
+            kind: "change",
+            changed,
+            left: tOld !== null ? { no: r.oldNo, text: tOld, runs: oldRuns } : null,
+            right: tNew !== null ? { no: r.newNo, text: tNew, runs: newRuns } : null,
+        };
+    });
+}
+function padEnd(s, width) {
+    const len = [...s].length;
+    if (len >= width)
+        return s;
+    return s + " ".repeat(width - len);
+}
+function SideBySideInner({ oldText, newText, lang = null, maxRows = Infinity, columns, }) {
+    let stdoutCols;
+    try {
+        stdoutCols = useStdout()?.stdout?.columns;
+    }
+    catch {
+        stdoutCols = undefined;
+    }
+    const totalW = columns ?? stdoutCols ?? 100;
+    const sbs = React.useMemo(() => computeSideBySide(oldText, newText), [oldText, newText]);
+    if (sbs.kind === "same") {
+        return _jsx(Text, { dimColor: true, children: "(no changes \u2014 file unchanged)" });
+    }
+    if (sbs.kind === "binary") {
+        return _jsx(Text, { dimColor: true, children: "binary file changed" });
+    }
+    if (sbs.kind === "skipped") {
+        return _jsx(Text, { dimColor: true, children: sbs.reason });
+    }
+    // Graceful narrow-terminal degrade: stacked unified keeps every char
+    // instead of crushing two panes into unreadable slivers.
+    if (totalW < SBS_NARROW_COLUMNS) {
+        return _jsx(DiffView, { oldText: oldText, newText: newText, lang: lang, maxLines: maxRows });
+    }
+    const sep = ` ${theme.symbol.bar} `;
+    const paneW = Math.max(20, Math.floor((totalW - sep.length) / 2));
+    let maxNo = 0;
+    for (const r of sbs.rows) {
+        if (r.kind === "context")
+            maxNo = Math.max(maxNo, r.oldNo, r.newNo);
+        else {
+            if (r.oldNo !== null)
+                maxNo = Math.max(maxNo, r.oldNo);
+            if (r.newNo !== null)
+                maxNo = Math.max(maxNo, r.newNo);
+        }
+    }
+    const numW = String(Math.max(maxNo, 1)).length;
+    const contentW = Math.max(8, paneW - numW - 1);
+    const view = React.useMemo(() => fitRows(sbs.rows, contentW), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [sbs, contentW]);
+    const shown = view.slice(0, maxRows);
+    const overflow = Math.max(0, view.length - shown.length);
+    const renderCell = (no, body, opts) => {
+        const num = no === null ? " ".repeat(numW) : padEnd(String(no), numW);
+        return (_jsxs(Text, { children: [_jsxs(Text, { color: opts.numColor, dimColor: opts.numColor === undefined || opts.dim, children: [num, " "] }), body] }));
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [sbs.isNewFile ? "new file " : "", "+", sbs.adds, " \u2212", sbs.dels] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: padEnd("BEFORE", paneW) }), _jsx(Text, { dimColor: true, children: sep }), _jsx(Text, { bold: true, children: "AFTER" })] }), shown.map((r, k) => {
+                if (r.kind === "context") {
+                    return (_jsxs(Text, { children: [renderCell(r.left.no, _jsx(Text, { dimColor: true, children: r.left.text }), { dim: true }), _jsx(Text, { dimColor: true, children: sep }), renderCell(r.right.no, _jsx(Text, { dimColor: true, children: r.right.text }), { dim: true })] }, k));
+                }
+                const leftNumColor = r.left !== null && r.changed ? theme.color.toolError : undefined;
+                const rightNumColor = r.right !== null && r.changed ? theme.color.success : undefined;
+                return (_jsxs(Text, { children: [r.left !== null
+                            ? renderCell(r.left.no, _jsx(LineBody, { lineText: r.left.text, runs: r.left.runs, base: "del", lang: lang }), { numColor: leftNumColor, dim: !r.changed })
+                            : renderCell(null, _jsx(Text, { children: padEnd("", contentW) }), { dim: true }), _jsx(Text, { dimColor: true, children: sep }), r.right !== null
+                            ? renderCell(r.right.no, _jsx(LineBody, { lineText: r.right.text, runs: r.right.runs, base: "add", lang: lang }), { numColor: rightNumColor, dim: !r.changed })
+                            : renderCell(null, _jsx(Text, { children: padEnd("", contentW) }), { dim: true })] }, k));
+            }), overflow > 0 ? _jsxs(Text, { dimColor: true, children: ["\u2026 ", overflow, " more row", overflow === 1 ? "" : "s"] }) : null, sbs.truncated ? _jsx(Text, { dimColor: true, children: "(diff truncated at 400 changed lines)" }) : null] }));
+}
+export const SideBySideDiffView = React.memo(SideBySideInner);

package/dist/ui/status-bar.js

@@ -1,4 +1,14 @@
 import { Fragment as _Fragment, jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+// Status bar leaf: the sole info bar, state-prioritized and quiet.
+// - idle: provider/model │ token │ cwd[:branch] │ reasoning │ mode.
+//   Labels are positional (no `provider:` prefixes); mode/trust show always
+//   (pinned), cwd shortens, branch only for git repos.
+// - busy: activity │ elapsed │ token │ reasoning │ mode │ esc-hint (+waiting/approval flags).
+//   Provider/model/cwd drop while working — the activity, the
+//   clock, context pressure, effort, and the pinned mode are what matter mid-turn.
+// All paint comes from ui/theme tokens. The token segment formatter lives
+// in context-windows (its only surface).
+import React from "react";
 import { Box, Text } from "ink";
 import { formatTokenSegment } from "../context-windows.js";
 import { theme } from "./theme.js";
@@ -20,7 +30,12 @@ export function shrinkTo(s, n) {
         return "";
     return `…/${s.slice(-(n - 3))}`;
 }
-export function StatusBar({ provider, model, usageTotals, contextLoad, reasoningDisplay, mode, trustAll, busy, activity, phaseLabel, elapsedSecs, stalled, approvalPending, cwd, branch, columns = 100, }) {
+// Render-count probe for the flicker tests: incremented on every StatusBar
+// render (same-props parent churn — token paints, keystrokes, unrelated
+// ticks — must skip it; only changed props repaint).
+export const statusBarRenderProbe = { count: 0 };
+export const StatusBar = React.memo(function StatusBar({ provider, model, usageTotals, contextLoad, reasoningDisplay, mode, trustAll, busy, activity, phaseLabel, elapsedSecs, stalled, approvalPending, cwd, branch, columns = 100, }) {
+    statusBarRenderProbe.count += 1;
     const bar = theme.symbol.bar;
     if (!busy) {
         const token = formatTokenSegment(usageTotals, model, contextLoad);
@@ -49,11 +64,12 @@ export function StatusBar({ provider, model, usageTotals, contextLoad, reasoning
         return (_jsx(Box, { marginTop: theme.spacing.statusMarginTop, children: _jsxs(Text, { dimColor: true, children: [provider, "/", model, " ", bar, " ", token, loc ? (_jsxs(_Fragment, { children: [" ", bar, " ", loc] })) : null, " ", bar, " reasoning: ", reasoningDisplay, " ", bar, " mode: ", mode, trust ? "+trust" : null] }) }));
     }
     // Busy layout prioritizes activity + clock + interrupt hint; the mode
-    // stays pinned (it used to vanish while working). The activity text
+    // stays pinned (it used to vanish while working), and the reasoning
+    // effort stays visible (it used to vanish while working). The activity text
     // shrinks to fit so `esc stops` never wraps away.
     const busyTrust = trustAll && mode !== "plan" ? "+trust" : "";
-    const busyFixed = ` ${bar} ${elapsedSecs}s ${bar} ${formatTokenSegment(usageTotals, model, contextLoad)} ${bar} mode: ${mode}${busyTrust} ${bar} esc stops`;
+    const busyFixed = ` ${bar} ${elapsedSecs}s ${bar} ${formatTokenSegment(usageTotals, model, contextLoad)} ${bar} reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${busyTrust} ${bar} esc stops`;
     const busyAvail = columns - busyFixed.length - 2;
     const activityText = shrinkTo(activity ?? phaseLabel, Math.max(0, busyAvail));
     return (_jsx(Box, { marginTop: theme.spacing.statusMarginTop, children: _jsxs(Text, { dimColor: true, children: [_jsxs(Text, { color: theme.color.activity, children: [theme.symbol.workTool, " ", activityText] }), busyFixed, stalled && !approvalPending ? ` ${bar} waiting${theme.symbol.ellipsis}` : null, approvalPending ? (_jsxs(Text, { color: theme.color.warning, children: [" ", bar, " waiting approval"] })) : null] }) }));
-}
+});

package/dist/ui/status-host.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Status-bar host: keeps the terminal-width subscription out of App.
+//
+// App used to call useStdout() in its own body to measure columns for the
+// bar's fit-or-drop logic, coupling the whole App render to stdout changes.
+// This memoized host owns that read instead: resizes re-render the bar
+// alone. StatusBar itself is untouched (same props API); `columns` becomes
+// an optional override (tests keep passing explicit widths, production
+// measures). The 100 fallback matches StatusBar's own default.
+import React from "react";
+import { useStdout } from "ink";
+import { StatusBar } from "./status-bar.js";
+export const StatusBarHost = React.memo(function StatusBarHost(props) {
+    let measured;
+    try {
+        measured = useStdout()?.stdout?.columns;
+    }
+    catch {
+        measured = undefined;
+    }
+    return _jsx(StatusBar, { ...props, columns: props.columns ?? measured ?? 100 });
+});

package/dist/ui/stream-store.js

@@ -0,0 +1,48 @@
+const EMPTY = { draft: null, thinking: null };
+export function createStreamStore() {
+    let snapshot = EMPTY;
+    const listeners = new Set();
+    function emit() {
+        for (const cb of [...listeners]) {
+            try {
+                cb();
+            }
+            catch {
+                // A throwing listener must not break the remaining subscribers.
+            }
+        }
+    }
+    function assign(next) {
+        if (next.draft === snapshot.draft && next.thinking === snapshot.thinking)
+            return;
+        snapshot = next;
+        emit();
+    }
+    return {
+        getSnapshot: () => snapshot,
+        subscribe: (cb) => {
+            listeners.add(cb);
+            return () => {
+                listeners.delete(cb);
+            };
+        },
+        setDraft: (text) => {
+            if (text === snapshot.draft)
+                return;
+            assign({ draft: text, thinking: snapshot.thinking });
+        },
+        setThinking: (text) => {
+            if (text === snapshot.thinking)
+                return;
+            assign({ draft: snapshot.draft, thinking: text });
+        },
+        getDraft: () => snapshot.draft,
+        getThinking: () => snapshot.thinking,
+        clear: () => {
+            if (snapshot !== EMPTY) {
+                snapshot = EMPTY;
+                emit();
+            }
+        },
+    };
+}

package/dist/ui/theme.js

@@ -54,6 +54,12 @@ export const theme = {
         code: "green",
         link: "cyan",
         heading: undefined, // bold, no hue
+        // Diff-body syntax colors (ui/highlight): Monokai-ish hues that read
+        // on dark and light terminals. Comments stay dim (no hue — same rule
+        // as muted text); plain code inherits the line paint.
+        synKeyword: "magenta",
+        synString: "yellow",
+        synNumber: "cyan",
     },
     border: {
         style: "round",

package/dist/ui/todo-panel.js

@@ -1,4 +1,8 @@
 import { jsxs as _jsxs } from "react/jsx-runtime";
+// Live session checklist panel (TodoWrite mirror). Prop-driven; returns
+// null when empty. Mounted below the transcript, fed by a checklist snapshot.
+// Paint from ui/theme tokens — no literal colors or glyphs here.
+import React from "react";
 import { Box, Text } from "ink";
 import { theme } from "./theme.js";
 // Live session checklist (Claude-Code-style TodoWrite panel). Mounted in
@@ -6,7 +10,11 @@ import { theme } from "./theme.js";
 // by a snapshot the loop refreshes after every todowrite/todo_update call,
 // so the in-progress row — shown with its activeForm when present — always
 // answers "what is the model doing right now". Returns null when empty.
-export function TodoPanel({ items }) {
+// Render-count probe for the flicker tests: same-props parent churn must
+// skip the panel (it only changes when the loop commits todo activity).
+export const todoPanelRenderProbe = { count: 0 };
+export const TodoPanel = React.memo(function TodoPanel({ items }) {
+    todoPanelRenderProbe.count += 1;
     if (items.length === 0)
         return null;
     const done = items.filter((t) => t.status === "completed").length;
@@ -19,4 +27,4 @@ export function TodoPanel({ items }) {
                 const label = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
                 return (_jsxs(Text, { dimColor: t.status === "completed", children: [mark, " ", label, t.priority ? ` (${t.priority})` : ""] }, `${i}-${t.content}`));
             })] }));
-}
+});

package/dist/ui/tool-inspector.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+import { truncateHead } from "../tools/shared.js";
 import { theme } from "./theme.js";
 export const MAX_TOOL_RECORDS = 50;
 export const STORE_CHARS = 32768;
@@ -8,7 +9,12 @@ export const LIST_WINDOW = 15;
 export function createToolRecord(id, label, result, isError, ms) {
     const text = result ?? "";
     const truncated = text.length > STORE_CHARS;
-    const stored = truncated ? text.slice(0, STORE_CHARS) : text;
+    // Line-aware store cap (issue 04): the stored head never ends mid-line.
+    // Single-giant-line inputs keep the hard cut (documented tail edge case),
+    // so over-cap single-line results still store exactly STORE_CHARS.
+    const stored = truncated
+        ? truncateHead(text, STORE_CHARS, "\n[truncated: stored output exceeded 32KB]").head
+        : text;
     return {
         id,
         label,