atom-agent 1.3.0 → 1.5.0

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

@@ -4,10 +4,10 @@ import { computeDiff } from "./diff.js";
 import { SideBySideDiffView } from "./side-by-side.js";
 import { theme } from "./theme.js";
 import { LIST_WINDOW, windowedList } from "./tool-inspector.js";
-// Cap for the panel detail (hunk headers excluded): full-file writes can
-// be large — the head reviews, the trailer names the remainder, the file
-// on disk is the whole truth.
-export const DIFF_PANEL_MAX_LINES = 200;
+// Retained for compatibility (no longer applied — the panel renders the
+// full preview; smoothness comes from the per-mount memo + word fallbacks,
+// not from a row cap).
+export const DIFF_PANEL_MAX_LINES = Infinity;
 // Group committed session previews by file: latest preview per path
 // wins (a later edit supersedes the earlier view of the same file),
 // first-seen path order kept. Previews without a path are ungroupable
@@ -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, maxRows: DIFF_PANEL_MAX_LINES }), _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

@@ -6,13 +6,14 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // changed-word backgrounds + syntax foregrounds (ui/highlight, zero-dep),
 // one <Text> per run (no per-character nodes), word diff + highlighting
 // memoized/cached so the 1s busy tick never recomputes. Long lines are
-// never truncated (Ink wraps; copy/paste stays intact) — only hunk COUNT
-// is capped via maxLines so the modal stays compact. All paint comes from
+// never truncated (Ink wraps; copy/paste stays intact); the full hunk list
+// renders by default (an explicit maxLines windows it when a caller passes
+// one). All paint comes from
 // ui/theme tokens (Ink supports color + backgroundColor on Text — verified
 // 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) {
@@ -36,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 = [];
@@ -49,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;
@@ -86,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 });
@@ -101,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

@@ -4,6 +4,10 @@
 export const CHANGE_THRESHOLD = 0.4;
 // Mirrors Claude's DiffDetailView guards.
 export const MAX_FILE_BYTES = 1_000_000;
+// Retained for compatibility (no longer applied — the engine returns the
+// full hunk list; views render it whole). Safety caps that remain enforced:
+// MAX_FILE_BYTES, binary detect, MAX_MYERS_LINES fallback, MAX_WORD_TOKENS
+// fallback.
 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.
@@ -183,7 +187,7 @@ export function computeDiff(oldText, newText) {
     const hunks = [];
     let adds = 0;
     let dels = 0;
-    let truncated = false;
+    const 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) => {
@@ -242,7 +246,6 @@ export function computeDiff(oldText, newText) {
         }
         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];
@@ -251,33 +254,79 @@ export function computeDiff(oldText, newText) {
         }
         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;
+    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;
+            }
         }
-        truncated = true;
-        return { hunks: out, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
     }
-    return { hunks, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
+    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))) {
@@ -316,9 +365,7 @@ export function computeSideBySide(oldText, newText) {
     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 truncated = false;
     const flushSlice = (s, e) => {
         const slice = raw.slice(s, e);
         let k = 0;
@@ -376,12 +423,7 @@ export function computeSideBySide(oldText, newText) {
             }
             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);
@@ -392,31 +434,11 @@ export function computeSideBySide(oldText, newText) {
             hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
         }
         else {
-            if (!flushSlice(hunkStart, hunkEnd)) {
-                return { kind: "diff", rows, adds, dels, truncated, isNewFile: oldText === null };
-            }
+            flushSlice(hunkStart, hunkEnd);
             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/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,9 +7,11 @@ 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.
+// 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
@@ -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, 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" })] }));
+    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;