atom-agent 1.0.0 → 1.1.0

package/dist/App.js

@@ -1,13 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Ink (React) TUI for the minimal Atom chatbot.
 // Hand-rolled input + dropdowns via useInput (no extra deps).
+import * as fs from "node:fs";
 import * as os from "node:os";
-import React, { useEffect, useRef, useState } from "react";
+import * as path from "node:path";
+import React, { useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useApp, useInput, usePaste, useStdout } from "ink";
 import { DEFAULT_MODEL, EFFORT_OPTIONS, FALLBACK_MODELS, LoopCancelledError, REASONING_EFFORT_SUPPORTED_MODELS, buildSystemPrompt, fetchModelsForProviderWithStatus, fetchModelsWithStatus, historyChars, isEffortSupported, messageChars, openTodoNeedles, runAgenticLoopForProvider, } from "./zen.js";
 import { createContextManager, trackHistory, } from "./context-manager.js";
 import { assemblePrefix, providerCacheSupport, } from "./prompt-cache.js";
-import { TOOL_DEFINITIONS, TOOL_ONE_LINERS, clearTodos, describeToolCall, executeTool, getTodos, needsApproval, providerSecrets } from "./tools.js";
+import { TOOL_DEFINITIONS, TOOL_ONE_LINERS, APPROVAL_PREVIEW_MAX_BYTES, clearTodos, describeToolCall, executeTool, getTodos, needsApproval, previewDiffForApproval, providerSecrets } from "./tools.js";
 import { classifyTurnOutcome, createTelemetryRecorder, loadTelemetrySessions, resolveTelemetryEnabled, summarizeTelemetry, telemetryDir, } from "./telemetry.js";
 import { writeTelemetryDashboard } from "./telemetry-dashboard.js";
 import { formatRules, parseRuleInput, } from "./permissions.js";
@@ -48,7 +50,7 @@ export const SLASH_COMMANDS = [
         name: "/effort",
         description: "Open the reasoning-effort picker (Default/Low/Medium/High/Max; top is Max, sent as max).",
     },
-    { name: "/tools", description: "List the 7 tools with one-line descriptions." },
+    { name: "/tools", description: "List the tools with one-line descriptions." },
     { name: "/skills", description: "List installed skills (project + global)." },
     { name: "/skill", description: "Invoke a skill by name (/skill:name; /skills lists)." },
     { name: "/mode", description: "Print the current permission mode (Tab cycles normal → yolo → plan)." },
@@ -62,6 +64,8 @@ export const SLASH_COMMANDS = [
     { name: "/context", description: "Show context usage by source (system, tools, history, skills)." },
     { name: "/queue", description: "List queued follow-ups (/queue clear wipes them)." },
     { name: "/steer", description: "Steer the running turn, or send when idle (/steer <text>)." },
+    { name: "/autoscroll", description: "Follow new output as it arrives (/autoscroll on|off; off freezes the view mid-turn)." },
+    { name: "/thinking", description: "Show or hide model thinking in the TUI (rendering only; the turn is untouched)." },
     { name: "/resume", description: "Restore the last saved session (turns, history, settings, usage)." },
     { name: "/telemetry", description: "Show the local observability summary (sessions, tokens, tools)." },
     { name: "/dashboard", description: "Write the local observability dashboard page and show its path." },
@@ -106,8 +110,18 @@ export const SKILL_USAGE = "usage: /skill:<name> — invoke a skill directly (li
 export const RULE_USAGE = "usage: /allow <tool[:glob]> · /deny <tool[:glob]> · /rules · /rules clear (e.g. /allow bash:npm test*, /deny bash:rm *)";
 export const QUEUE_USAGE = "usage: /queue (list) · /queue clear (wipe) · /steer <text> (steer the running turn, or send when idle)";
 export const STEER_USAGE = "usage: /steer <text> — while busy, injects into the running turn at the next step boundary (the current action finishes first); when idle, sends as a normal turn";
+export const AUTOSCROLL_USAGE = "usage: /autoscroll [on|off] — on (default) follows new output as it arrives; off freezes the view while a turn runs (a `↓ N new` indicator offers the jump back). Bare /autoscroll prints the current state.";
+export const THINKING_USAGE = "usage: /thinking — toggles model-thinking visibility in the TUI (rendering only: shows or hides the committed thinking blocks; the turn, history, and telemetry are untouched).";
 export function filterSlashCommands(prefix) {
     const q = prefix.startsWith("/") ? prefix.slice(1) : prefix;
+    // Exact match wins outright: a fully-typed command collapses the menu
+    // to itself, so prefix-siblings (/skill vs /skills, /model vs /models)
+    // never read as duplicates and Enter stays deterministic. Partial
+    // input keeps the prefix-then-fuzzy tiers below untouched.
+    const full = `/${q}`;
+    const exact = SLASH_COMMANDS.find((c) => c.name === full);
+    if (exact)
+        return [exact];
     const pre = [];
     const fuzzy = [];
     for (const c of SLASH_COMMANDS) {
@@ -163,10 +177,15 @@ export function paletteEntries(query) {
     }));
 }
 // Busy-gate shared by the slash menu and the palette: /compact sets the
