atom-agent 1.4.0 → 1.5.1

package/dist/tools.js

@@ -25,42 +25,10 @@ export * from "./tools/shared.js";
 export * from "./tools/shell.js";
 export * from "./tools/todo.js";
 export * from "./tools/web.js";
-export const UPDATE_GOAL_TOOL_DEFINITION = {
-    type: "function",
-    function: {
-        name: "update_goal",
-        description: "Report this goal turn's outcome (goal-scoped: only available during an active goal turn). " +
-            "WHEN to use: at the end of each goal turn — status \"continue\" with the next action, " +
-            "or \"complete\"/\"blocked\" with a reason. " +
-            "A \"complete\" lands only on genuinely finished work: verified checks and resolved todos. " +
-            "Checks you could not run go in \"unverified\" (recorded openly in the closing summary, never a gate). " +
-            "WHEN NOT to use: never outside a goal turn (it records nothing there); " +
-            "a turn with no report continues the goal.",
-        parameters: {
-            type: "object",
-            properties: {
-                status: {
-                    type: "string",
-                    enum: ["continue", "complete", "blocked"],
-                    description: "Turn outcome: \"continue\" (keep working), \"complete\" (goal done), \"blocked\" (cannot proceed).",
-                },
-                next: {
-                    type: "string",
-                    description: "Next action (only with status \"continue\"; omit otherwise).",
-                },
-                reason: {
-                    type: "string",
-                    description: "Why the goal is done or stuck (required with \"complete\"/\"blocked\"; omit otherwise).",
-                },
-                unverified: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Checks that could not be run (only with status \"complete\"; omit otherwise). " +
-                        "Recorded openly in the closing summary; at most 10 non-empty items of 200 characters each.",
-                },
-            },
-            required: ["status"],
-            additionalProperties: false,
-        },
-    },
-};
+// UPDATE_GOAL_TOOL_DEFINITION lives in src/tools/registry.ts beside its
+// validator and executor (ticket 06: intercepted first-class registry
+// entries) and re-exports through the `export *` barrel above, so every
+// existing `from "./tools.js"` importer keeps working untouched. The loop
+// dispatches it through the registry runner (never by name), and chat
+// payloads carry it via allToolDefinitions — one list for model visibility
+// and executability.

package/dist/ui/diff-panel.js

@@ -51,5 +51,5 @@ export function DiffPanel({ files, index, expanded }) {
                     return (_jsxs(Text, { color: hi ? theme.color.selection : undefined, children: [hi ? `${theme.symbol.select} ` : theme.spacing.rowIndent, "+", r.adds, " \u2212", r.dels, " ", r.path] }, r.path));
                 }), win.below > 0 ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreBelow, " ", win.below, " more"] })) : null, _jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, "/", theme.symbol.moreBelow, " move \u00B7 Enter expands \u00B7 Esc closes"] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [rec.path, _jsxs(Text, { dimColor: true, children: [" ", theme.symbol.separator, " +", rec.adds, " \u2212", rec.dels] })] }), _jsx(Text, { dimColor: true, children: theme.symbol.rule.repeat(32) }), _jsx(SideBySideDiffView, { oldText: rec.oldText, newText: rec.newText, lang: rec.lang }), _jsx(Text, { dimColor: true, children: theme.symbol.rule.repeat(32) }), _jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, "/", theme.symbol.moreBelow, " prev/next file \u00B7 Enter collapses \u00B7 Esc closes"] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SideBySideDiffView, { oldText: rec.oldText, newText: rec.newText, lang: rec.lang, path: rec.path }), _jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, "/", theme.symbol.moreBelow, " prev/next file \u00B7 Enter collapses \u00B7 Esc closes"] })] }));
 }

package/dist/ui/diff-view.js

@@ -13,7 +13,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // against the installed Ink 7 typings).
 import React from "react";
 import { Box, Text } from "ink";
