atom-agent 1.0.0 → 1.2.0

package/dist/App.js

@@ -1,20 +1,22 @@
 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 { Box, Text, useApp, useInput, usePaste, useStdout } from "ink";
+import * as path from "node:path";
+import React, { useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, usePaste } 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";
 import { decidePolicy, skillGrantsFor } from "./policy.js";
 import { capSkillBodyForAuto, createSkillRegistry, loadSkillBody, matchSkills, resolveSkills, } from "./skills.js";
 import { contextWindowFor } from "./context-windows.js";
-import { COMPACT_PCT_DEFAULT, buildCompactedHistory, compactBoundaryLine, compactPct, countUserTurns, estimateTokensForChars, isThrashDisabled, requestCompactSummary, splitHistoryForCompaction, } from "./compact.js";
+import { COMPACT_PCT_DEFAULT, buildCompactedHistory, collectStoredTouchedFiles, collectTouchedFiles, compactBoundaryLine, compactPct, countUserTurns, estimateTokensForChars, fitSummaryWithFiles, isThrashDisabled, requestCompactSummary, splitHistoryForCompaction, } from "./compact.js";
 import { DEFAULT_PROVIDER, PROVIDERS, chatEndpointFor, getProvider, isLocalProviderId, isProviderId, localBaseURLFor, maskKey, openaiCompatibleChatEndpoint, providerNeedsKey, validateBaseURL, } from "./providers.js";
 import { createLocalDiscovery, summarizeLocalSnapshot, } from "./local-discovery.js";
 import { getStoredBaseURL, loadAuth, resolveApiKey, saveAuth, setStoredKey, } from "./auth.js";
@@ -22,20 +24,23 @@ import { validateProviderKey } from "./adapters.js";
 import { clearKiloModelsCache, isFreeKiloModel, preferFreeKiloModel, } from "./kilo.js";
 import { getGitInfo, withEnvBlock } from "./env-block.js";
 import { loadPrefs, loadSession, saveSession, sessionExists, } from "./session.js";
+import { createSession, ensureActiveSession, getActiveSession, getActiveSessionId, getSession, listSessions, renameSession, setActiveSession, updateSession, } from "./sessions.js";
 import { loadAtomConfig } from "./config.js";
 import { cancelledTurnLine } from "./rollback.js";
 import { clearSnapshots, conversationCutIndex, getCheckpoint, listCheckpoints, registerHistoryProbe, restoreCheckpointFiles, } from "./snapshots.js";
 import { forgetReadFingerprint, refreshReadFingerprint } from "./tools.js";
 import { InputBox } from "./ui/input.js";
 import { historyNewerIndex, historyOlderIndex, killToLineEnd, killToLineStart, killWordBefore, lineColOf, moveVertically, normalizePaste, offsetOfLines, pushInputHistory as pushInputHistoryList, splitInputLines, } from "./ui/input-model.js";
-import { LiveTail } from "./ui/live-tail.js";
+import { LiveTailHost } from "./ui/live-host.js";
 import { InspectorPanel, MAX_TOOL_RECORDS, VIEWPORT_LINES, createToolRecord, } from "./ui/tool-inspector.js";
 import { activityText } from "./ui/activity.js";
 import { ApprovalBox, QuestionBox } from "./ui/modals.js";
 import { PalettePanel } from "./ui/palette.js";
 import { PALETTE_CATEGORY_ORDER, PALETTE_HINTS, paletteCategory } from "./ui/palette.js";
 import { PickerMoreAbove, PickerMoreBelow, PickerRow, PickerShell, pickerWindow } from "./ui/pickers.js";
-import { StatusBar, shortenCwd } from "./ui/status-bar.js";
+import { shortenCwd } from "./ui/status-bar.js";
+import { StatusBarHost } from "./ui/status-host.js";
+import { createStreamStore } from "./ui/stream-store.js";
 import { theme } from "./ui/theme.js";
 import { TodoPanel } from "./ui/todo-panel.js";
 import { TranscriptView, applyScrollAction } from "./ui/transcript.js";
@@ -48,7 +53,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)." },
@@ -58,11 +63,15 @@ export const SLASH_COMMANDS = [
     { name: "/rules", description: "List session allow/deny rules (/rules clear wipes them)." },
     { name: "/clear", description: "Clear the conversation history (keeps session token totals; drops file checkpoints)." },
     { name: "/new", description: "Start a brand-new session (full fresh conversation + counters reset, previous kept for /resume)." },
+    { name: "/rename", description: "Rename the current session (/rename <name>)." },
     { name: "/compact", description: "Summarize older turns into one summary (optional focus text: /compact focus…)." },
     { 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: "Toggle following new output (off by default; bare toggles, on|off sets it; 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: "/session", description: "Switch the active session (interactive picker, most recent first)." },
     { name: "/telemetry", description: "Show the local observability summary (sessions, tokens, tools)." },
     { name: "/dashboard", description: "Write the local observability dashboard page and show its path." },
     { name: "/rewind", description: "Restore files to a session checkpoint (files only; shell side effects are never snapshotted)." },
@@ -106,8 +115,36 @@ 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] — off (default) freezes the view while a turn runs (a `↓ N new` indicator offers the jump back); on follows new output as it arrives. Bare /autoscroll toggles between the two.";
+export const THINKING_USAGE = "usage: /thinking — toggles model-thinking visibility in the TUI (rendering only: the live block and future rounds show or hide; already-printed blocks stay as printed; the turn, history, and telemetry are untouched).";
+export const RENAME_USAGE = 'usage: /rename <name> — rename the current session (e.g. /rename Build authentication; quotes optional: /rename "name with spaces"). Bare /rename prints this usage.';
+// Pure arg parser for /rename (unit-tested): strips the command, trims,
+// then strips one layer of matching outer quotes (single or double) so
+// quoted names work even though the command line has no real parser.
+// Unquoted multi-word names work as-is (everything after /rename is the
+// name). Empty/whitespace-only input yields "" (caller prints usage).
+export function parseRenameArg(raw) {
+    const text = raw.trim();
+    const arg = text === "/rename" ? "" : text.slice("/rename".length).trim();
+    if (arg.length >= 2) {
+        const first = arg[0];
+        const last = arg[arg.length - 1];
+        if ((first === '"' || first === "'") && last === first) {
+            return arg.slice(1, -1).trim();
+        }
+    }
+    return arg;
+}
 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 +200,18 @@ 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);
+// /rename only renames the store record + title state (the later turn-end
+// persist preserves the title, so it never races 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" ||
+        name === "/rename");
 }
 // Fuzzy subsequence match with gap/start/word-boundary scoring (lower is
 // better; null = no match). Pure — shared by the command filter, the skill
@@ -205,6 +250,15 @@ export function filterSkillPicker(entries, query) {
         return entries;
     return entries.filter((e) => e.name.toLowerCase().includes(q));
 }
+export function sameSkillMenuSnapshot(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].name !== b[i].name || a[i].description !== b[i].description)
+            return false;
+    }
+    return true;
+}
 // Pure menu builder (unit-tested): matching commands first (prefix tier in
 // stable order, then fuzzy by score), then matching skills as `/skill:name`
 // entries (prefix tier stable, then fuzzy). Skills join only once the query