-// pending flag for turn-end drain; /queue + /steer manage the running turn.
+// pending flag for turn-end drain; /queue + /steer manage the running turn;
+// /autoscroll and /thinking only flip view flags (never touch the turn).
 // Every other command waits idle.
 export function slashRunsWhileBusy(name) {
-    return name === "/compact" || name === "/queue" || name === "/steer";
+    return (name === "/compact" ||
+        name === "/queue" ||
+        name === "/steer" ||
+        name === "/autoscroll" ||
+        name === "/thinking");
 }
 // Fuzzy subsequence match with gap/start/word-boundary scoring (lower is
 // better; null = no match). Pure — shared by the command filter, the skill
@@ -816,6 +835,26 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         scrollEndRef.current = next;
         setScrollEnd(next);
     }
+    // Thinking visibility (the /thinking toggle, rendering-only, default
+    // hidden): committed thinking turns + the live thinking block show only
+    // while on. Never touches the turn, history, or telemetry — purely paint.
+    const [showThinking, setShowThinking] = useState(false);
+    const showThinkingRef = useRef(false);
+    function setShowThinkingBoth(next) {
+        showThinkingRef.current = next;
+        setShowThinking(next);
+    }
+    // /autoscroll (session-only, default on). On = today's behavior: a
+    // following view extends with every appended turn. Off = appends during a
+    // busy turn freeze a following view at its current end instead of yanking
+    // it (the `↓ N new` indicator offers the jump back; End resumes). Idle
+    // appends always follow — freezing only matters while output streams.
+    const [autoScroll, setAutoScroll] = useState(true);
+    const autoScrollRef = useRef(true);
+    function setAutoScrollBoth(next) {
+        autoScrollRef.current = next;
+        setAutoScroll(next);
+    }
     // Skill registry (cached metadata): one instance per App, scoped to the
     // same dirs the suite injects via skillDirs. Every discovery path below
     // reads through it — refresh() revalidates by stat (mtime+size) and only
@@ -840,6 +879,34 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             // menu keeps its previous snapshot (a hiccup must never break input)
         }
     }
+    // Pending transcript diff (display-only): the approve-time write/edit
+    // preview plus full-file BEFORE/AFTER capture, held for the matching
+    // onToolActivity commit. Single slot is exact — the scheduler never
+    // parallel-batches writes (writes conflict globally; parallel members
+    // never prompt), and every execution commits exactly one activity entry
+    // in call order. Lifetime ⊆ one turn: set in approve(),
+    // consumed-or-cleared by the matching activity, and cleared on
+    // deny/cancel/turn boundaries so a stale preview can never attach to
+    // a later call.
+    // - write: BEFORE reuses the preview's pre-read; AFTER is the new
+    //   content arg (exactly what the tool writes) — zero extra reads.
+    // - edit: BEFORE is a best-effort full-file read here (pre-execution);
+    //   AFTER is read at commit time. Two reads, each once, never in render.
+    const pendingDiffRef = useRef(null);
+    // Best-effort full-file read for diff capture: null on missing dir,
+    // oversize, or any I/O failure. Never throws — capture degrades to the
+    // arg-block preview pair instead of breaking approval.
+    function readFileForDiff(absPath) {
+        try {
+            const st = fs.statSync(absPath);
+            if (!st.isFile() || st.size > APPROVAL_PREVIEW_MAX_BYTES)
+                return null;
+            return fs.readFileSync(absPath, "utf8");
+        }
+        catch {
+            return null;
+        }
+    }
     // Tool approval prompt (normal mode, write/edit/bash): the loop waits on
     // the resolver until the user presses y/a/n. Ctrl+C aborts the whole turn
     // (LoopCancelledError) instead of denying one call.
@@ -941,10 +1008,28 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // tool name before its execution line lands.
     const [draft, setDraft] = useState(null);
     // Thinking channel (onThinking): reasoning text streamed apart from the
-    // answer, rendered in its own dim block below. Transient like `draft` —
-    // cleared on every turn boundary below — and never committed to the
-    // transcript or the model history.
+    // answer, rendered in its own dim block below. The live value is transient
+    // like `draft` — cleared on every turn boundary below — but each completed
+    // round commits to the transcript via commitThinking (stays in the TUI,
+    // never the model history) instead of being replaced and lost.
     const [thinking, setThinking] = useState(null);