-import { computeDiff } from "./diff.js";
+import { computeDiff, hunksRange, rangeLabel } from "./diff.js";
 import { highlightLine } from "./highlight.js";
 import { theme } from "./theme.js";
 function syntaxColor(kind) {
@@ -37,7 +37,7 @@ function syntaxColor(kind) {
 // both the walk and the tokenize lookup.
 export const LineBody = React.memo(function LineBody({ lineText, runs, base, lang, }) {
     const baseColor = base === "add" ? theme.color.success : theme.color.toolError;
-    const hlBg = base === "add" ? "green" : "red";
+    const hlBg = base === "add" ? theme.color.diffAddBg : theme.color.diffDelBg;
     const langKnown = lang === "c" || lang === "py" || lang === "sh" || lang === "data";
     const syn = langKnown ? highlightLine(lineText, lang) : [];
     const nodes = [];
@@ -50,7 +50,7 @@ export const LineBody = React.memo(function LineBody({ lineText, runs, base, lan
         if (r.changed) {
             // Changed words keep the high-contrast background treatment —
             // syntax hues would muddy the signal.
-            nodes.push(_jsx(Text, { backgroundColor: hlBg, color: "black", bold: true, children: r.text }, k));
+            nodes.push(_jsx(Text, { backgroundColor: hlBg, color: theme.color.diffChangedFg, bold: true, children: r.text }, k));
             // Advance the syntax cursor past this run so later runs align.
             while (synIdx < syn.length && syn[synIdx].end <= runEnd)
                 synIdx += 1;
@@ -87,7 +87,15 @@ export const LineBody = React.memo(function LineBody({ lineText, runs, base, lan
     });
     return _jsx(Text, { color: langKnown ? undefined : baseColor, children: nodes });
 });
-function DiffViewInner({ oldText, newText, lang = null, maxLines = Infinity }) {
+// Ticket 02 signature header: ONE quiet dim line — change counts, path,
+// line range — shared verbatim by the unified view, the side-by-side view
+// (ui/side-by-side), the approval modal, the committed transcript, and the
+// /diff review. Changed rows carry +/- color + word backgrounds; context
+// rows stay dim so unchanged text reads subordinate.
+export function DiffSummary({ adds, dels, isNewFile, path, range, }) {
+    return (_jsxs(Text, { dimColor: true, children: [isNewFile ? "new file " : "", "+", adds, " \u2212", dels, path ? ` ${theme.symbol.separator} ${path}` : "", range ? ` ${theme.symbol.separator} ${range}` : ""] }));
+}
+function DiffViewInner({ oldText, newText, lang = null, path = null, maxLines = Infinity }) {
     const diff = React.useMemo(() => computeDiff(oldText, newText), [oldText, newText]);
     if (diff.skipped) {
         return _jsx(Text, { dimColor: true, children: diff.skipped });
@@ -102,7 +110,7 @@ function DiffViewInner({ oldText, newText, lang = null, maxLines = Infinity }) {
             total += h.lines.length;
         return Math.max(0, total - maxLines);
     })();
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [diff.isNewFile ? "new file " : "", "+", diff.adds, " \u2212", diff.dels] }), diff.hunks.map((h, hi) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["@@ -", h.oldStart, ",", h.oldLines, " +", h.newStart, ",", h.newLines, " @@"] }), h.lines.map((ln, k) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(DiffSummary, { adds: diff.adds, dels: diff.dels, isNewFile: diff.isNewFile, path: path, range: diff.isNewFile ? null : rangeLabel(hunksRange(diff.hunks)) }), diff.hunks.map((h, hi) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["@@ -", h.oldStart, ",", h.oldLines, " +", h.newStart, ",", h.newLines, " @@"] }), h.lines.map((ln, k) => {
                         bodyLines += 1;
                         if (bodyLines > maxLines)
                             return null;

package/dist/ui/diff.js

@@ -261,6 +261,73 @@ export function computeDiff(oldText, newText) {
     flush(hunkStart, hunkEnd);
     return { hunks, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
 }
+// Overall changed-line range for unified hunks (hunk context excluded —
+// the header names the span that changed, the @@ lines keep per-hunk detail).
+export function hunksRange(hunks) {
+    let oldMin = null;
+    let oldMax = null;
+    let newMin = null;
+    let newMax = null;
+    for (const h of hunks) {
+        // Walk hunk lines counting only changed lines for the range.
+        let ho = h.oldStart;
+        let hn = h.newStart;
+        for (const ln of h.lines) {
+            if (ln.kind === "context") {
+                ho += 1;
+                hn += 1;
+                continue;
+            }
+            if (ln.kind === "del") {
+                oldMin = oldMin === null ? ho : Math.min(oldMin, ho);
+                oldMax = oldMax === null ? ho : Math.max(oldMax, ho);
+                ho += 1;
+            }
+            else {
+                newMin = newMin === null ? hn : Math.min(newMin, hn);
+                newMax = newMax === null ? hn : Math.max(newMax, hn);
+                hn += 1;
+            }
+        }
+    }
+    return { oldMin, oldMax, newMin, newMax };
+}
+// Overall line range for side-by-side rows (change rows only — context
+// excluded, same rule as hunksRange so both views agree).
+export function sbsRange(rows) {
+    let oldMin = null;
+    let oldMax = null;
+    let newMin = null;
+    let newMax = null;
+    for (const r of rows) {
+        if (r.kind === "context")
+            continue;
+        if (r.oldNo !== null) {
+            oldMin = oldMin === null ? r.oldNo : Math.min(oldMin, r.oldNo);
+            oldMax = oldMax === null ? r.oldNo : Math.max(oldMax, r.oldNo);
+        }
+        if (r.newNo !== null) {
+            newMin = newMin === null ? r.newNo : Math.min(newMin, r.newNo);
+            newMax = newMax === null ? r.newNo : Math.max(newMax, r.newNo);
+        }
+    }
+    return { oldMin, oldMax, newMin, newMax };
+}
+function span(min, max) {
+    if (min === null || max === null)
+        return null;
+    return min === max ? `L${min}` : `L${min}–${max}`;
+}
+// "L2 → L2", "L2–20 → L2–21", or the one-sided remainder for pure
+// add/del blocks. Null when there is nothing to name (new files carry
+// the `new file` marker instead of a range; callers skip null).
+export function rangeLabel(r) {
+    const o = span(r.oldMin, r.oldMax);
+    const n = span(r.newMin, r.newMax);
+    if (o && n)
+        return o === n ? o : `${o} → ${n}`;
+    return o ?? n;
+}
 export function computeSideBySide(oldText, newText) {
     if (isBinary(newText) || (oldText !== null && isBinary(oldText))) {
         return { kind: "binary" };

package/dist/ui/errors.js

@@ -14,6 +14,20 @@ export function parseToolLabel(label) {
 export function titleCase(name) {
     return name.length > 0 ? name[0].toUpperCase() + name.slice(1) : name;
 }
+// One-line guarantee (ticket 04): the card is a summary, never a wall. The
+// loop already commits only the first error line, but the classifier must
+// not trust its input — any multi-line turn committed directly (tests,
+// future paths) collapses to its first line here, and pathological
+// single-line output caps at MAX_DETAIL_CHARS. The full text always waits
+// in the Ctrl+O inspector store (tool failures) or the model reply stream.
+export const MAX_DETAIL_CHARS = 200;
+export function summarizeDetail(raw) {
+    const first = raw
+        .replace(/^[↳\s]+/, "")
+        .split("\n", 1)[0]
+        .trim();
+    return first.length > MAX_DETAIL_CHARS ? `${first.slice(0, MAX_DETAIL_CHARS)}…` : first;
+}
 const NETWORK_RE = /HTTP (429|500|502|503|504)|connection reset|fetch failed|network|timed? ?out|ENOTFOUND|ECONN|EAI_AGAIN|socket hang up/i;
 const MODEL_RE = /Empty reply|Truncated stream|malformed|unexpected payload|no .* usage|invalid response/i;
 const CONFIG_RE = /Missing API key|no API key|not configured|invalid baseURL|auth/i;
@@ -29,14 +43,14 @@ export function classifyToolError(turn, label) {
             return {
                 kind: "config",
                 title: "Setup needed",
-                detail: content.trim(),
+                detail: summarizeDetail(content),
                 hint: "Run /provider to paste a key, then resend.",
                 inspectable: false,
             };
         }
         return null;
     }
-    const detail = content.replace(/^[↳\s]+/, "");
+    const detail = summarizeDetail(content);
     if (/denied by user/i.test(detail)) {
         const tool = detail.split(":").pop()?.trim() ?? "";
         return {
@@ -105,10 +119,10 @@ export function classifyToolError(turn, label) {
     };
 }
 const KIND_GLYPH = {
-    tool: "✕",
-    denial: "⊘",
-    network: "⚠",
-    model: "✕",
+    tool: theme.symbol.toolFail,
+    denial: theme.symbol.toolDenied,
+    network: theme.symbol.warningMark,
+    model: theme.symbol.toolFail,
     cancelled: "",
     config: "→",
     internal: "‼",

package/dist/ui/input.js

@@ -1,8 +1,10 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 // Input leaf: the boxed prompt surface. Prop-driven + memoized on
-// (input, cursor) so timer ticks never repaint it. Multiline aware: the
-// cursor rides line/col and long lines wrap via Ink. Deliberately bare —
-// no placeholder text, no hints; the box + cursor is the affordance.
+// (input, cursor, busy) so timer ticks never repaint it. Multiline aware: the
+// cursor rides line/col and long lines wrap via Ink.
+// Footer-cluster states: idle shows just the box + cursor; busy dims the
+// whole surface and carries its own interrupt hint, so the input never
+// vanishes mid-turn — Enter while busy queues, esc stops.
 // Paint from ui/theme tokens — no literal colors or glyphs here.
 import React from "react";
 import { Box, Text } from "ink";
@@ -14,27 +16,29 @@ import { lineColOf, splitInputLines } from "./input-model.js";
 export const inputRenderProbe = { count: 0 };
 // The input is the one boxed, prominent surface: a quiet gray frame sets it
 // apart from the transcript above and the status line below. Memoized on
-// (input, cursor) so elapsed-timer ticks, token paints, and unrelated App
-// state churn never repaint it — keystrokes stay at exactly one paint each,
-// which is what makes navigation feel instant instead of choppy.
-export const InputBox = React.memo(function InputBox({ input, cursor }) {
+// (input, cursor, busy) so elapsed-timer ticks, token paints, and unrelated
+// App state churn never repaint it — keystrokes stay at exactly one paint
+// each, which is what makes navigation feel instant instead of choppy.
+// `busy` flips only at turn boundaries (never per tick/token), so the
+// working state costs exactly one extra paint per turn edge.
+export const InputBox = React.memo(function InputBox({ input, cursor, busy = false }) {
     inputRenderProbe.count += 1;
     // Defensive clamp: the ref is the source of truth mid-tick and always
     // stays in range, but state may lag it by one render.
     const safeCursor = Math.max(0, Math.min(cursor, input.length));
     const lines = splitInputLines(input);
     const { line: cline, col: ccol } = lineColOf(input, safeCursor);
-    return (_jsxs(Box, { borderStyle: theme.border.style, borderColor: theme.border.input, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { color: theme.color.inputPrompt, bold: true, children: [theme.symbol.inputPrompt, " "] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: lines.map((ln, i) => {
-                    if (i !== cline)
-                        return _jsx(Text, { children: ln.length > 0 ? ln : " " }, i);
-                    // See-through cursor: the character under the cursor renders in
-                    // inverse video instead of inserting a block glyph beside it, so
-                    // letters never shift aside as the cursor moves (the old block
-                    // made the line wobble on every arrow-key step). At end of line
-                    // (or on an empty line) an inverse space holds the cell.
-                    const before = ln.slice(0, ccol);
-                    const at = ln.slice(ccol, ccol + 1);
-                    const after = ln.slice(ccol + 1);
-                    return (_jsxs(Text, { children: [before, _jsx(Text, { inverse: true, children: at.length > 0 ? at : " " }), after] }, i));
-                }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsxs(Box, { borderStyle: theme.border.style, borderColor: theme.border.input, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { color: theme.color.inputPrompt, bold: true, dimColor: busy, children: [theme.symbol.inputPrompt, " "] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: lines.map((ln, i) => {
+                            if (i !== cline)
+                                return (_jsx(Text, { dimColor: busy, children: ln.length > 0 ? ln : " " }, i));
+                            // See-through cursor: the character under the cursor renders in
+                            // inverse video instead of inserting a block glyph beside it, so
+                            // letters never shift aside as the cursor moves (the old block
+                            // made the line wobble on every arrow-key step). At end of line
+                            // (or on an empty line) an inverse space holds the cell.
+                            const before = ln.slice(0, ccol);
+                            const at = ln.slice(ccol, ccol + 1);
+                            const after = ln.slice(ccol + 1);
+                            return (_jsxs(Text, { dimColor: busy, children: [before, _jsx(Text, { inverse: true, children: at.length > 0 ? at : " " }), after] }, i));
+                        }) })] }), busy ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workTool, " working ", theme.symbol.separator, " esc stops ", theme.symbol.separator, " Enter queues"] })) : null] }));
 });

package/dist/ui/live-tail.js

@@ -9,6 +9,12 @@ import { Box, Text } from "ink";
 import { activityText } from "./activity.js";
 import { MarkdownStream } from "./markdown.js";
 import { theme } from "./theme.js";
+// Live thinking window (render-stability): reasoning streams at token rate,
+// and painting the full accumulated text every 64ms both churns frame
+// height and re-lays-out an ever-growing block. The live view shows only
+// the tail — the full text still commits to the transcript at the round
+// boundary, so nothing is ever lost.
+export const LIVE_THINKING_LINES = 8;
 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
@@ -17,5 +23,34 @@ export const LiveTail = React.memo(function LiveTail({ isEmpty, sessionHint, emp
     // 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, 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] }));
+    const thoughtLines = thinking !== null ? thinking.split("\n") : [];
+    const thoughtTail = thoughtLines.slice(-LIVE_THINKING_LINES);
+    const thoughtTruncated = thoughtLines.length > thoughtTail.length;
+    // Restraint (ticket 07): an empty live zone mounts nothing. The Box below
+    // carries marginY, which Ink paints as blank lines even with no children —
+    // without this guard every idle frame with history wasted two vertical
+    // lines between the transcript and the input. When the transcript is empty
+    // the hint lines always render, so only the non-empty, nothing-live case
+    // collapses. Mirror the JSX conditions below (falsy draft/toolHint render
+    // nothing there, so they count as nothing here too).
+    const showsDraft = !freezeLive && !!draft;
+    const showsThinking = !freezeLive && thinking !== null && showThinking;
+    const showsToolHint = busy && !!toolHint;
+    const showsThinkingGap = !freezeLive && busy && !draft && !thinking && !toolHint;
+    if (!isEmpty &&
+        !freezeLive &&
+        !showsDraft &&
+        !showsThinking &&
+        !showsToolHint &&
+        !showsThinkingGap) {
+        return 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 ? (
+            // Grouped thinking unit: dim labeled header + quoteBar-prefixed tail
+            // body reads as one quiet block, structurally separate from the
+            // answer draft above (magenta ATOM> + markdown). Tail-window behavior
+            // unchanged; divider lives inside this row's own box (no extra
+            // Static rows). Muted = dimColor per theme law, never gray paint
+            // (cursor glyph keeps the reserved mutedPaint shade).
+            _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " thinking", thoughtTruncated ? ` ${theme.symbol.ellipsis}` : ""] }), thoughtTail.map((line, idx) => (_jsxs(Text, { dimColor: true, children: [`${theme.symbol.quoteBar} ${line}`, idx === thoughtTail.length - 1 ? (_jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBar })) : null] }, idx)))] })) : 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

@@ -532,9 +532,14 @@ export function MarkdownText({ text }) {
 // 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 }) {
+export function ToolLine({ content, error, ms, via }) {
+    // Approval provenance suffix (ticket 04): a dim `· via <token>` marker
+    // rendered OUTSIDE the label text, so `⚙ name target` stays byte-identical
+    // for the parsers/tests that read it (parseToolLabel/parseActivityHint)
+    // while what allowed the call stays visible on the audit line.
+    const suffix = via ? ` ${theme.symbol.separator} via ${via}` : "";
     if (error) {
-        return _jsx(Text, { color: theme.color.toolError, children: content });
+        return _jsxs(Text, { color: theme.color.toolError, children: [content, suffix] });
     }
     if (content.startsWith("⚠ ")) {
         return _jsx(Text, { color: theme.color.warning, children: content });
@@ -543,7 +548,7 @@ export function ToolLine({ content, error, ms }) {
         !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 (_jsxs(Text, { color: theme.color.tool, dimColor: true, children: [content, suffix, " ", theme.symbol.separator, " ", Math.round(ms / 1000), "s"] }));
     }
-    return (_jsx(Text, { color: theme.color.tool, dimColor: true, children: content }));
+    return (_jsxs(Text, { color: theme.color.tool, dimColor: true, children: [content, suffix] }));
 }

package/dist/ui/modals.js

@@ -7,10 +7,12 @@ import React from "react";
 import { Box, Text } from "ink";
 import { SideBySideDiffView } from "./side-by-side.js";
 import { theme } from "./theme.js";
-// Retained for compatibility (no longer applied — the approval preview
-// renders the full diff; smoothness comes from the per-mount memo + word
-// fallbacks, not from a row cap).
-export const APPROVAL_DIFF_MAX_LINES = Infinity;
+// Display-only window for the approval preview (hunk headers excluded;
+// the trailer names the remainder). The diff engine stays uncapped and the
+// transcript renders the full diff on approve — this window only keeps the
+// modal (and its allow/deny options) on screen instead of pushing the frame
+// into fullscreen full-clear territory on every large write.
+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
@@ -39,7 +41,7 @@ export const ApprovalBox = React.memo(function ApprovalBox({ toolName, descripti
         { 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 }) : 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" })] }));
+    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, path: diff.path, maxRows: APPROVAL_DIFF_MAX_LINES }) : null, diff ? _jsx(Text, { dimColor: true, children: "Full diff renders in the transcript on approve." }) : 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;

package/dist/ui/paint-scheduler.js

@@ -0,0 +1,120 @@
+// Centralized streaming paint scheduler: ONE trailing timer for every live
+// lane (answer draft + thinking).
+//
+// EVENT FREQUENCY != RENDER FREQUENCY: tokens may arrive hundreds per
+// second, but terminal paints coalesce to at most one per interval, always
+// carrying the latest pending text per lane, delivered in a SINGLE onFlush
+// call so draft + thinking land in the same React render instead of
+// fighting across two frames.
+//
+// Rules it enforces:
+// - latest-wins per lane (never queue stale paints behind each other)
+// - leading immediate paint after idle (no typing/stream-start latency)
+// - trailing coalescing inside the window (no per-token renders)
+// - deterministic flush() for turn end, tool transitions, errors, and
+//   completion (the final state always paints exactly once)
+// - cancel() drops pending text AND the timer, so a trailing paint can
+//   never resurrect stale content after a clear/rollback
+// - timer failure degrades to immediate paint (never lose content)
+//
+// The interval is injected (App passes DRAFT_THROTTLE_MS); the default
+// matches it. For unit tests, now/clock are injectable like the throttler's.
+export const PAINT_INTERVAL_MS = 64;
+export function createPaintScheduler(opts) {
+    const intervalMs = opts.intervalMs ?? PAINT_INTERVAL_MS;
+    const nowFn = opts.now ?? Date.now;
+    const setT = opts.setTimeoutFn ?? setTimeout;
+    const clearT = opts.clearTimeoutFn ?? clearTimeout;
+    const onFlush = opts.onFlush;
+    const pending = new Map();
+    let lastFlush = Number.NEGATIVE_INFINITY;
+    let timer = null;
+    function safeNow() {
+        try {
+            return nowFn();
+        }
+        catch {
+            return Date.now();
+        }
+    }
+    function clearTimer() {
+        if (timer !== null) {
+            try {
+                clearT(timer);
+            }
+            catch {
+                // ignore (a stray trailing paint is harmless — flush() already ran)
+            }
+            timer = null;
+        }
+    }
+    // Single paint path (also the never-lose-content fallback).
+    function emit(at) {
+        if (pending.size === 0) {
+            clearTimer();
+            return;
+        }
+        clearTimer();
+        const lanes = {};
+        const draft = pending.get("draft");
+        const thinking = pending.get("thinking");
+        if (draft !== undefined)
+            lanes.draft = draft;
+        if (thinking !== undefined)
+            lanes.thinking = thinking;
+        pending.clear();
+        lastFlush = at;
+        onFlush(lanes);
+    }
+    return {
+        push(lane, text) {
+            pending.set(lane, text);
+            const t = safeNow();
+            if (t - lastFlush >= intervalMs) {
+                emit(t);
+                return;
+            }
+            if (timer !== null)
+                return; // trailing paint already scheduled
+            const wait = intervalMs - (t - lastFlush);
+            try {
+                timer = setT(() => {
+                    timer = null;
+                    emit(safeNow());
+                }, Math.max(0, wait));
+            }
+            catch {
+                // No timer available: paint now rather than lose the token.
+                emit(safeNow());
+            }
+        },
+        flush() {
+            if (pending.size === 0) {
+                clearTimer();
+                return;
+            }
+            emit(safeNow());
+        },
+        cancel(lane) {
+            if (lane === undefined) {
+                pending.clear();
+            }
+            else {
+                pending.delete(lane);
+            }
+            if (pending.size === 0)
+                clearTimer();
+        },
+        reset() {
+            pending.clear();
+            clearTimer();
+            lastFlush = Number.NEGATIVE_INFINITY;
+        },
+        getPending(lane) {
+            return pending.get(lane) ?? null;
+        },
+        pendingTimers() {
+            return timer === null ? 0 : 1;
+        },
+    };
+}

package/dist/ui/palette.js

@@ -30,7 +30,6 @@ const PALETTE_CATEGORIES = {
     "/allow": "Tools",
     "/deny": "Tools",
     "/rules": "Tools",
-    "/skills": "Skills",
     "/skill": "Skills",
     "/queue": "Flow",
     "/steer": "Flow",
@@ -68,5 +67,8 @@ export const PalettePanel = React.memo(function PalettePanel({ entries, index, f
         }
         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] }));
+    return (
+    // flexShrink=0: footer-cluster anchoring (ticket 05) — same contract as
+    // PickerShell; the list truncates via pickerWindow instead of squeezing.
+    _jsxs(Box, { flexDirection: "column", flexShrink: 0, 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/pickers.js

@@ -2,7 +2,10 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { theme } from "./theme.js";
 export function PickerShell({ title, borderColor = theme.border.picker, children, }) {
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: borderColor, paddingX: theme.spacing.pickerPadX, children: [_jsx(Text, { bold: true, children: title }), children] }));
+    return (
+    // flexShrink=0: footer-cluster anchoring (ticket 05) — a tall list never
+    // squeezes when the terminal runs short; it truncates via pickerWindow.
+    _jsxs(Box, { flexDirection: "column", flexShrink: 0, borderStyle: theme.border.style, borderColor: borderColor, paddingX: theme.spacing.pickerPadX, children: [_jsx(Text, { bold: true, children: title }), children] }));
 }
 export function PickerMoreAbove({ count }) {
     if (count <= 0)