atom-agent 1.1.0 → 1.3.0

package/dist/ui/diff-view.js

@@ -29,7 +29,12 @@ function syntaxColor(kind) {
 // an offset cursor paints every char exactly once (text integrity is
 // pinned by tests — highlighting must never alter content). Exported:
 // the side-by-side view (ui/side-by-side) reuses it per pane cell.
-export function LineBody({ lineText, runs, base, lang, }) {
+//
+// Memoized: props are (lineText, runs, base, lang) — `runs` keeps identity
+// from the parent's useMemo'd diff, and highlightLine is itself line-cached,
+// so unrelated parent renders (ticks, keystrokes, appends elsewhere) skip
+// 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 langKnown = lang === "c" || lang === "py" || lang === "sh" || lang === "data";
@@ -80,7 +85,7 @@ export function LineBody({ lineText, runs, base, lang, }) {
         nodes.push(_jsx(Text, { children: parts }, k));
     });
     return _jsx(Text, { color: langKnown ? undefined : baseColor, children: nodes });
-}
+});
 function DiffViewInner({ oldText, newText, lang = null, maxLines = Infinity }) {
     const diff = React.useMemo(() => computeDiff(oldText, newText), [oldText, newText]);
     if (diff.skipped) {

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, showThinking = true }) {
+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 && 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] }));
-}
+    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/palette.js

@@ -9,7 +9,7 @@ import { Box, Text } from "ink";
 import { PickerMoreAbove, PickerMoreBelow, pickerWindow } from "./pickers.js";
 import { theme } from "./theme.js";
 export const PALETTE_WINDOW = 12;