+    const thinkingRef = useRef(null);
+    // Move the accumulated round thinking into the transcript as a quiet
+    // annotation turn (no-op when empty). Called when a new POST starts and at
+    // turn end, so every round's reasoning stays visible; the /thinking toggle
+    // only controls rendering, never this record.
+    function commitThinking() {
+        const text = thinkingRef.current;
+        thinkingRef.current = null;
+        setThinking(null);
+        if (typeof text === "string" && text.length > 0) {
+            appendTurns({ role: "assistant", content: text, thinking: true });
+        }
+    }
+    function clearThinking() {
+        thinkingRef.current = null;
+        setThinking(null);
+    }
     const [phase, setPhase] = useState("idle");
     const [phaseDetail, setPhaseDetail] = useState("");
     const [toolHint, setToolHint] = useState(null);
@@ -1552,6 +1637,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setTurns(next);
     }
     function appendTurns(...items) {
+        // Autoscroll off + busy + following: freeze the view at its current end
+        // BEFORE appending, so streaming output accumulates below instead of
+        // yanking the viewport (smooth-scroll hold). Idle appends and already-
+        // held views pass through untouched.
+        if (!autoScrollRef.current && busyRef.current && scrollEndRef.current === null) {
+            setScrollEndBoth(turnsRef.current.length);
+        }
         const next = [...turnsRef.current, ...items];
         turnsRef.current = next;
         setTurns(next);
@@ -1729,7 +1821,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // Snapshot the committed session (historyRef + turnsRef + settings refs)
     // to ~/.atom/session.json. Disk errors are ignored (in-memory session
     // still applies). Called only for committed state: completed turns and
-    // clean exit — never for rolled-back (failed/cancelled) turns.
+    // clean exit — never for rolled-back (failed/cancelled) turns. The
+    // committed diff previews (Turn.diff) are display-only and never saved:
+    // they can hold whole file contents (bloat) and would render stale
+    // after later edits, so /resume restores label-only turns.
     function persistSession() {
         try {
             saveSession({
@@ -1739,7 +1834,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 mode: modeRef.current,
                 usageTotals: usageRef.current,
                 history: historyRef.current,
-                turns: turnsRef.current,
+                turns: turnsRef.current.map((t) => {
+                    const { diff: _dropped, ...rest } = t;
+                    return rest;
+                }),
             }, authHome);
         }
         catch {
@@ -2209,6 +2307,58 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         }
         pushInfo(QUEUE_USAGE);
     }
+    // /thinking: rendering-only visibility toggle for model thinking (both
+    // the committed transcript blocks and the live thinking block). Pure
+    // paint — safe while busy (never touches the turn, like /autoscroll).
+    // Bare toggles; anything appended prints usage (there are no arguments).
+    function runThinkingCommand(raw) {
+        if (raw.trim() !== "/thinking") {
+            pushInfo(THINKING_USAGE);
+            return;
+        }
+        const next = !showThinkingRef.current;
+        setShowThinkingBoth(next);
+        pushInfo(next
+            ? "(thinking shown — model reasoning stays visible in the transcript)"
+            : "(thinking hidden — reasoning still runs, it just isn't rendered)");
+    }
+    // /autoscroll [on|off]: follow switch for the scrollback viewport. View-
+    // only state — safe while busy (never touches the turn, like /queue).
+    // Bare prints the state; on jumps to the latest; off freezes a following
+    // view at its current end (mid-turn appends then accumulate below).
+    function runAutoScrollCommand(raw) {
+        const arg = raw.trim() === "/autoscroll" ? "" : raw.trim().slice("/autoscroll".length).trim().toLowerCase();
+        if (arg === "") {
+            pushInfo(autoScrollRef.current
+                ? "(autoscroll on — following new output as it arrives)"
+                : "(autoscroll off — the view freezes while a turn runs; End follows the latest)");
+            return;
+        }
+        if (arg === "on") {
+            if (autoScrollRef.current) {
+                pushInfo("(autoscroll already on)");
+                return;
+            }
+            setAutoScrollBoth(true);
+            setScrollEndBoth(null);
+            pushInfo("(autoscroll on — following the latest)");
+            return;
+        }
+        if (arg === "off") {
+            if (!autoScrollRef.current) {
+                pushInfo("(autoscroll already off)");
+                return;
+            }
+            // Confirm FIRST while still following (visible), then flip the switch:
+            // flipping first would freeze this very confirm below the viewport
+            // (appendTurns freezes busy appends once off). Already-held views stay
+            // held; the next busy append freezes a following view via appendTurns.
+            pushInfo("(autoscroll off — the view freezes while a turn runs; End follows the latest)");
+            setAutoScrollBoth(false);
+            return;
+        }
+        pushInfo(AUTOSCROLL_USAGE);
+    }
     // /models: local-discovery status + refresh. Bare `/models` reports the
     // last snapshot (kicking a first probe when discovery never ran);
     // `/models refresh` re-probes all three runtimes, then reports. Results
@@ -2275,7 +2425,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 setClearGen((g) => g + 1);
                 setError(null);
                 setDraft(null);
-                setThinking(null);
+                clearThinking();
                 setToolHint(null);
                 setPhase("idle");
                 setPhaseDetail("");
@@ -2326,7 +2476,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 setClearGen((g) => g + 1);
                 setError(null);
                 setDraft(null);
-                setThinking(null);
+                clearThinking();
                 setToolHint(null);
                 setPhase("idle");
                 setPhaseDetail("");
@@ -2412,6 +2562,12 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             case "/steer":
                 runQueueCommand("/steer");
                 return;
+            case "/thinking":
+                runThinkingCommand("/thinking");
+                return;
+            case "/autoscroll":
+                runAutoScrollCommand("/autoscroll");
+                return;
             case "/mode":
                 if (modeRef.current === "plan") {
                     pushInfo("mode: plan (read-only — write/edit/bash blocked with a replan note; Tab to approve + exit)");
@@ -2503,6 +2659,25 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     async function approve(name, args) {
         if (turnCancelRef.current?.signal.aborted)
             throw new LoopCancelledError();
+        // Stage the transcript-diff preview for write/edit (all outcomes):
+        // the modal below reuses it, and onToolActivity consumes it when the
+        // matching execution commits. Deny/cancel paths clear it (execution
+        // never happens, so nothing must linger for a later call). Full-file
+        // BEFORE is captured here (pre-execution); AFTER resolves at commit
+        // (write content arg, or a post-execution disk read for edit).
+        const stagedDiff = name === "write" || name === "edit" ? previewDiffForApproval(name, args) : null;
+        if (name === "write" || name === "edit") {
+            const toolPath = typeof args["path"] === "string" ? args["path"] : null;
+            const beforeFull = name === "write"
+                ? (stagedDiff?.oldText ?? null) // preview already pre-read it: no second read
+                : toolPath !== null
+                    ? readFileForDiff(path.resolve(process.cwd(), toolPath))
+                    : null;
+            const afterArg = name === "write" && typeof args["content"] === "string"
+                ? args["content"]
+                : null;
+            pendingDiffRef.current = { name, path: toolPath, beforeFull, afterArg, diff: stagedDiff };
+        }
         // Policy layer owns the decision order (deny → plan → allow → yolo →
         // trust → always → skill grants → prompt); this function owns cancel
         // handling and the interactive prompt plumbing around it.
@@ -2514,22 +2689,27 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             skillGrants: skillGrantsRef.current,
             approvalGated: needsApproval(name),
         });
-        if (outcome.kind === "deny")
+        if (outcome.kind === "deny") {
+            pendingDiffRef.current = null;
             return "no";
+        }
         if (outcome.kind === "allow")
             return "once";
         const signal = turnCancelRef.current?.signal ?? null;
-        if (signal?.aborted)
+        if (signal?.aborted) {
+            pendingDiffRef.current = null;
             throw new LoopCancelledError();
+        }
         return new Promise((resolve, reject) => {
             approvalResolveRef.current = { resolve, reject };
             setApproveIndexBoth(0);
-            setPendingApproval({ name, args });
+            setPendingApproval({ name, args, diff: stagedDiff });
             if (signal) {
                 const onAbort = () => {
                     const h = approvalResolveRef.current;
                     approvalResolveRef.current = null;
                     setPendingApproval(null);
+                    pendingDiffRef.current = null;
                     h?.reject(new LoopCancelledError());
                 };
                 if (signal.aborted)
@@ -2543,6 +2723,8 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         if (decision === "always" && pendingApproval) {
             alwaysAllowedRef.current.add(pendingApproval.name);
         }
+        if (decision === "no")
+            pendingDiffRef.current = null;
         const h = approvalResolveRef.current;
         approvalResolveRef.current = null;
         setPendingApproval(null);
@@ -2651,6 +2833,17 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 runQueueCommand(text);
                 return;
             }
+            // /autoscroll and /thinking are view-only state (never touch the
+            // turn), so they run while busy like /queue + /steer (see
+            // slashRunsWhileBusy).
+            if (text === "/autoscroll" || text.startsWith("/autoscroll ")) {
+                runAutoScrollCommand(text);
+                return;
+            }
+            if (text === "/thinking" || text.startsWith("/thinking ")) {
+                runThinkingCommand(text);
+                return;
+            }
             if (text.startsWith("/"))
                 return;
             if (queueRef.current.length >= QUEUE_CAP) {
@@ -2667,6 +2860,17 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             runQueueCommand(text);
             return;
         }
+        // /autoscroll takes an optional subcommand (/autoscroll on|off), like the
+        // /queue family — SLASH_NAMES only holds the exact command. /thinking
+        // is bare-toggle-only; anything appended prints its usage.
+        if (text === "/autoscroll" || text.startsWith("/autoscroll ")) {
+            runAutoScrollCommand(text);
+            return;
+        }
+        if (text === "/thinking" || text.startsWith("/thinking ")) {
+            runThinkingCommand(text);
+            return;
+        }
         // Scoped rules (ticket 03): exact or free-text forms (/allow bash:x,
         // /rules clear) route with args intact — SLASH_NAMES only holds exact
         // commands, and the skill fallback below must not swallow these.
@@ -2731,7 +2935,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setBusy(true);
         setError(null);
         setDraft(null);
-        setThinking(null);
+        clearThinking();
         // Fresh turn, fresh latch: the queue drain at the end auto-sends only
         // when this turn was NOT cancelled (see the turn-end finally).
         turnCancelledRef.current = false;
@@ -2753,6 +2957,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         // Display-only tool clock: no tool is running at turn start, so any
         // stale timestamp from a previous turn must not leak into this one.
         toolStartRef.current = null;
+        // Same for the transcript-diff slot: a previous turn's unconsumed
+        // preview (cancelled mid-execution) must never attach to this turn.
+        pendingDiffRef.current = null;
         lastPartialRef.current = "";
         refreshGitInfo();
         // SUBMIT STAGE 2/4 — context-assembly (rollback scope: pre-rollbackTo,
@@ -2833,6 +3040,11 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 // Local observability sink: the loop reports completed model/tool
                 // calls (iterations, durations, usage) into the open turn trace.
                 telemetry: telemetrySink,
+                // Loop-harness rollup: per-turn LoopStats (cache hits, guard hits,
+                // bottleneck, context growth) attach to the same open turn trace.
+                // Fires once per turn — including failed/cancelled turns, whose
+                // endTurn below still records the outcome alongside these stats.
+                onLoopStats: (s) => telemetry.recordLoopStats(telemetryTurnId, s),
                 // Plan-mode read-only gate (ticket 04): mutations are refused here
                 // with a replan note; every other tool delegates to executeTool.
                 execute: guardedExecute,
@@ -2850,6 +3062,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     noteTurnActivity();
                 },
                 onThinking: (partial) => {
+                    thinkingRef.current = partial;
                     setThinking(partial);
                     noteTurnActivity();
                 },
@@ -2858,8 +3071,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     setPhaseDetail(detail ?? "");
                     noteTurnActivity();
                     if (p === "thinking") {
-                        // New POST: its thinking (if any) replaces the previous round's.
-                        setThinking(null);
+                        // New POST: the previous round's thinking (if any) commits to
+                        // the transcript so it stays in the TUI instead of being
+                        // replaced and lost; the fresh round streams into the live block.
+                        commitThinking();
                     }
                     else if (p === "tool" && detail) {
                         setToolHint(detail);
@@ -2963,6 +3178,40 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     else if (isTodo) {
                         items.push({ role: "tool", content: result });
                     }
+                    // Committed transcript diff: the approve-time capture for this
+                    // exact execution rides on the label turn. Consume-or-clear on
+                    // every matching activity (success or failure) so a stale
+                    // capture can never leak onto a later call; render only on
+                    // success with a real payload (failures keep the ↳ line only).
+                    // Full-file BEFORE→AFTER is preferred (aligned panes with
+                    // context); when either side is unavailable (unreadable file,
+                    // oversize), fall back to the arg-block preview pair.
+                    const slot = pendingDiffRef.current;
+                    if (slot !== null &&
+                        (label === `⚙ ${slot.name}` || label.startsWith(`⚙ ${slot.name} `))) {
+                        pendingDiffRef.current = null;
+                        if (!isError) {
+                            let afterFull = null;
+                            if (slot.name === "write") {
+                                afterFull = slot.afterArg;
+                            }
+                            else if (slot.path !== null) {
+                                afterFull = readFileForDiff(path.resolve(process.cwd(), slot.path));
+                            }
+                            const beforeFull = slot.beforeFull;
+                            if (beforeFull !== null && afterFull !== null) {
+                                items[0].diff = {
+                                    oldText: beforeFull,
+                                    newText: afterFull,
+                                    lang: slot.diff?.lang ?? null,
+                                    path: slot.path,
+                                };
+                            }
+                            else if (slot.diff !== null) {
+                                items[0].diff = slot.diff;
+                            }
+                        }
+                    }
                     appendTurns(...items);
                     noteTurnActivity();
                 },
@@ -2975,8 +3224,11 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 },
             });
             // Turn-end flush: any trailing throttled partial paints before the