@@ -273,6 +327,8 @@ export function commandUsage(name) {
             return SKILL_USAGE;
         case "/compact":
             return "Usage: /compact [focus text] — summarize older turns (works while busy; drains at turn end).";
+        case "/rename":
+            return RENAME_USAGE;
         default:
             return null;
     }
@@ -292,6 +348,41 @@ export function modelsCacheKey(providerId, baseURL) {
     }
     return providerId;
 }
+export function filterSessionEntries(entries, query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return entries;
+    const scored = [];
+    entries.forEach((e, idx) => {
+        const titleScore = fuzzyScore(q, e.title);
+        const idScore = fuzzyScore(q, e.id);
+        let best = titleScore;
+        if (idScore !== null && (best === null || idScore + 5 < best)) {
+            best = idScore + 5;
+        }
+        if (best !== null)
+            scored.push({ e, score: best, idx });
+    });
+    scored.sort((a, b) => a.score - b.score || a.idx - b.idx);
+    return scored.map((s) => s.e);
+}
+// Relative age for the picker secondary line (unit-tested). Invalid dates
+// say "unknown" (never throw, never invent).
+export function formatSessionAge(nowMs, updatedAt) {
+    const t = Date.parse(updatedAt);
+    if (!Number.isFinite(t))
+        return "unknown";
+    const secs = Math.max(0, Math.floor((nowMs - t) / 1000));
+    if (secs < 60)
+        return "just now";
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${Math.floor(hours / 24)}d ago`;
+}
 // Pure helpers for the elapsed/stall indicator (injectable now for tests).
 export function elapsedSecsSince(startMs, nowMs) {
     return Math.max(0, Math.floor((nowMs - startMs) / 1000));
@@ -487,17 +578,13 @@ export function MissingKey() {
 // Measured once: TOOL_DEFINITIONS never changes at runtime, so the schema
 // size is a constant (avoids re-serializing ~15KB on every manager build).
 const TOOLS_SCHEMA_CHARS = JSON.stringify(TOOL_DEFINITIONS).length;
+// Render-count probe for propagation audits: incremented on every App body
+// execution (hostile-perf suite asserts token paints and ticks stay out of
+// here — only real state transitions may run the orchestrator).
+export const appRenderProbe = { count: 0 };
 export function App({ apiKey, endpoint, initialModel, initialModels, initialProvider, restorePrefs, authHome, skillDirs, configDirs, now, setIntervalFn, clearIntervalFn, setTimeoutFn, clearTimeoutFn, localDiscovery }) {
+    appRenderProbe.count += 1;
     const { exit } = useApp();
-    // Measured terminal width for the status bar's fit-or-drop branch logic.
-    // Unknown (piped output) falls back to the bar's own default.
-    let termColumns;
-    try {
-        termColumns = useStdout()?.stdout?.columns;
-    }
-    catch {
-        termColumns = undefined;
-    }
     // Saved preferences (provider/model/effort + resolved key/endpoint), loaded
     // once when restorePrefs is on (prod). Explicit props always win; without
     // prefs the CLI defaults apply. Null in tests (flag off) and on any
@@ -670,6 +757,24 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         skillFilterRef.current = next;
         setSkillFilter(next);
     }
+    // /session picker (interactive switcher): snapshot state loaded ONCE per
+    // open (listSessions reads each record a single time), filtered in memory
+    // per keystroke. ↑/↓ + Enter switches, Esc cancels with the live session
+    // untouched. Same keyboard/window pattern as the /skills picker.
+    const [selectingSession, setSelectingSession] = useState(false);
+    const [sessionItems, setSessionItems] = useState([]);
+    const [sessionIndex, setSessionIndex] = useState(0);
+    const sessionIndexRef = useRef(0);
+    const [sessionFilter, setSessionFilter] = useState("");
+    const sessionFilterRef = useRef("");
+    function setSessionIndexBoth(next) {
+        sessionIndexRef.current = next;
+        setSessionIndex(next);
+    }
+    function setSessionFilterBoth(next) {
+        sessionFilterRef.current = next;
+        setSessionFilter(next);
+    }
     // Reasoning-effort picker (/effort): same pattern as the /model picker
     // (↑/↓ + Enter, Esc cancels). Saved effort restores with restorePrefs,
     // else the atom.json default, else Default.
@@ -816,6 +921,24 @@ 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 off). Off freezes the view at the
+    // first busy append (the `↓ N new` indicator offers the jump back); on
+    // follows new output as it arrives. Bare /autoscroll toggles.
+    const [autoScroll, setAutoScroll] = useState(false);
+    const autoScrollRef = useRef(false);
+    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
@@ -832,14 +955,46 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         try {
             const found = await skillRegistry.refresh();
             const { skills } = resolveSkills(found.skills);
-            setSkillMenu(skills
+            const next = skills
                 .filter((s) => s.userInvocable)
-                .map((s) => ({ name: s.name, description: s.description })));
+                .map((s) => ({ name: s.name, description: s.description }));
+            // Install only on change: the mount refresh routinely rediscovers the
+            // identical set mid-turn, and a fresh array identity would schedule a
+            // full App render for zero new information.
+            setSkillMenu((prev) => (sameSkillMenuSnapshot(prev, next) ? prev : next));
         }
         catch {
             // 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.
@@ -930,24 +1085,91 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // as a dim line while the transcript is empty; the conversation itself
     // never auto-restores (only provider/model/effort do, via restorePrefs).
     const [sessionHint] = useState(() => sessionExists(authHome));
+    // Active session display title (rename feedback + failure messages).
+    // Initialized from the store record when one already exists (sync disk
+    // read, no write — creation stays in the mount effect); thereafter the
+    // store is the source of truth and every sync point below refreshes it.
+    // Deliberately NOT in the status bar: the sole info bar has a fixed width
+    // budget and a ~30-char title wraps `mode: X` onto its own line. Session
+    // identity surfaces instead in the /session picker rows, the rename
+    // confirmation, and the switch/new notices.
+    const [sessionTitle, setSessionTitle] = useState(() => {
+        try {
+            return getActiveSession(authHome)?.title ?? "";
+        }
+        catch {
+            return "";
+        }
+    });
+    const sessionTitleRef = useRef(sessionTitle);
     // Reasoning label from response metadata (via onReasoning). The status
     // line shows the session effort when non-Default (plus " (unsupported)"
     // when the model is outside the verified-support set); when effort is
     // Default it shows this label, falling back to `default`.
     const [reasoning, setReasoning] = useState(null);
-    // Live streaming state: `draft` is the growing assistant text (onToken),
-    // `phase`/`phaseDetail` track the observe→act→inspect→adjust loop
-    // (thinking|streaming|tool|retry|done), and `toolHint` shows a streamed
-    // tool name before its execution line lands.
-    const [draft, setDraft] = useState(null);
+    // Live streaming state: the growing assistant text (onToken) and the
+    // thinking channel (onThinking) live in a per-mount StreamStore, NOT in App
+    // useState. Token paints (up to ~15/sec) notify only the subscribed
+    // LiveTailHost — App's body and every other leaf skip them entirely.
+    // `phase`/`phaseDetail`/`toolHint` stay in App state: they change at most a
+    // few times per turn (low frequency, and StatusBar legitimately needs them).
+    const [streamStore] = useState(() => createStreamStore());
     // 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.
-    const [thinking, setThinking] = useState(null);
+    // answer, rendered in its own dim block below. The live value is transient
+    // like the 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 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;
+        try {
+            // Drop any trailing paint: the commit carries the full text, and a
+            // late flush must never resurrect stale reasoning after the clear.
+            thinkingThrottleRef.current?.cancel();
+        }
+        catch {
+            // ignore (the store clear below still wins)
+        }
+        streamStore.setThinking(null);
+        if (typeof text === "string" && text.length > 0) {
+            appendTurns({ role: "assistant", content: text, thinking: true });
+        }
+    }
+    function clearThinking() {
+        thinkingRef.current = null;
+        try {
+            thinkingThrottleRef.current?.cancel();
+        }
+        catch {
+            // ignore (the store clear below still wins)
+        }
+        streamStore.setThinking(null);
+    }
     const [phase, setPhase] = useState("idle");
     const [phaseDetail, setPhaseDetail] = useState("");
     const [toolHint, setToolHint] = useState(null);
+    // Synchronous mirrors for the hot loop callbacks: zen fires
+    // onPhase("streaming") on EVERY content chunk, so the handler must not
+    // issue same-value setStates per token (React re-invokes the component
+    // before bailing out — 15 App-body executions/sec for nothing).
+    // setPhaseBoth is the only writer; equal values skip setState entirely.
+    const phaseRef = useRef("idle");
+    const phaseDetailRef = useRef("");
+    function setPhaseBoth(next, detail) {
+        if (phaseRef.current !== next) {
+            phaseRef.current = next;
+            setPhase(next);
+        }
+        if (phaseDetailRef.current !== detail) {
+            phaseDetailRef.current = detail;
+            setPhaseDetail(detail);
+        }
+    }
     // Task B smoothness (a): throttled streaming draft. onToken pushes every
     // partial (activity/stall tracking stays per-token); paints coalesce to one
     // per DRAFT_THROTTLE_MS trailing window, flushed on done/turn-end.
@@ -960,7 +1182,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 setTimeoutFn,
                 clearTimeoutFn,
                 onFlush: (text) => {
-                    setDraft(text);
+                    // Paint path only: the commit carries the byte-exact full text.
+                    // Writing the store notifies LiveTailHost alone — never App.
+                    streamStore.setDraft(text);
                 },
             });
             draftThrottleRef.current = th;
@@ -975,6 +1199,26 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             // ignore (draft stays as-is; the commit carries the full text)
         }
     }
+    // Thinking paint coalescing: reasoning chunks arrive at token rate but
+    // paint through the same trailing window into the store (producer/consumer
+    // symmetry with the draft). thinkingRef stays synchronous per chunk so
+    // commitThinking can never lose reasoning to a pending trailing paint.
+    const thinkingThrottleRef = useRef(null);
+    function thinkingThrottler() {
+        let th = thinkingThrottleRef.current;
+        if (!th) {
+            th = createDraftThrottler({
+                now,
+                setTimeoutFn,
+                clearTimeoutFn,
+                onFlush: (text) => {
+                    streamStore.setThinking(text);
+                },
+            });
+            thinkingThrottleRef.current = th;
+        }
+        return th;
+    }
     // Phase 5: models-list session cache (successful live lists only, keyed
     // by modelsCacheKey). Failures fall back uncached, exactly as before.
     const modelsCacheRef = useRef(new Map());
@@ -1050,6 +1294,15 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // on the next activity.
     const [elapsedSecs, setElapsedSecs] = useState(0);
     const [stalled, setStalled] = useState(false);
+    // Mirror for the per-token stall reset (same same-value-setState hazard
+    // as phase above — noteTurnActivity runs on every chunk).
+    const stalledRef = useRef(false);
+    function setStalledBoth(next) {
+        if (stalledRef.current !== next) {
+            stalledRef.current = next;
+            setStalled(next);
+        }
+    }
     const turnStartRef = useRef(0);
     const lastActivityRef = useRef(0);
     const turnTimerRef = useRef(null);
@@ -1175,7 +1428,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         catch {
             // ignore clock errors (stall hint just won't trigger)
         }
-        setStalled(false);
+        // Guarded: runs on every token/thinking/phase event, but only a
+        // true→false transition may schedule a render.
+        setStalledBoth(false);
     }
     function startTurnTimer() {
         clearTurnTimer();
@@ -1189,7 +1444,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         turnStartRef.current = start;
         lastActivityRef.current = start;
         setElapsedSecs(0);
-        setStalled(false);
+        setStalledBoth(false);
         try {
             turnTimerRef.current = (setIntervalFn ?? setInterval)(() => {
                 let t;
@@ -1201,7 +1456,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 }
                 setElapsedSecs(elapsedSecsSince(turnStartRef.current, t));
                 if (isStalledSince(lastActivityRef.current, t)) {
-                    setStalled(true);
+                    // Guarded: the stalled flag flips false→true once per silence
+                    // window, not on every tick within it.
+                    if (!stalledRef.current)
+                        setStalledBoth(true);
                 }
             }, TURN_TICK_MS);
         }
@@ -1244,6 +1502,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
             try {
                 draftThrottleRef.current?.cancel();
+                thinkingThrottleRef.current?.cancel();
             }
             catch {
                 // ignore
@@ -1414,6 +1673,8 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setModelFilterBoth("");
         setSelectingSkills(false);
         setSkillFilterBoth("");
+        setSelectingSession(false);
+        setSessionFilterBoth("");
         setSelectingEffort(false);
         setSelectingProvider(false);
         setKeyPromptBoth(null);
@@ -1446,6 +1707,46 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             pushInfo("(skill discovery failed — no skills listed)");
         });
     }
+    // /session picker open: snapshot the store list ONCE (most-recent-first
+    // from listSessions) with the active record marked, then filter in memory
+    // per keystroke (no disk reads while typing). Idle-only (callers gate on
+    // busy like every picker — a mid-turn switch would race the loop's own
+    // history writes). Empty store degrades to a notice (unreachable while
+    // the mount bootstrap holds, but never a blank popup).
+    function openSessionPicker(initialFilter) {
+        setInputBoth("");
+        closeAllPickers();
+        let records;
+        try {
+            records = listSessions(authHome);
+        }
+        catch {
+            pushInfo("(could not list sessions — store unreadable)");
+            return;
+        }
+        if (records.length === 0) {
+            pushInfo("(no sessions yet — your current conversation is saved automatically)");
+            return;
+        }
+        let activeId = null;
+        try {
+            activeId = getActiveSessionId(authHome);
+        }
+        catch {
+            activeId = null;
+        }
+        setSessionItems(records.map((s) => ({
+            id: s.id,
+            title: s.title,
+            updatedAt: s.updatedAt,
+            createdAt: s.createdAt,
+            turnCount: s.turns.length,
+            active: s.id === activeId,
+        })));
+        setSessionFilterBoth(initialFilter);
+        setSessionIndexBoth(0);
+        setSelectingSession(true);
+    }
     // Unified /model entries for this render: active provider's current list
     // first, then every other keyed provider's cached-or-fallback list (pure,
     // local-only — see modelPickerEntries). Called from the /model open path,
@@ -1552,6 +1853,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);
@@ -1560,6 +1868,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         usageRef.current = next;
         setUsageTotals(next);
     }
+    function setSessionTitleBoth(next) {
+        sessionTitleRef.current = next;
+        setSessionTitle(next);
+    }
     function setContextLoadBoth(next) {
         contextLoadRef.current = next;
         setContextLoad(next);
@@ -1729,7 +2041,97 @@ 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.
+    //
+    // Multi-session mirror (src/sessions.ts): every conversation auto-belongs
+    // to a durable session record (~/.atom/sessions/<id>.json + active
+    // pointer). persistSession() also mirrors the same committed snapshot
+    // into the active record via persistStoreSession() below, so completed
+    // turns, clean exits, and successful compactions bump updatedAt there too.
+    // Failures/cancels never reach here (same rollback rule as legacy).
+    // Active id lives in a ref only — never a session list in runtime state.
+    const activeSessionIdRef = useRef(null);
+    function storeCwd() {
+        try {
+            return process.cwd();
+        }
+        catch {
+            return "";
+        }
+    }
+    // Ensure exactly one active persistent session exists (fresh mount creates
+    // one with the current provider/model/effort/mode + cwd). Never throws,
+    // never blocks render — disk errors leave the ref null and the next
+    // persist retries.
+    function ensureStoreSession() {
+        try {
+            const existing = activeSessionIdRef.current;
+            // The record may vanish under a running process (external delete,
+            // corrupted file): a stale cached id must re-ensure instead of
+            // persisting into the void (every later turn would silently skip).
+            if (existing) {
+                try {
+                    if (getSession(existing, authHome))
+                        return existing;
+                }
+                catch {
+                    // fall through to re-ensure below
+                }
+            }
+            const s = ensureActiveSession({
+                cwd: storeCwd(),
+                provider: providerRef.current,
+                model: modelRef.current,
+                effort: effortRef.current,
+                mode: modeRef.current,
+            }, authHome);
+            activeSessionIdRef.current = s.id;
+            // The store owns the title (a /rename from an earlier mount must show
+            // after restart); sync the display state on every ensure.
+            setSessionTitleBoth(s.title);
+            return s.id;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Mirror the committed snapshot into the active multi-session record
+    // (single updateSession so updatedAt bumps on every committed turn).
+    // Disk errors ignored, like the legacy save above.
+    function persistStoreSession() {
+        try {
+            const id = ensureStoreSession();
+            if (!id)
+                return;
+            updateSession(id, {
+                history: historyRef.current,
+                turns: turnsRef.current.map((t) => {
+                    const { diff: _dropped, ...rest } = t;
+                    return rest;
+                }),
+                usageTotals: usageRef.current,
+                provider: providerRef.current,
+                model: modelRef.current,
+                effort: effortRef.current,
+                mode: modeRef.current,
+                cwd: storeCwd(),
+            }, authHome);
+        }
+        catch {
+            // ignore disk errors (in-memory session still applies)
+        }
+    }
+    // Mount bootstrap: claim/create the active session before any turn can
+    // persist, so every normal conversation belongs to a durable session.
+    // Startup never auto-restores conversation state (fresh + legacy hint,
+    // matching current UX) — this only ensures the record exists.
+    useEffect(() => {
+        ensureStoreSession();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
     function persistSession() {
         try {
             saveSession({
@@ -1739,12 +2141,16 @@ 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 {
             // ignore disk errors (in-memory session still applies)
         }
+        persistStoreSession();
     }
     // Local observability persistence: flush the current telemetry session
     // file (atomic, best-effort). Called on turn boundaries and session events —
@@ -1876,8 +2282,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     telemetry.recordCompactionUsage(u, isAuto ? "auto" : "manual");
                 },
             });
-            // Atomic swap: build the new history first, then replace.
-            const next = buildCompactedHistory(systemMsg, summary, split.tail, split.olderTurnCount);
+            // Atomic swap: build the new history first, then replace. The head's
+            // touched files (collected from the committed tool_calls the loop
+            // already recorded — no new tracking) ride inside the summary within
+            // budget, so resumed sessions know what was touched; over-budget lists
+            // shrink instead of failing compaction.
+            const fitted = fitSummaryWithFiles(summary, collectTouchedFiles(split.head));
+            const next = buildCompactedHistory(systemMsg, fitted.text, split.tail, split.olderTurnCount);
             // Replacement: re-wrap so the ledger restarts from the compacted array
             // (the old ledger is discarded with the old array).
             historyRef.current = trackHistory(next);
@@ -2013,6 +2424,12 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         contextManager().trimForSend(historyRef.current, (msg) => {
             pendingNotices.push({ role: "tool", content: `⚠ ${msg}` });
         }, undefined, openTodoNeedles());
+        // Surface the touched-file lists stored in compacted summaries, verbatim
+        // in the stored format — a resumed session knows what was touched
+        // without re-exploring the tree.
+        for (const section of collectStoredTouchedFiles(historyRef.current)) {
+            pendingNotices.push({ role: "tool", content: section });
+        }
         // Remount the turns <Static> (same mechanism as /clear and /new): Ink's
         // Static only renders newly appended indices, so restoring a transcript
         // over a non-empty rendered buffer (e.g. the /new boundary line) would
@@ -2030,6 +2447,141 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         ]);
         telemetry.recordEvent("resume", `restored session saved at ${s.savedAt} (${s.turns.length} turns)`);
         persistTelemetry();
+        // Mirror the restored legacy state into the active multi-session record
+        // (create+activate when none exists). Startup itself never auto-restores
+        // the store — only this explicit /resume does.
+        persistStoreSession();
+    }
+    // /session switch: make the picked record the live conversation. Exactly
+    // one history replacement (never merge, never duplicate): the target's
+    // history/turns REPLACE the live arrays wholesale, following the doResume
+    // precedent (endpoint recompute, env-block refresh, budget trim, lineage
+    // drop, Static remount, title sync). Differences from /resume:
+    // - the outgoing live state snapshots into the OLD record first, but only
+    //   when it holds turns (a fresh mount's system-only live state is NOT the
+    //   old record's content — persisting it would wipe that record);
+    // - re-picking the current session is a no-op (reloading from disk would
+    //   drop unpersisted live turns);
+    // - updatedAt is NOT bumped (switching is navigation, not a mutation —
+    //   listings keep true recency order);
+    // - a missing/unreadable target errors WITHOUT touching the live session.
+    // The legacy session.json follows the switch (same persistSession path as
+    // every completed turn) so /resume stays coherent with the live view.
+    function switchToSession(id) {
+        let target = null;
+        try {
+            target = getSession(id, authHome);
+        }
+        catch {
+            target = null;
+        }
+        if (!target) {
+            pushInfo("(session no longer available — staying on the current session)");
+            return;
+        }
+        const currentId = activeSessionIdRef.current;
+        if (currentId !== null && currentId === target.id) {
+            pushInfo(`(already on "${target.title}")`);
+            return;
+        }
+        // Snapshot the outgoing conversation into its own record first (same
+        // rule as /new's pre-reset save). Guarded: only when the live state
+        // actually holds turns of the outgoing record.
+        if (currentId !== null && currentId !== target.id && turnsRef.current.length > 0) {
+            persistStoreSession();
+        }
+        try {
+            setActiveSession(target.id, authHome);
+        }
+        catch {
+            // setActiveSession never throws by contract; defensive only.
+        }
+        activeSessionIdRef.current = target.id;
+        setProviderBoth(target.provider);
+        const baseURL = chatBaseURL(target.provider);
+        if (target.provider === "openai-compatible") {
+            setActiveEndpoint(openaiCompatibleChatEndpoint(baseURL));
+        }
+        else if (target.provider === "opencode-zen") {
+            setActiveEndpoint(endpoint);
+        }
+        else {
+            setActiveEndpoint(chatEndpointFor(target.provider, baseURL));
+        }
+        setModelBoth(target.model);
+        setEffortBoth(target.effort);
+        setModeBoth(target.mode);
+        setUsageBoth(target.usageTotals);
+        // Replacement: the target's arrays replace the live ones wholesale (a
+        // fresh-created record carries empty history — fall back to a fresh
+        // system line so the system-first invariant always holds).
+        historyRef.current =
+            target.history.length > 0
+                ? trackHistory([...target.history])
+                : trackHistory([{ role: "system", content: withEnvBlock(systemPrompt) }]);
+        if (target.history.length > 0) {
+            refreshSystemEnv();
+        }
+        lastPromptTokensRef.current = undefined;
+        if (!usageRef.current) {
+            setContextLoadBoth(null);
+        }
+        else {
+            setContextLoadBoth(estimateTokensForChars(historyChars(historyRef.current)));
+        }
+        autoStreakRef.current = 0;
+        setAutoDisabledBoth(false);
+        pendingCompactRef.current = null;
+        const pendingNotices = [];
+        // New lineage (see src/rollback.ts): checkpoint marks index the old
+        // history — drop them, loudly when non-empty. Disk files untouched.
+        const switchDrops = clearSnapshots();
+        if (switchDrops > 0) {
+            pendingNotices.push({
+                role: "tool",
+                content: `(/session — discarded ${switchDrops} live file checkpoint(s); undos do not cross a session switch)`,
+            });
+        }
+        // TODO isolation (mirrors /new): the checklist is process-global memory
+        // that is never persisted — carrying it across sessions would show the
+        // new session the old session's plan, and the agent would act on it.
+        // Reset it, loudly when non-empty.
+        if (getTodos().length > 0) {
+            clearTodos();
+            setTodoSnap([]);
+            pendingNotices.push({
+                role: "tool",
+                content: "(/session — checklist reset; TODOs are per-conversation and do not cross sessions)",
+            });
+        }
+        else {
+            clearTodos();
+            setTodoSnap([]);
+        }
+        contextManager().trimForSend(historyRef.current, (msg) => {
+            pendingNotices.push({ role: "tool", content: `⚠ ${msg}` });
+        }, undefined, openTodoNeedles());
+        for (const section of collectStoredTouchedFiles(historyRef.current)) {
+            pendingNotices.push({ role: "tool", content: section });
+        }
+        // Same Static remount as /clear, /resume, and /new: the replaced list
+        // must not reuse the old buffer.
+        setScrollEndBoth(null);
+        setClearGen((g) => g + 1);
+        setTurnsBoth([
+            ...target.turns,
+            {
+                role: "tool",
+                content: `(switched to session "${target.title}" — ${target.turns.length} turns)`,
+            },
+            ...pendingNotices,
+        ]);
+        setSessionTitleBoth(target.title);
+        telemetry.recordEvent("info", `session switched to ${target.id} (${target.turns.length} turns)`);
+        persistTelemetry();
+        // Legacy single-file save follows the switch so /resume restores what
+        // the live view shows (same path/format as every completed turn).
+        persistSession();
     }
     // /rewind conversation scope (ticket 01): truncate history + transcript to
     // the checkpoint's turn. The cut drops the whole containing turn (submit's
@@ -2209,6 +2761,93 @@ 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)");
+    }
+    // /rename for the CURRENT session only (never creates one: renameSession
+    // touches exactly the active record). Bare /rename prints usage — ATOM has
+    // no generic text-prompt overlay (key/baseURL prompts are
+    // provider-specific), so an interactive flow would be a new UI system.
+    // Empty/whitespace-only names are rejected safely (previous name kept).
+    // On failure the previous name is preserved (title state only changes on
+    // success); history/turns are never part of the write.
+    function runRenameCommand(raw) {
+        const name = parseRenameArg(raw);
+        if (!name) {
+            pushInfo(RENAME_USAGE);
+            return;
+        }
+        let id = null;
+        try {
+            id = ensureStoreSession();
+        }
+        catch {
+            id = null;
+        }
+        if (!id) {
+            pushInfo("(rename failed — session store unavailable; name unchanged)");
+            return;
+        }
+        let renamed = null;
+        try {
+            renamed = renameSession(id, name, authHome);
+        }
+        catch {
+            renamed = null;
+        }
+        if (!renamed) {
+            const current = sessionTitleRef.current || "untitled";
+            pushInfo(`(rename failed — still "${current}")`);
+            return;
+        }
+        setSessionTitleBoth(renamed.title);
+        pushInfo(`(renamed session to "${renamed.title}")`);
+    }
+    // /autoscroll [on|off]: follow switch for the scrollback viewport. View-
+    // only state — safe while busy (never touches the turn, like /queue).
+    // Bare toggles off ⇄ on; 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();
+        // Bare command toggles; explicit on|off sets directly.
+        const effective = arg === "" ? (autoScrollRef.current ? "off" : "on") : arg;
+        if (effective === "on") {
+            if (autoScrollRef.current) {
+                pushInfo("(autoscroll already on)");
+                return;
+            }
+            setAutoScrollBoth(true);
+            setScrollEndBoth(null);
+            pushInfo("(autoscroll on — following the latest)");
+            return;
+        }
+        if (effective === "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
@@ -2264,6 +2903,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             case "/clear":
                 // Task 6: same base as mount (no AGENTS.md re-read, as before) plus a
                 // fresh env block. Fresh array → fresh ledger via trackHistory.
+                // Store mirror: LAZY, matching legacy — /clear wipes the live
+                // transcript only and writes nothing to the store here; the cleared
+                // (empty) conversation persists on the next completed turn via
+                // persistSession()/persistStoreSession().
                 historyRef.current = trackHistory([
                     { role: "system", content: withEnvBlock(systemPrompt) },
                 ]);
@@ -2274,11 +2917,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 setScrollEndBoth(null);
                 setClearGen((g) => g + 1);
                 setError(null);
-                setDraft(null);
-                setThinking(null);
+                streamStore.setDraft(null);
+                clearThinking();
                 setToolHint(null);
-                setPhase("idle");
-                setPhaseDetail("");
+                setPhaseBoth("idle", "");
                 // /clear drops the transcript: load resets (no context), streak
                 // resets, pending compact drains, and turn-scoped skill grants go
                 // with it (no invisible auto-approvals survive a wiped transcript).
@@ -2309,7 +2951,28 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 // restores — same path/format as every completed turn, no new
                 // schema). No sessions/ archive step: session.ts only has
                 // session.json, so no archiving is invented here.
+                // persistSession() also mirrors the pre-/new conversation into the
+                // OLD active store record before the reset below.
                 persistSession();
+                // Fresh store record for the new conversation (settings carried over,
+                // empty history/turns/usage; default title = formatSessionTitle(now)
+                // via createSession). Explicit setActiveSession: createSession only
+                // claims the pointer when none is set.
+                try {
+                    const created = createSession({
+                        cwd: storeCwd(),
+                        provider: providerRef.current,
+                        model: modelRef.current,
+                        effort: effortRef.current,
+                        mode: modeRef.current,
+                    }, authHome);
+                    setActiveSession(created.id, authHome);
+                    activeSessionIdRef.current = created.id;
+                    setSessionTitleBoth(created.title);
+                }
+                catch {
+                    // ignore disk errors (in-memory reset below still applies)
+                }
                 // Fresh system re-read (system.ts base + current AGENTS.md overlay)
                 // plus a fresh Task 6 env block. Fresh array → fresh ledger.
                 historyRef.current = trackHistory([
@@ -2325,11 +2988,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 setScrollEndBoth(null);
                 setClearGen((g) => g + 1);
                 setError(null);
-                setDraft(null);
-                setThinking(null);
+                streamStore.setDraft(null);
+                clearThinking();
                 setToolHint(null);
-                setPhase("idle");
-                setPhaseDetail("");
+                setPhaseBoth("idle", "");
                 // /new-vs-/clear split: /clear wipes the transcript but KEEPS usage
                 // totals; /new resets the counters too (fresh conversation). Session
                 // SETTINGS (effort/mode/provider/model) are kept — only the
@@ -2412,6 +3074,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)");
@@ -2456,6 +3124,15 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             case "/resume":
                 doResume();
                 return;
+            case "/session":
+                openSessionPicker("");
+                return;
+            case "/rename":
+                // Bare exact match (slash-menu Enter on the highlighted name):
+                // usage — the typed-args form is preserved by the menu branch and
+                // the submit prefix route above.
+                runRenameCommand("/rename");
+                return;
             case "/telemetry":
                 pushInfo(telemetrySummaryText());
                 return;
@@ -2503,6 +3180,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 +3210,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 +3244,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);
@@ -2636,6 +3339,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             await runCompactCommand(focus);
             return;
         }
+        // /rename with optional name: prefix match ("/rename" or "/rename ...").
+        // Instant local store op — safe while busy (the turn-end persist never
+        // carries a title, so it cannot clobber the rename).
+        if (text === "/rename" || text.startsWith("/rename ")) {
+            runRenameCommand(text);
+            return;
+        }
         // SUBMIT STAGE 1/4 — permissions (rollback scope: pre-turn, appends
         // nothing). Busy guard + API-key check: rejections return before any
         // history mutation, so there is nothing to roll back.
@@ -2651,6 +3361,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 +3388,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.
@@ -2683,6 +3415,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             void runModelsCommand(arg);
             return;
         }
+        // /session takes an optional initial filter ("/session auth" opens the
+        // picker pre-filtered) — SLASH_NAMES only holds the exact command.
+        if (text === "/session" || text.startsWith("/session ")) {
+            const initial = text === "/session" ? "" : text.slice("/session".length).trim();
+            openSessionPicker(initial);
+            return;
+        }
         // Exact full-command + Enter runs it. A single-token "/name" not in
         // SLASH_NAMES resolves through the skill registry (ticket 03, legacy
         // form — the namespaced `/skill:name` below is canonical); anything
@@ -2730,8 +3469,8 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         busyRef.current = true;
         setBusy(true);
         setError(null);
-        setDraft(null);
-        setThinking(null);
+        streamStore.setDraft(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;
@@ -2740,19 +3479,22 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         // Expiry happens in the turn-end finally below, plus /clear + /new.
         try {
             draftThrottler().reset();
+            thinkingThrottler().reset();
         }
         catch {
             // ignore (first token still paints; at worst one window late)
         }
         setToolHint(null);
-        setPhase("thinking");
-        setPhaseDetail("");
+        setPhaseBoth("thinking", "");
         // Phase 5: start the elapsed/stall timer (status-bar only, never the
         // transcript). Cleared in finally below and on unmount.
         startTurnTimer();
         // 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 +3575,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,
@@ -2844,22 +3591,33 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                         draftThrottler().push(partial);
                     }
                     catch {
-                        setDraft(partial);
+                        // Never lose tokens: paint now rather than drop the partial.
+                        streamStore.setDraft(partial);
                     }
                     lastPartialRef.current = partial;
                     noteTurnActivity();
                 },
                 onThinking: (partial) => {
-                    setThinking(partial);
+                    thinkingRef.current = partial;
+                    try {
+                        thinkingThrottler().push(partial);
+                    }
+                    catch {
+                        // Never lose reasoning: paint now rather than drop the partial.
+                        streamStore.setThinking(partial);
+                    }
                     noteTurnActivity();
                 },
                 onPhase: (p, detail) => {
-                    setPhase(p);
-                    setPhaseDetail(detail ?? "");
+                    // Change-guarded (zen emits "streaming" per content chunk):
+                    // steady-state tokens issue zero setStates here.
+                    setPhaseBoth(p, 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 +3721,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 +3767,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 +3810,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 +3864,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("");
@@ -3082,14 +3883,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             catch {
                 // ignore
             }
-            setDraft(null);
-            setThinking(null);
+            streamStore.setDraft(null);
+            clearThinking();
             setToolHint(null);
             clearTurnTimer();
-            setStalled(false);
+            setStalledBoth(false);
             setElapsedSecs(0);
-            setPhase("idle");
-            setPhaseDetail("");
+            setPhaseBoth("idle", "");
             // Queue drain (Claude-Code-style): a clean turn auto-sends the next
             // queued follow-up (chaining while the queue is non-empty); a cancelled
             // turn keeps its queue visible but never auto-sends. A steer stranded
@@ -3493,6 +4293,51 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
             return;
         }
+        // 3a2. Session picker (interactive switcher, same pattern as /skills:
+        // type to filter, ↑/↓ + Enter switches, Esc cancels with the live
+        // session completely unchanged). The list is the open-time snapshot —
+        // filtering never touches disk. Enter on an empty filtered list only
+        // prints a widen hint (no switch, no state change).
+        if (selectingSession) {
+            // Rebuilt per keypress from the same render's state the paint uses, so
+            // highlight/filter/paint never disagree mid-tick.
+            const entries = filterSessionEntries(sessionItems, sessionFilterRef.current);
+            if (key.upArrow) {
+                if (entries.length > 0) {
+                    setSessionIndexBoth((sessionIndexRef.current - 1 + entries.length) % entries.length);
+                }
+            }
+            else if (key.downArrow) {
+                if (entries.length > 0) {
+                    setSessionIndexBoth((sessionIndexRef.current + 1) % entries.length);
+                }
+            }
+            else if (key.escape) {
+                setSessionFilterBoth("");
+                setSelectingSession(false);
+            }
+            else if (key.return) {
+                const picked = entries[sessionIndexRef.current];
+                setSessionFilterBoth("");
+                setSelectingSession(false);
+                if (picked) {
+                    exitHistoryBrowse();
+                    switchToSession(picked.id);
+                }
+                else {
+                    pushInfo("(no sessions match — backspace to widen the filter.)");
+                }
+            }
+            else if (key.backspace || key.delete) {
+                setSessionFilterBoth(sessionFilterRef.current.slice(0, -1));
+                setSessionIndexBoth(0);
+            }
+            else if (ch && !key.ctrl && !key.meta && !key.tab) {
+                setSessionFilterBoth(sessionFilterRef.current + ch);
+                setSessionIndexBoth(0);
+            }
+            return;
+        }
         // 3b. Effort picker (/effort): same keyboard pattern as the /model
         // picker (↑/↓ + Enter, Esc cancels).
         if (selectingEffort) {
@@ -3599,7 +4444,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 +4468,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*");
@@ -3631,6 +4484,14 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                         setInputBoth("");
                         runRulesCommand(raw);
                     }
+                    else if (pick.name === "/rename" &&
+                        (inputRef.current === "/rename" || inputRef.current.startsWith("/rename "))) {
+                        // Preserve the typed name (e.g. '/rename "Build auth"'); a bare
+                        // highlighted name falls through to usage.
+                        const raw = inputRef.current;
+                        setInputBoth("");
+                        runRenameCommand(raw);
+                    }
                     else {
                         runSlashCommand(pick.name);
                     }
@@ -3729,7 +4590,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         // compact/queue/steer fire while busy.
         if (key.ctrl && (ch === "p" || ch === "P")) {
             if (!pendingApproval && !pendingQuestion &&
-                !selecting && !selectingSkills && !selectingProvider &&
+                !selecting && !selectingSkills && !selectingSession && !selectingProvider &&
                 !keyPrompt && !baseURLPrompt && !selectingEffort &&
                 !selectingRewind && !selectingRewindScope && !inspecting) {
                 if (paletteOpenRef.current)
@@ -3886,6 +4747,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             !pendingQuestion &&
             !selecting &&
             !selectingSkills &&
+            !selectingSession &&
             !selectingProvider &&
             !keyPrompt &&
             !baseURLPrompt &&
@@ -3911,7 +4773,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                         : `thinking${theme.symbol.ellipsis}`;
     // Slash menu derived for render (mirrors the useInput computation above):
     // commands first, then matching skills as `/skill:name` entries.
-    const slashMenu = !selecting &&
+    // Memoized on every gate input: without this the fuzzy matcher rebuilds
+    // on each 1s tick and tool append even though the menu only depends on
+    // input + overlay state.
+    const slashMenu = useMemo(() => !selecting &&
         !selectingSkills &&
         !selectingEffort &&
         !selectingProvider &&
@@ -3925,7 +4790,23 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         input.startsWith("/") &&
         !input.includes("\n")
         ? buildSlashMenu(input, skillMenu)
-        : { items: [], moreSkills: 0 };
+        : { items: [], moreSkills: 0 }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        selecting,
+        selectingSkills,
+        selectingEffort,
+        selectingProvider,
+        keyPrompt,
+        baseURLPrompt,
+        pendingApproval,
+        pendingQuestion,
+        selectingRewind,
+        selectingRewindScope,
+        slashDismissed,
+        input,
+        skillMenu,
+    ]);
     const filteredSlash = slashMenu.items;
     const slashVisible = filteredSlash.length > 0;
     const slashHi = filteredSlash.length > 0 ? slashIndex % filteredSlash.length : 0;
@@ -3939,9 +4820,21 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // Unified /model picker derived for render (mirrors the useInput
     // computation above): full entries, filtered entries, clamped highlight,
     // and the visible window — the frame never grows past MODEL_PICKER_VISIBLE
-    // rows no matter how many models providers list.
-    const modelEntriesAll = selecting ? buildModelEntries() : [];
-    const modelEntries = selecting ? filterModelEntries(modelEntriesAll, modelFilter) : [];
+    // rows no matter how many providers list. Memoized: the registry walk
+    // (all providers + fallbacks) must not rerun on ticks/appends while open.
+    // Deps cover every read inside buildModelEntries: selecting gate, provider
+    // mirror, live models, auth store (key presence), and the local snapshot
+    // (loopback baseURLs feed the cache keys); cache-ref writes always land
+    // alongside one of these setStates, so the memo can never go stale.
+    const { modelEntriesAll, modelEntries } = useMemo(() => {
+        const all = selecting ? buildModelEntries() : [];
+        return {
+            modelEntriesAll: all,
+            modelEntries: selecting ? filterModelEntries(all, modelFilter) : [],
+        };
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [selecting, provider, models, auth, localSnap, modelFilter]);
     const modelHi = modelEntries.length === 0 ? 0 : Math.max(0, Math.min(selIndex, modelEntries.length - 1));
     const modelWin = pickerWindow(modelEntries.length, modelHi);
     const modelTitle = `Atom — Select model (${modelEntries.length}` +
@@ -3950,13 +4843,47 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // /skills picker derived for render (mirrors the useInput computation
     // above): names only, filtered, clamped highlight, visible window. The
     // title keeps the `Skills (` prefix the registry header always had.
-    const skillEntriesAll = selectingSkills ? skillPickerItems : [];
-    const skillEntries = selectingSkills ? filterSkillPicker(skillEntriesAll, skillFilter) : [];
+    // Memoized for the same tick/append reason as the model picker above.
+    const { skillEntriesAll, skillEntries } = useMemo(() => {
+        const all = selectingSkills ? skillPickerItems : [];
+        return {
+            skillEntriesAll: all,
+            skillEntries: selectingSkills ? filterSkillPicker(all, skillFilter) : [],
+        };
+    }, [selectingSkills, skillPickerItems, skillFilter]);
     const skillHi = skillEntries.length === 0 ? 0 : Math.max(0, Math.min(skillIndex, skillEntries.length - 1));
     const skillWin = pickerWindow(skillEntries.length, skillHi);
     const skillTitle = `Skills (${skillEntries.length}` +
         (skillFilter ? ` of ${skillEntriesAll.length}, filter: "${skillFilter}"` : "") +
         `) — type to filter, up/down + Enter, Esc cancels:`;
+    // /session picker derived for render (mirrors the useInput computation
+    // above): open-time snapshot, filtered in memory, clamped highlight,
+    // visible window. Memoized for the same tick/append reason as the pickers
+    // above. nowMs via Date.now (render-time age labels, never persisted).
+    const { sessionEntriesAll, sessionEntries } = useMemo(() => {
+        const all = selectingSession ? sessionItems : [];
+        return {
+            sessionEntriesAll: all,
+            sessionEntries: selectingSession ? filterSessionEntries(all, sessionFilter) : [],
+        };
+    }, [selectingSession, sessionItems, sessionFilter]);
+    const sessionHi = sessionEntries.length === 0 ? 0 : Math.max(0, Math.min(sessionIndex, sessionEntries.length - 1));
+    const sessionWin = pickerWindow(sessionEntries.length, sessionHi);
+    const sessionPickerTitle = `Sessions (${sessionEntries.length}` +
+        (sessionFilter ? ` of ${sessionEntriesAll.length}, filter: "${sessionFilter}"` : "") +
+        `) — 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]);
+    // Approval description: the tool-call one-liner for the modal. Memoized on
+    // the pending approval itself — the 1s busy tick keeps firing while the
+    // modal waits, and must not rebuild the string (nor re-render the modal).
+    const approvalDescription = useMemo(() => (pendingApproval ? describeToolCall(pendingApproval.name, pendingApproval.args) : ""), [pendingApproval]);
     // (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 +4904,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(LiveTailHost, { store: streamStore, isEmpty: turns.length === 0, sessionHint: sessionHint, emptySessionTitle: turns.length === 0 ? sessionTitle : null, 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: approvalDescription, 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;
@@ -3992,7 +4919,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                         return (_jsxs(PickerRow, { highlighted: i === skillHi, children: ["/skill:", e.name, !e.userInvocable ? _jsx(Text, { dimColor: true, children: " [auto-only]" }) : null] }, `${e.name}-${i}`));
                     }), _jsx(PickerMoreBelow, { count: skillEntries.length - skillWin.end }), skillEntries.length === 0 ? (_jsx(Text, { dimColor: true, children: skillEntriesAll.length === 0
                             ? "No skills installed — add SKILL.md skills under .claude/skills/, .agents/skills/, or the ~/. counterparts."
-                            : "No skills match — backspace to widen the filter." })) : null] })) : selectingProvider ? (_jsx(PickerShell, { title: "Atom \u2014 Select provider (up/down + Enter, Esc cancels):", children: PROVIDERS.map((p, i) => {
+                            : "No skills match — backspace to widen the filter." })) : null] })) : selectingSession ? (_jsxs(PickerShell, { title: sessionPickerTitle, children: [_jsx(PickerMoreAbove, { count: sessionWin.start }), sessionEntries.slice(sessionWin.start, sessionWin.end).map((e, k) => {
+                        const i = sessionWin.start + k;
+                        const age = formatSessionAge(Date.now(), e.updatedAt);
+                        return (_jsxs(PickerRow, { highlighted: i === sessionHi, children: [e.title, e.active ? " (current)" : "", _jsxs(Text, { dimColor: true, children: [" ", "\u00B7 ", e.turnCount, " turn", e.turnCount === 1 ? "" : "s", " \u00B7 ", age] })] }, `${e.id}-${i}`));
+                    }), _jsx(PickerMoreBelow, { count: sessionEntries.length - sessionWin.end }), sessionEntries.length === 0 ? (_jsx(Text, { dimColor: true, children: sessionEntriesAll.length === 0
+                            ? "No sessions yet — your current conversation is saved automatically."
+                            : "No sessions match — backspace to widen the filter." })) : null] })) : selectingProvider ? (_jsx(PickerShell, { title: "Atom \u2014 Select provider (up/down + Enter, Esc cancels):", children: PROVIDERS.map((p, i) => {
                     const has = keyForProvider(p.id).length > 0;
                     const keyMark = isLocalProviderId(p.id)
                         ? `local ${theme.symbol.descSeparator} no key needed`
@@ -4002,7 +4935,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
@@ -4010,5 +4943,5 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             // border color.
             _jsx(InputBox, { input: input, cursor: cursor })), slashVisible && !inspecting && !paletteOpen ? (_jsxs(PickerShell, { title: slashHasSkills
                     ? `Atom commands + skills (${theme.symbol.moreAbove}/${theme.symbol.moreBelow} + Enter/Tab to run, Esc dismisses):`
-                    : `Atom commands (${theme.symbol.moreAbove}/${theme.symbol.moreBelow} + Enter/Tab to run, Esc dismisses):`, borderColor: theme.border.menu, children: [_jsx(PickerMoreAbove, { count: slashWin.start }), filteredSlash.slice(slashWin.start, slashWin.end).map((c) => (_jsxs(PickerRow, { highlighted: c.name === slashHighlight, highlightColor: theme.color.menuSelection, children: [c.name, c.description ? ` ${theme.symbol.descSeparator} ${c.description}` : ""] }, c.name))), _jsx(PickerMoreBelow, { count: filteredSlash.length - slashWin.end }), slashUsage ? _jsx(Text, { dimColor: true, children: slashUsage }) : null, slashMenu.moreSkills > 0 ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.ellipsis, "and ", slashMenu.moreSkills, " more skill", slashMenu.moreSkills === 1 ? "" : "s", " \u2014 keep typing to narrow"] })) : null] })) : null, _jsx(StatusBar, { provider: provider, model: model, usageTotals: usageTotals, contextLoad: contextLoad, reasoningDisplay: reasoningDisplay, mode: mode, trustAll: trustAll, busy: busy, activity: toolHint ? activityText(toolHint) : null, phaseLabel: phaseLabel, elapsedSecs: elapsedSecs, stalled: stalled, approvalPending: pendingApproval !== null, cwd: shortenCwd(process.cwd(), os.homedir()), branch: gitInfo?.branch ?? null, columns: termColumns })] }));
+                    : `Atom commands (${theme.symbol.moreAbove}/${theme.symbol.moreBelow} + Enter/Tab to run, Esc dismisses):`, borderColor: theme.border.menu, children: [_jsx(PickerMoreAbove, { count: slashWin.start }), filteredSlash.slice(slashWin.start, slashWin.end).map((c) => (_jsxs(PickerRow, { highlighted: c.name === slashHighlight, highlightColor: theme.color.menuSelection, children: [c.name, c.description ? ` ${theme.symbol.descSeparator} ${c.description}` : ""] }, c.name))), _jsx(PickerMoreBelow, { count: filteredSlash.length - slashWin.end }), slashUsage ? _jsx(Text, { dimColor: true, children: slashUsage }) : null, slashMenu.moreSkills > 0 ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.ellipsis, "and ", slashMenu.moreSkills, " more skill", slashMenu.moreSkills === 1 ? "" : "s", " \u2014 keep typing to narrow"] })) : null] })) : null, _jsx(StatusBarHost, { provider: provider, model: model, usageTotals: usageTotals, contextLoad: contextLoad, reasoningDisplay: reasoningDisplay, mode: mode, trustAll: trustAll, busy: busy, activity: toolHint ? activityText(toolHint) : null, phaseLabel: phaseLabel, elapsedSecs: elapsedSecs, stalled: stalled, approvalPending: pendingApproval !== null, cwd: shortenCwd(process.cwd(), os.homedir()), branch: gitInfo?.branch ?? null })] }));
 }