-export const PALETTE_CATEGORY_ORDER = ["Model", "Session", "Tools", "Skills", "Flow", "Help"];
+export const PALETTE_CATEGORY_ORDER = ["Model", "Session", "Tools", "Skills", "Flow", "Extensions", "Help"];
 const PALETTE_CATEGORIES = {
     "/model": "Model",
     "/provider": "Model",
@@ -18,6 +18,8 @@ const PALETTE_CATEGORIES = {
     "/clear": "Session",
     "/new": "Session",
     "/resume": "Session",
+    "/rename": "Session",
+    "/session": "Session",
     "/rewind": "Session",
     "/context": "Session",
     "/telemetry": "Session",

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

@@ -9,8 +9,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 //   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 (useStdout, same
-//   pattern as App's termColumns); long lines truncate per pane with …
+// - 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

package/dist/ui/status-bar.js

@@ -12,6 +12,47 @@ import React from "react";
 import { Box, Text } from "ink";
 import { formatTokenSegment } from "../context-windows.js";
 import { theme } from "./theme.js";
+// Default objective budget for the goal segment: compact enough to share the
+// line with the pinned model/token/mode segments at 100 columns.
+export const GOAL_STATUS_OBJECTIVE_CHARS = 32;
+// Truncate an objective to n chars max (`…` tail keeps the start, which
+// carries the verb). n < 4 yields "" (the caller drops the segment instead).
+export function truncateGoalObjective(objective, max = GOAL_STATUS_OBJECTIVE_CHARS) {
+    const text = typeof objective === "string" ? objective : "";
+    if (text.length <= max)
+        return text;
+    if (max < 4)
+        return "";
+    return `${text.slice(0, max - 1)}…`;
+}
+// Full goal segment at the default budget, or null when no goal is live.
+// Paused reads distinct from active (`[paused]` vs `[active]`).
+export function formatGoalSegment(goal, max = GOAL_STATUS_OBJECTIVE_CHARS) {
+    if (!goal || typeof goal.objective !== "string" || goal.objective.length === 0)
+        return null;
+    const state = goal.active === true ? "active" : "paused";
+    return `goal: ${truncateGoalObjective(goal.objective, max)} [${state}]`;
+}
+// Fit the goal segment into `room` chars (the width left after every other
+// segment): full text when it fits, a shorter truncation when it almost
+// fits, null (drop the segment) when even a stub would displace the line.
+// Never throws; never returns "".
+export function fitGoalSegment(goal, room) {
+    if (!goal || typeof goal.objective !== "string" || goal.objective.length === 0)
+        return null;
+    if (typeof room !== "number" || !Number.isFinite(room) || room <= 0)
+        return null;
+    const state = goal.active === true ? "active" : "paused";
+    const full = `goal: ${goal.objective} [${state}]`;
+    if (full.length <= room)
+        return full;
+    // Room for at least 4 objective chars plus the fixed framing, else drop.
+    const overhead = `goal:  [${state}]`.length + 1;
+    const allow = Math.floor(room - overhead);
+    if (allow < 4)
+        return null;
+    return `goal: ${truncateGoalObjective(goal.objective, allow)} [${state}]`;
+}
 // ~/… collapse + tail-cut: informative, never a full scroll of nesting.
 // Further shrinking for tight widths goes through shrinkTo below (the bar
 // measures first and only renders what fits).
@@ -34,9 +75,13 @@ export function shrinkTo(s, n) {
 // 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, }) {
+export const StatusBar = React.memo(function StatusBar({ provider, model, usageTotals, contextLoad, reasoningDisplay, mode, trustAll, busy, activity, phaseLabel, elapsedSecs, stalled, approvalPending, cwd, branch, columns = 100, extensionStatus, goal, }) {
     statusBarRenderProbe.count += 1;
     const bar = theme.symbol.bar;
+    // Extension guest slot (ticket 10): pre-budgeted text renders only when
+    // the full line still fits — the fixed-width contract above. The `+ 3`
+    // is the ` ${bar} ` separator the segment carries with it.
+    const hasExt = typeof extensionStatus === "string" && extensionStatus.length > 0;
     if (!busy) {
         const token = formatTokenSegment(usageTotals, model, contextLoad);
         const trust = trustAll && mode !== "plan" ? "+trust" : "";
@@ -46,7 +91,8 @@ export const StatusBar = React.memo(function StatusBar({ provider, model, usageT
         // order: branch → cwd tail → the whole segment.
         const tail = `reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${trust}`;
         const baseLen = `${provider}/${model} ${bar} ${token} ${bar}  ${bar} ${tail}`.length;
-        const avail = columns - baseLen;
+        const showExt = hasExt && baseLen + extensionStatus.length + 3 + 2 <= columns;
+        const avail = columns - baseLen - (showExt ? extensionStatus.length + 3 : 0);
         let loc = null;
         if (cwd) {
             const branchPart = branch ? ` : ${branch}` : "";
@@ -61,15 +107,44 @@ export const StatusBar = React.memo(function StatusBar({ provider, model, usageT
                 loc = shrunk ? shrunk : null;
             }
         }
-        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] }) }));
+        // Goal segment (ticket 09): lowest-priority builtin — it takes only the
+        // width left after every other segment and drops whole rather than push
+        // the line past `columns`. Hidden entirely with no goal.
+        const lineSoFar = baseLen + (showExt ? extensionStatus.length + 3 : 0) + (loc ? loc.length + 3 : 0);
+        const goalSeg = fitGoalSegment(goal ?? null, columns - lineSoFar - 2);
+        return (_jsx(Box, { marginTop: theme.spacing.statusMarginTop, children: _jsxs(Text, { dimColor: true, children: [provider, "/", model, " ", bar, " ", token, showExt ? (_jsxs(_Fragment, { children: [" ", bar, " ", extensionStatus] })) : null, loc ? (_jsxs(_Fragment, { children: [" ", bar, " ", loc] })) : null, " ", bar, " reasoning: ", reasoningDisplay, " ", bar, " mode: ", mode, trust ? "+trust" : null, goalSeg ? (_jsxs(_Fragment, { children: [" ", bar, " ", goalSeg] })) : null] }) }));
     }
     // Busy layout prioritizes activity + clock + interrupt hint; the mode
     // 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} reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${busyTrust} ${bar} esc stops`;
+    const busyToken = formatTokenSegment(usageTotals, model, contextLoad);
+    // Goal segment (ticket 09): a guest in the fixed part — capped at 48
+    // chars and rendered only when the FULL activity text still fits beside
+    // it. Otherwise the goal drops whole and every existing segment renders
+    // exactly as with no goal (the goal never displaces, same precedent as
+    // the extension guest above). The clock, token, mode, and esc-hint
+    // segments never move for it either way.
+    const busyGoalSeg = fitGoalSegment(goal ?? null, 48);
+    const busyGoalCandidate = busyGoalSeg ? ` ${bar} ${busyGoalSeg}` : "";
+    const activityFull = activity ?? phaseLabel;
+    const busyCore = ` ${bar} ${elapsedSecs}s ${bar} ${busyToken} ${bar} reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${busyTrust}`;
+    const busyTail = ` ${bar} esc stops`;
+    const busyExtCandidate = hasExt && `${busyCore}${busyGoalCandidate}${busyTail}`.length + extensionStatus.length + 3 + 2 <= columns
+        ? ` ${bar} ${extensionStatus}`
+        : "";
+    const withGoalFixed = `${busyCore}${busyExtCandidate}${busyGoalCandidate}${busyTail}`;
+    // Room check against the unfitted activity text: when it no longer fits
+    // whole with the goal aboard, the goal yields (drop whole, recompute).
+    const busyGoalPart = busyGoalCandidate !== "" &&
+        withGoalFixed.length + activityFull.length + 2 <= columns
+        ? busyGoalCandidate
+        : "";
+    const busyNoExt = `${busyCore}${busyGoalPart}${busyTail}`;
+    const showBusyExt = hasExt && busyNoExt.length + extensionStatus.length + 3 + 2 <= columns;
+    const busyFixed = ` ${bar} ${elapsedSecs}s${showBusyExt ? ` ${bar} ${extensionStatus}` : ""} ${bar} ${busyToken} ${bar} reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${busyTrust}${busyGoalPart} ${bar} esc stops`;
     const busyAvail = columns - busyFixed.length - 2;
-    const activityText = shrinkTo(activity ?? phaseLabel, Math.max(0, busyAvail));
+    const activityText = shrinkTo(activityFull, 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/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,

package/dist/ui/transcript.js

@@ -1,39 +1,37 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 // Transcript leaves: the committed <Static> scrollback, its item renderer,
 // and the startup banner. Prop-driven + memoized (see comments) so App state
 // churn never repaints them. Turn is the display-transcript entry shape.
 // All paint comes from ui/theme tokens — no literal colors or glyphs here.
 import React from "react";
-import { Box, Text } from "ink";
+import { Box, Static, Text } from "ink";
 import { SideBySideDiffView, TRANSCRIPT_DIFF_MAX_LINES } from "./side-by-side.js";
 import { ErrorCard, classifyToolError } from "./errors.js";
 import { MarkdownText, ToolLine } from "./markdown.js";
 import { theme } from "./theme.js";
-// Scrollback viewport: the committed transcript renders as a windowed
-// slice of turns in a live Box (NOT <Static> — Static is append-only with
-// no scroll API, so PgUp/Home/follow modes are impossible on it).
+// Commit frontier model: the committed transcript prints to terminal
+// scrollback ONCE via <Static> and is never rewritten (this is what keeps
+// a full-page transcript from flashing on every keystroke — Ink takes a
+// clearTerminal + full-reprint path for fullscreen dynamic frames).
 //
-// Model: E = viewed end index (items visible: (E-WIN, E]). E === turns.length
-// means follow mode — new turns extend the view automatically. Any E < len
-// is manual mode: the view freezes while new turns accumulate below, and a
-// `↓ N new` indicator offers the jump back. Clamping makes list replacement
-// (/clear, /resume, /new) re-follow for free (E > len collapses to len).
-// Banner shows only when the window touches the top.
+// Model: E = committed end index (null = follow: commit everything). Any
+// E < len is manual mode — new turns accumulate below the frontier and a
+// `↓ N new` indicator offers the jump back. Printed output can never
+// retract, so E below the committed count holds back future commits only;
+// deep history lives in terminal scrollback. Banner shows on fresh mounts.
+// List replacement (/clear, /resume, /new, /rewind) bumps clearGen, which
+// resets the Static buffer via the identity below.
 export const SCROLLBACK_WINDOW = 300;
 export const SCROLL_PAGE_ITEMS = 10;
-export function resolveViewport(len, end, win = SCROLLBACK_WINDOW) {
-    const e = Math.max(0, Math.min(end ?? len, len));
-    const follow = e >= len;
-    return { start: Math.max(0, e - win), end: e, pending: len - e, follow };
-}
 export function applyScrollAction(end, len, action) {
     const e = end ?? len;
     switch (action.kind) {
         case "pageUp":
-            // Short sessions (everything fits the window) have no window to move:
-            // freeze at the bottom instead of no-op-ing, so PgUp always engages
-            // the held view (live output stops growing; the terminal stops
-            // yanking). Long sessions move the window up a page, as before.
+            // Freeze the commit frontier instead of no-op-ing, so PgUp always
+            // engages the held view (new output stops printing below; the live
+            // tail stops growing; the terminal stops yanking). Values below the
+            // already-committed count hold back future commits only — printed
+            // output lives in terminal scrollback and can never retract.
             if (len <= SCROLLBACK_WINDOW)
                 return len;
             return Math.max(Math.min(len, SCROLLBACK_WINDOW), e - SCROLL_PAGE_ITEMS);
@@ -84,30 +82,86 @@ export function renderTranscriptItem(item) {
 // Render-count probe for the timer-isolation test: incremented on every
 // TranscriptView render (a 1s timer tick must leave it unchanged).
 export const transcriptRenderProbe = { count: 0 };
-export const TranscriptView = React.memo(function TranscriptView({ turns, clearGen, renderItem, end, windowSize, held, showThinking = true, }) {
-    transcriptRenderProbe.count += 1;
-    const render = renderItem ?? renderTranscriptItem;
-    const win = windowSize ?? SCROLLBACK_WINDOW;
-    const vp = resolveViewport(turns.length, end, win);
-    // Pairing ([audit label, error detail] → one card) runs over the VISIBLE
-    // slice only — pairing is positional, and off-window turns never mount.
-    // Keys stay global (`turn-${idx}`) so scrolling never remounts rows.
-    // Hidden thinking turns are skipped in place (same index stability).
-    const body = [];
-    for (let idx = vp.start; idx < vp.end; idx++) {
+// Render-count probe for row isolation: incremented per mounted row paint
+// (appending one turn must paint exactly one new row, never the window).
+export const transcriptRowRenderProbe = { count: 0 };
+// Committed turns are immutable once appended (diffs attach pre-commit in
+// onToolActivity, never post-append), and keys stay global (`turn-${idx}`),
+// so a row whose item identity is unchanged can skip rendering entirely.
+// Custom compare: the body array is rebuilt per TranscriptView render with
+// fresh wrappers around the SAME turn refs — shallow compare would always
+// miss, hence id + turn/label identity. An unstable render fn falls back to
+// today's behavior (re-render) rather than going stale.
+function transcriptRowEqual(a, b) {
+    return (a.render === b.render &&
+        a.item.id === b.item.id &&
+        a.item.turn === b.item.turn &&
+        a.item.label === b.item.label);
+}
+const TranscriptRow = React.memo(function TranscriptRow({ item, render }) {
+    transcriptRowRenderProbe.count += 1;
+    return _jsx(React.Fragment, { children: render(item) });
+}, transcriptRowEqual);
+// Monotonic static admission: convert record turns [from, to) into Static
+// items, pairing adjacent [audit label, error detail] within the batch and
+// permanently skipping hidden thinking turns. ALWAYS returns next ===
+// clamped `to` (even when everything skips) so the frontier only moves
+// forward — shrinking or reordering same-identity items would misalign
+// Ink's append-only Static buffer and duplicate terminal scrollback.
+// List replacements (/clear, /resume, /rewind) bump clearGen instead, which
+// resets the buffer via the Static identity below.
+export function admitStaticBatch(turns, from, to, showThinking) {
+    const end = Math.max(from, Math.min(to, turns.length));
+    const items = [];
+    let idx = from;
+    while (idx < end) {
         const turn = turns[idx];
-        if (turn.thinking === true && !showThinking)
+        if (turn.thinking === true && !showThinking) {
+            idx += 1;
             continue;
-        const next = idx + 1 < vp.end ? turns[idx + 1] : undefined;
+        }
+        const next = idx + 1 < end ? turns[idx + 1] : undefined;
         if (isAuditLabel(turn) && next !== undefined && next.role === "tool" && next.error === true) {
-            body.push({ id: `turn-${idx}`, turn: next, label: turn });
-            idx += 1;
+            items.push({ id: `turn-${idx}`, turn: next, label: turn });
+            idx += 2;
             continue;
         }
-        body.push({ id: `turn-${idx}`, turn });
+        items.push({ id: `turn-${idx}`, turn });
+        idx += 1;
+    }
+    return { items, next: end };
+}
+export const TranscriptView = React.memo(function TranscriptView({ turns, clearGen, renderItem, end, held, showThinking = true, }) {
+    transcriptRenderProbe.count += 1;
+    const render = renderItem ?? renderTranscriptItem;
+    const frontier = end ?? turns.length;
+    // Committed static state: full reset on clearGen (list replacements bump
+    // it — replacements must never reuse the buffer), suffix-only advance
+    // otherwise (setState-during-render derived-state pattern; the extra pass
+    // runs only when genuinely new items commit, never on ticks/keystrokes).
+    const [committed, setCommitted] = React.useState(() => {
+        const base = clearGen === 0 ? [{ id: "banner" }] : [];
+        const batch = admitStaticBatch(turns, 0, frontier, showThinking);
+        return { gen: clearGen, items: [...base, ...batch.items], next: batch.next };
+    });
+    if (committed.gen !== clearGen) {
+        const base = clearGen === 0 ? [{ id: "banner" }] : [];
+        const batch = admitStaticBatch(turns, 0, end ?? turns.length, showThinking);
+        setCommitted({ gen: clearGen, items: [...base, ...batch.items], next: batch.next });
+    }
+    else {
+        const batch = admitStaticBatch(turns, committed.next, frontier, showThinking);
+        if (batch.items.length > 0 || batch.next !== committed.next) {
+            setCommitted({
+                gen: clearGen,
+                items: [...committed.items, ...batch.items],
+                next: batch.next,
+            });
+        }
     }
-    const items = clearGen === 0 && vp.start === 0 ? [{ id: "banner" }, ...body] : body;
-    return (_jsxs(Box, { flexDirection: "column", children: [items.map((item) => (_jsx(React.Fragment, { children: render(item) }, item.id))), vp.pending > 0 ? (_jsxs(Text, { dimColor: true, children: ["\u2193 ", vp.pending, " new \u2014 End for latest"] })) : held ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 End to follow"] })) : null] }));
+    // Backlog below the committed frontier (frozen appends, not yet printed).
+    const pending = turns.length - committed.next;
+    return (_jsxs(_Fragment, { children: [_jsx(Static, { items: committed.items, children: (item) => _jsx(TranscriptRow, { item: item, render: render }, item.id) }, clearGen), pending > 0 ? (_jsxs(Text, { dimColor: true, children: ["\u2193 ", pending, " new \u2014 End for latest"] })) : held ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 End to follow"] })) : null] }));
 });
 // Startup banner: the ATOM block-letter art, rendered once at launch inside
 // <Static> (scrollback, so it scrolls away naturally). FIGlet "ANSI Shadow"