-            // commit replaces the draft (byte-exact via `reply` regardless).
+            // commit replaces the draft (byte-exact via `reply` regardless). The
+            // final round's thinking commits first (chronological: reasoning, then
+            // the answer it produced).
             flushDraft();
+            commitThinking();
             appendTurns({ role: "assistant", content: reply });
             // The turn committed to history (final text, denial-as-result, or
             // stop-notice) — persist the kill-safe save. Rolled-back turns (catch
@@ -3015,6 +3267,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 controller.signal.aborted;
             historyRef.current.splice(rollbackTo); // don't keep the failed/cancelled turn
             turnCancelledRef.current = cancelled;
+            // The turn never happened: drop live thinking with it (a failed turn
+            // commits nothing — same scope as the history rollback above).
+            clearThinking();
             // Local observability: failed/cancelled turns still record what was
             // attempted (model/tool calls so far) with their outcome, then flush.
             // Like the save above, the telemetry file only ever gains completed
@@ -3066,6 +3321,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             turnCancelRef.current = null;
             approvalResolveRef.current = null;
             setPendingApproval(null);
+            // Safety net: the slot is normally consumed by onToolActivity or
+            // cleared on deny/cancel — never let it cross a turn boundary.
+            pendingDiffRef.current = null;
             askResolveRef.current = null;
             setPendingQuestion(null);
             setAskCustomBoth("");
@@ -3083,7 +3341,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 // ignore
             }
             setDraft(null);
-            setThinking(null);
+            clearThinking();
             setToolHint(null);
             clearTurnTimer();
             setStalled(false);
@@ -3599,7 +3857,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
             else if (key.return || key.tab) {
                 const pick = matches[slashIndexRef.current % matches.length];
-                // /compact, /queue, and /steer run while busy (see
+                // /compact, /queue, /steer, and /autoscroll run while busy (see
                 // slashRunsWhileBusy); every other entry still waits idle.
                 if (pick && (slashRunsWhileBusy(pick.name) || !busyRef.current)) {
                     if (pick.skill) {
@@ -3623,6 +3881,14 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                         setInputBoth("");
                         void runCompactCommand(focus);
                     }
+                    else if (pick.name === "/autoscroll" &&
+                        (inputRef.current === "/autoscroll" || inputRef.current.startsWith("/autoscroll "))) {
+                        // Preserve the on/off arg when the menu is open on a prefix
+                        // (bare highlighted name alone would drop it).
+                        const raw = inputRef.current;
+                        setInputBoth("");
+                        runAutoScrollCommand(raw);
+                    }
                     else if ((pick.name === "/allow" || pick.name === "/deny" || pick.name === "/rules") &&
                         inputRef.current.startsWith(pick.name)) {
                         // Preserve the typed rule args (e.g. "/allow bash:npm test*");
@@ -3957,6 +4223,14 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     const skillTitle = `Skills (${skillEntries.length}` +
         (skillFilter ? ` of ${skillEntriesAll.length}, filter: "${skillFilter}"` : "") +
         `) — type to filter, up/down + Enter, Esc cancels:`;
+    // Memoized render derivations (flicker fix): these rebuild arrays on every
+    // App render (token paints, keystrokes, 1s ticks), which defeats the memo
+    // on the leaf panels below. Memoized, the leaves skip everything but real
+    // changes. Checkpoint listing reads the snapshot dir — never per frame.
+    const paletteEntriesMemo = useMemo(() => (paletteOpen ? paletteEntries(paletteFilter) : []), [paletteOpen, paletteFilter]);
+    const checkpointListMemo = useMemo(() => (selectingRewind ? listCheckpoints() : []), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [selectingRewind]);
     // (The cursor clamp lives inside the memoized InputBox now, next to its
     // only use — App body no longer reads cursor state for paint.)
     // Status-line reasoning segment wired to the effort session state:
@@ -3977,7 +4251,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     const toolElapsedSecs = busy && toolHint && toolStartRef.current !== null
         ? elapsedSecsSince(toolStartRef.current, turnStartRef.current + elapsedSecs * 1000)
         : null;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TranscriptView, { turns: turns, clearGen: clearGen, end: scrollEnd, held: scrollEnd !== null }), _jsx(LiveTail, { isEmpty: turns.length === 0, sessionHint: sessionHint, draft: draft, thinking: thinking, busy: busy, held: scrollEnd !== null, toolHint: toolHint, toolElapsedSecs: toolElapsedSecs, elapsedSecs: elapsedSecs }), error ? _jsxs(Text, { color: theme.color.error, children: ["error> ", error] }) : null, pendingApproval ? (_jsx(ApprovalBox, { toolName: pendingApproval.name, description: describeToolCall(pendingApproval.name, pendingApproval.args), selected: approveIndex })) : null, pendingQuestion ? (_jsx(QuestionBox, { question: pendingQuestion.question, options: pendingQuestion.options, allowCustom: pendingQuestion.allowCustom, askCustom: askCustom, askSelIndex: askSelIndex })) : null, _jsx(TodoPanel, { items: todoSnap }), steerPending ? _jsxs(Text, { dimColor: true, children: ["Steering: ", steerPending] }) : null, queue.length > 0 ? (_jsxs(Text, { dimColor: true, children: ["Queued (", queue.length, "): ", queue[0], queue.length > 1 ? ` +${queue.length - 1} more (/queue)` : ""] })) : null, paletteOpen ? (_jsx(PalettePanel, { entries: paletteEntries(paletteFilter), index: paletteIndex, filter: paletteFilter })) : inspecting ? (_jsx(InspectorPanel, { records: toolLogRef.current, index: inspectIndex, expanded: inspectExpanded, scroll: inspectScroll })) : selecting ? (_jsxs(PickerShell, { title: modelTitle, children: [_jsx(PickerMoreAbove, { count: modelWin.start }), modelEntries.slice(modelWin.start, modelWin.end).map((e, k) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TranscriptView, { turns: turns, clearGen: clearGen, end: scrollEnd, held: scrollEnd !== null, showThinking: showThinking }), _jsx(LiveTail, { isEmpty: turns.length === 0, sessionHint: sessionHint, draft: draft, thinking: thinking, busy: busy, held: scrollEnd !== null, toolHint: toolHint, toolElapsedSecs: toolElapsedSecs, elapsedSecs: elapsedSecs, showThinking: showThinking }), error ? _jsxs(Text, { color: theme.color.error, children: ["error> ", error] }) : null, pendingApproval ? (_jsx(ApprovalBox, { toolName: pendingApproval.name, description: describeToolCall(pendingApproval.name, pendingApproval.args), selected: approveIndex, diff: pendingApproval.diff ?? null })) : null, pendingQuestion ? (_jsx(QuestionBox, { question: pendingQuestion.question, options: pendingQuestion.options, allowCustom: pendingQuestion.allowCustom, askCustom: askCustom, askSelIndex: askSelIndex })) : null, _jsx(TodoPanel, { items: todoSnap }), steerPending ? _jsxs(Text, { dimColor: true, children: ["Steering: ", steerPending] }) : null, queue.length > 0 ? (_jsxs(Text, { dimColor: true, children: ["Queued (", queue.length, "): ", queue[0], queue.length > 1 ? ` +${queue.length - 1} more (/queue)` : ""] })) : null, paletteOpen ? (_jsx(PalettePanel, { entries: paletteEntriesMemo, index: paletteIndex, filter: paletteFilter })) : inspecting ? (_jsx(InspectorPanel, { records: toolLogRef.current, index: inspectIndex, expanded: inspectExpanded, scroll: inspectScroll })) : selecting ? (_jsxs(PickerShell, { title: modelTitle, children: [_jsx(PickerMoreAbove, { count: modelWin.start }), modelEntries.slice(modelWin.start, modelWin.end).map((e, k) => {
                         const i = modelWin.start + k;
                         const entryLocal = e.local === true;
                         const prevLocal = i === 0 ? null : modelEntries[i - 1]?.local === true;
@@ -4002,7 +4276,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                                 ? `${theme.symbol.descSeparator} key optional — free models need none`
                                 : `${theme.symbol.descSeparator} no key`;
                     return (_jsxs(PickerRow, { highlighted: i === providerIndex, children: [p.name, " (", p.id, ") ", keyMark, p.id === provider ? " (current)" : ""] }, p.id));
-                }) })) : keyPrompt ? (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.picker, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { bold: true, children: ["Atom \u2014 API key for ", keyPrompt.providerId, " (paste + Enter, Esc cancels):"] }), keyPrompt.consoleURL ? (_jsxs(Text, { dimColor: true, children: ["Get a key: ", keyPrompt.consoleURL] })) : null, keyPrompt.existingMasked ? (_jsxs(Text, { dimColor: true, children: ["key on file (", keyPrompt.existingMasked, ") \u2014 type a new key to replace, Esc keeps + switches"] })) : (_jsx(Text, { dimColor: true, children: "No key on file \u2014 paste once, validated then stored in ~/.atom/auth.json" })), keyPrompt.providerId === "kilo" ? (_jsx(Text, { dimColor: true, children: "Optional: free models work without a key \u2014 empty Enter continues anonymously" })) : null, _jsxs(Text, { children: ["key: ", theme.symbol.keyMask.repeat(keyPrompt.draft.length), _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBlock })] }), keyPrompt.validating ? _jsxs(Text, { dimColor: true, children: ["validating", theme.symbol.ellipsis] }) : null, keyPrompt.error ? _jsx(Text, { color: theme.color.error, children: keyPrompt.error }) : null] })) : baseURLPrompt ? (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.picker, paddingX: theme.spacing.pickerPadX, children: [_jsx(Text, { bold: true, children: "Atom \u2014 baseURL for openai-compatible (http(s) URL + Enter, Esc cancels):" }), _jsxs(Text, { children: ["baseURL: ", baseURLPrompt.draft, _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBlock })] }), baseURLPrompt.error ? _jsx(Text, { color: theme.color.error, children: baseURLPrompt.error }) : null] })) : selectingEffort ? (_jsxs(PickerShell, { title: "Atom \u2014 Select reasoning effort (up/down + Enter, Esc cancels):", children: [EFFORT_OPTIONS.map((o, i) => (_jsxs(PickerRow, { highlighted: i === effortIndex, children: [o === "default" ? "Default" : o === "max" ? "Max" : o[0]?.toUpperCase() + o.slice(1), o === effort ? " (current)" : ""] }, `${o}-${i}`))), _jsx(Text, { dimColor: true, children: "Top is Max (sent as max); xhigh is not a verified value." })] })) : selectingRewind ? (_jsxs(PickerShell, { title: "Atom \u2014 Rewind to checkpoint (up/down + Enter, Esc cancels):", children: [listCheckpoints().map((c, i) => (_jsxs(PickerRow, { highlighted: i === rewindIndex, children: ["#", c.seq, " ", theme.symbol.separator, " ", c.label, " ", theme.symbol.separator, " ", c.files.length, " file(s)"] }, c.id))), _jsx(Text, { dimColor: true, children: "Restores exact bytes (hash-verified). Shell side effects (bash) are never snapshotted and cannot be undone." })] })) : selectingRewindScope ? (_jsxs(PickerShell, { title: "Atom \u2014 Rewind scope (up/down + Enter, Esc cancels):", children: [REWIND_SCOPES.map((s, i) => (_jsx(PickerRow, { highlighted: i === rewindScopeIndex, children: s }, s))), _jsx(Text, { dimColor: true, children: "Shell side effects (bash) are explicitly out of scope and cannot be undone." })] })) : (
+                }) })) : keyPrompt ? (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.picker, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { bold: true, children: ["Atom \u2014 API key for ", keyPrompt.providerId, " (paste + Enter, Esc cancels):"] }), keyPrompt.consoleURL ? (_jsxs(Text, { dimColor: true, children: ["Get a key: ", keyPrompt.consoleURL] })) : null, keyPrompt.existingMasked ? (_jsxs(Text, { dimColor: true, children: ["key on file (", keyPrompt.existingMasked, ") \u2014 type a new key to replace, Esc keeps + switches"] })) : (_jsx(Text, { dimColor: true, children: "No key on file \u2014 paste once, validated then stored in ~/.atom/auth.json" })), keyPrompt.providerId === "kilo" ? (_jsx(Text, { dimColor: true, children: "Optional: free models work without a key \u2014 empty Enter continues anonymously" })) : null, _jsxs(Text, { children: ["key: ", theme.symbol.keyMask.repeat(keyPrompt.draft.length), _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBlock })] }), keyPrompt.validating ? _jsxs(Text, { dimColor: true, children: ["validating", theme.symbol.ellipsis] }) : null, keyPrompt.error ? _jsx(Text, { color: theme.color.error, children: keyPrompt.error }) : null] })) : baseURLPrompt ? (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.picker, paddingX: theme.spacing.pickerPadX, children: [_jsx(Text, { bold: true, children: "Atom \u2014 baseURL for openai-compatible (http(s) URL + Enter, Esc cancels):" }), _jsxs(Text, { children: ["baseURL: ", baseURLPrompt.draft, _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBlock })] }), baseURLPrompt.error ? _jsx(Text, { color: theme.color.error, children: baseURLPrompt.error }) : null] })) : selectingEffort ? (_jsxs(PickerShell, { title: "Atom \u2014 Select reasoning effort (up/down + Enter, Esc cancels):", children: [EFFORT_OPTIONS.map((o, i) => (_jsxs(PickerRow, { highlighted: i === effortIndex, children: [o === "default" ? "Default" : o === "max" ? "Max" : o[0]?.toUpperCase() + o.slice(1), o === effort ? " (current)" : ""] }, `${o}-${i}`))), _jsx(Text, { dimColor: true, children: "Top is Max (sent as max); xhigh is not a verified value." })] })) : selectingRewind ? (_jsxs(PickerShell, { title: "Atom \u2014 Rewind to checkpoint (up/down + Enter, Esc cancels):", children: [checkpointListMemo.map((c, i) => (_jsxs(PickerRow, { highlighted: i === rewindIndex, children: ["#", c.seq, " ", theme.symbol.separator, " ", c.label, " ", theme.symbol.separator, " ", c.files.length, " file(s)"] }, c.id))), _jsx(Text, { dimColor: true, children: "Restores exact bytes (hash-verified). Shell side effects (bash) are never snapshotted and cannot be undone." })] })) : selectingRewindScope ? (_jsxs(PickerShell, { title: "Atom \u2014 Rewind scope (up/down + Enter, Esc cancels):", children: [REWIND_SCOPES.map((s, i) => (_jsx(PickerRow, { highlighted: i === rewindScopeIndex, children: s }, s))), _jsx(Text, { dimColor: true, children: "Shell side effects (bash) are explicitly out of scope and cannot be undone." })] })) : (
             // The input is the one boxed, prominent surface (see the memoized
             // InputBox above): a quiet gray frame sets it apart from the
             // transcript above and the status line below. Pickers and modals