atom-agent 0.3.0 → 1.1.0

package/dist/App.js

@@ -1,42 +1,74 @@
 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 React, { useEffect, useRef, useState } from "react";
-import { Box, Static, Text, useApp, useInput } from "ink";
-import { EFFORT_OPTIONS, FALLBACK_MODELS, LoopCancelledError, REASONING_EFFORT_SUPPORTED_MODELS, buildSystemPrompt, fetchModelsForProviderWithStatus, fetchModelsWithStatus, historyChars, isEffortSupported, runAgenticLoopForProvider, truncateHistory, } from "./zen.js";
-import { TOOL_ONE_LINERS, clearTodos, describeToolCall, executeTool, getTodos, needsApproval } from "./tools.js";
-import { checkRules, formatRules, parseRuleInput, } from "./permissions.js";
-import { discoverSkills, loadSkillBody, matchSkills, resolveSkills, skillsListText, } from "./skills.js";
-import { contextWindowFor, formatTokenSegment } from "./context-windows.js";
-import { COMPACT_PCT_DEFAULT, buildCompactedHistory, compactBoundaryLine, compactPct, computeContextLoad, countUserTurns, estimateTokensForChars, isThrashDisabled, requestCompactSummary, shouldAutoCompact, splitHistoryForCompaction, } from "./compact.js";
-import { DEFAULT_PROVIDER, PROVIDERS, chatEndpointFor, getProvider, isProviderId, maskKey, openaiCompatibleChatEndpoint, validateBaseURL, } from "./providers.js";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import React, { useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, usePaste, useStdout } from "ink";
+import { DEFAULT_MODEL, EFFORT_OPTIONS, FALLBACK_MODELS, LoopCancelledError, REASONING_EFFORT_SUPPORTED_MODELS, buildSystemPrompt, fetchModelsForProviderWithStatus, fetchModelsWithStatus, historyChars, isEffortSupported, messageChars, openTodoNeedles, runAgenticLoopForProvider, } from "./zen.js";
+import { createContextManager, trackHistory, } from "./context-manager.js";
+import { assemblePrefix, providerCacheSupport, } from "./prompt-cache.js";
+import { TOOL_DEFINITIONS, TOOL_ONE_LINERS, 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 { 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";
 import { validateProviderKey } from "./adapters.js";
-import { withEnvBlock } from "./env-block.js";
-import { loadSession, saveSession, sessionExists, } from "./session.js";
-import { conversationCutIndex, getCheckpoint, listCheckpoints, registerHistoryProbe, restoreCheckpointFiles, } from "./snapshots.js";
+import { clearKiloModelsCache, isFreeKiloModel, preferFreeKiloModel, } from "./kilo.js";
+import { getGitInfo, withEnvBlock } from "./env-block.js";
+import { loadPrefs, loadSession, saveSession, sessionExists, } from "./session.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 { 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 { theme } from "./ui/theme.js";
+import { TodoPanel } from "./ui/todo-panel.js";
+import { TranscriptView, applyScrollAction } from "./ui/transcript.js";
 // Single registry for the "/" autocomplete menu and the exact-command path.
 export const SLASH_COMMANDS = [
     { name: "/model", description: "Open the model picker." },
+    { name: "/models", description: "Refresh local model discovery (Ollama, LM Studio, llama.cpp)." },
     { name: "/provider", description: "Pick AI provider, paste API key once, chat." },
     {
         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: "/mode", description: "Print the current permission mode." },
-    { name: "/yolo", description: "Toggle yolo mode (tools run without asking). Tab toggles too." },
+    { 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)." },
     { name: "/trust", description: "Toggle session trust: auto-approve write/edit/bash without full yolo (/trust again revokes)." },
-    { name: "/plan", description: "Enter/exit read-only plan mode (explore freely; write/edit/bash blocked; exiting approves the todo plan)." },
     { name: "/allow", description: "Pre-approve a tool pattern this session (e.g. /allow bash:npm test*)." },
     { name: "/deny", description: "Forbid a tool pattern this session — deny wins over trust/yolo (e.g. /deny bash:rm *)." },
     { name: "/rules", description: "List session allow/deny rules (/rules clear wipes them)." },
-    { name: "/clear", description: "Clear the conversation history (keeps session token totals)." },
+    { 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: "/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: "Follow new output as it arrives (/autoscroll on|off; off freezes the view mid-turn)." },
+    { name: "/thinking", description: "Show or hide model thinking in the TUI (rendering only; the turn is untouched)." },
     { name: "/resume", description: "Restore the last saved session (turns, history, settings, usage)." },
+    { name: "/telemetry", description: "Show the local observability summary (sessions, tokens, tools)." },
+    { name: "/dashboard", description: "Write the local observability dashboard page and show its path." },
     { name: "/rewind", description: "Restore files to a session checkpoint (files only; shell side effects are never snapshotted)." },
     { name: "/help", description: "List commands with one-liners." },
     { name: "/exit", description: "Exit Atom." },
@@ -71,8 +103,198 @@ export const SUBMIT_PIPELINE_STAGES = [
         rollbackScope: "post-rollbackTo: the user message, skill context, and loop entries roll back on failure",
     },
 ];
+// Shared usage strings: the exact texts the commands print, hoisted to
+// module scope so the slash-menu argument hints reuse them (no second
+// implementation).
+export const SKILL_USAGE = "usage: /skill:<name> — invoke a skill directly (list with /skills, e.g. /skill:code-review)";
+export const RULE_USAGE = "usage: /allow <tool[:glob]> · /deny <tool[:glob]> · /rules · /rules clear (e.g. /allow bash:npm test*, /deny bash:rm *)";
+export const QUEUE_USAGE = "usage: /queue (list) · /queue clear (wipe) · /steer <text> (steer the running turn, or send when idle)";
+export const STEER_USAGE = "usage: /steer <text> — while busy, injects into the running turn at the next step boundary (the current action finishes first); when idle, sends as a normal turn";
+export const AUTOSCROLL_USAGE = "usage: /autoscroll [on|off] — on (default) follows new output as it arrives; off freezes the view while a turn runs (a `↓ N new` indicator offers the jump back). Bare /autoscroll prints the current state.";
+export const THINKING_USAGE = "usage: /thinking — toggles model-thinking visibility in the TUI (rendering only: shows or hides the committed thinking blocks; the turn, history, and telemetry are untouched).";
 export function filterSlashCommands(prefix) {
-    return SLASH_COMMANDS.filter((c) => c.name.startsWith(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) {
+        const name = c.name.slice(1);
+        if (name.startsWith(q)) {
+            pre.push(c);
+            continue;
+        }
+        const s = fuzzyScore(q, name);
+        if (s !== null)
+            fuzzy.push({ c, s });
+    }
+    // Prefix tier keeps registry order (stable, muscle memory); fuzzy tier
+    // ranks by score, ties by name.
+    fuzzy.sort((a, b) => a.s - b.s || (a.c.name < b.c.name ? -1 : 1));
+    return [...pre, ...fuzzy.map((f) => f.c)];
+}
+// Command palette model (Ctrl+P): one searchable index over the SAME
+// SLASH_COMMANDS registry the menu and runner use — no second command
+// implementation. Filtering reuses fuzzyScore (prefix tier stable, fuzzy
+// scored, description substring); display types live in ui/palette.
+export function paletteEntries(query) {
+    const q = query.trim().toLowerCase().replace(/^\//, "");
+    const out = [];
+    SLASH_COMMANDS.forEach((c, idx) => {
+        const name = c.name.slice(1).toLowerCase();
+        if (!q) {
+            out.push({ c, tier: 0, score: 0, idx });
+            return;
+        }
+        if (name.startsWith(q)) {
+            out.push({ c, tier: 1, score: 0, idx });
+            return;
+        }
+        const s = fuzzyScore(q, name);
+        if (s !== null) {
+            out.push({ c, tier: 2, score: s, idx });
+            return;
+        }
+        if (c.description.toLowerCase().includes(q))
+            out.push({ c, tier: 3, score: 0, idx });
+    });
+    const catOrder = (n) => PALETTE_CATEGORY_ORDER.indexOf(paletteCategory(n));
+    out.sort((a, b) => a.tier - b.tier ||
+        (a.tier === 0
+            ? catOrder(a.c.name) - catOrder(b.c.name) || a.idx - b.idx
+            : a.score - b.score || a.idx - b.idx));
+    return out.map(({ c }) => ({
+        name: c.name,
+        description: c.description,
+        category: paletteCategory(c.name),
+        hint: PALETTE_HINTS[c.name] ?? null,
+    }));
+}
+// 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;
+// /autoscroll and /thinking only flip view flags (never touch the turn).
+// Every other command waits idle.
+export function slashRunsWhileBusy(name) {
+    return (name === "/compact" ||
+        name === "/queue" ||
+        name === "/steer" ||
+        name === "/autoscroll" ||
+        name === "/thinking");
+}
+// Fuzzy subsequence match with gap/start/word-boundary scoring (lower is
+// better; null = no match). Pure — shared by the command filter, the skill
+// tier, and the palette, so there is exactly one matcher.
+export function fuzzyScore(query, target) {
+    const q = query.toLowerCase();
+    const t = target.toLowerCase();
+    if (!q)
+        return 0;
+    let ti = 0;
+    let score = 0;
+    let last = -1;
+    for (let qi = 0; qi < q.length; qi++) {
+        const found = t.indexOf(q[qi], ti);
+        if (found === -1)
+            return null;
+        score += last === -1 ? found : found - last - 1;
+        if (found === 0 || /[-_/:]/.test(t[found - 1]))
+            score -= 2;
+        if (found === last + 1)
+            score -= 1;
+        last = found;
+        ti = found + 1;
+    }
+    return score;
+}
+// Max skill rows in the menu: the command list always renders whole, skills
+// narrow as you type — the menu can never take over the screen.
+export const SLASH_MENU_SKILL_CAP = 8;
+// Pure filter for the /skills picker (unit-tested): case-insensitive
+// substring over the skill name (a search popup narrows harder than the
+// prefix-only slash menu). Empty query returns everything as-is.
+export function filterSkillPicker(entries, query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return entries;
+    return entries.filter((e) => e.name.toLowerCase().includes(q));
+}
+// 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
+// is non-trivial (input length ≥ 2 — a bare `/` lists commands only), and
+// match by skill-name prefix, full `/skill:name` prefix, or fuzzy on the
+// name. Skill rows carry a truncated description for discovery. Pure — the
+// App feeds it the cached registry snapshot.
+export const SKILL_MENU_DESC_CHARS = 60;
+export function buildSlashMenu(input, skills) {
+    const items = filterSlashCommands(input).map((c) => ({
+        name: c.name,
+        description: c.description,
+    }));
+    if (input.length < 2)
+        return { items, moreSkills: 0 };
+    const q = input.slice(1);
+    const skillQ = q.startsWith("skill:") ? q.slice("skill:".length) : q;
+    const pushSkill = (s, shown, more) => {
+        const entry = `/skill:${s.name}`;
+        const desc = s.description.length > SKILL_MENU_DESC_CHARS
+            ? `${s.description.slice(0, SKILL_MENU_DESC_CHARS)}…`
+            : s.description;
+        if (shown.n < SLASH_MENU_SKILL_CAP) {
+            items.push({ name: entry, description: desc, skill: s.name });
+            shown.n += 1;
+        }
+        else {
+            more.n += 1;
+        }
+    };
+    const shown = { n: 0 };
+    const more = { n: 0 };
+    const fuzzy = [];
+    for (const s of skills) {
+        const entry = `/skill:${s.name}`;
+        if (s.name.startsWith(skillQ) || entry.startsWith(input))
+            continue;
+        const score = fuzzyScore(skillQ, s.name);
+        if (score !== null)
+            fuzzy.push({ s, score });
+    }
+    for (const s of skills) {
+        const entry = `/skill:${s.name}`;
+        if (!s.name.startsWith(skillQ) && !entry.startsWith(input))
+            continue;
+        pushSkill(s, shown, more);
+    }
+    fuzzy.sort((a, b) => a.score - b.score || (a.s.name < b.s.name ? -1 : 1));
+    for (const f of fuzzy)
+        pushSkill(f.s, shown, more);
+    return { items, moreSkills: more.n };
+}
+// Argument hints for commands that take them, reusing the exact usage
+// strings the commands themselves print (no second implementation).
+export function commandUsage(name) {
+    switch (name) {
+        case "/allow":
+        case "/deny":
+        case "/rules":
+            return RULE_USAGE;
+        case "/queue":
+            return QUEUE_USAGE;
+        case "/steer":
+            return STEER_USAGE;
+        case "/skill":
+            return SKILL_USAGE;
+        case "/compact":
+            return "Usage: /compact [focus text] — summarize older turns (works while busy; drains at turn end).";
+        default:
+            return null;
+    }
 }
 // Phase 5 observability + latency polish (surgical, three items only):
 // - TURN_TICK_MS: elapsed-time resolution while busy (1s).
@@ -81,10 +303,12 @@ export function filterSlashCommands(prefix) {
 export const TURN_TICK_MS = 1000;
 export const TURN_STALL_AFTER_MS = 3000;
 // Phase 5 models-list session cache key: provider id (+baseURL for
-// openai-compatible, whose list depends on the custom endpoint).
+// openai-compatible, whose list depends on the custom endpoint, and for
+// local runtimes, whose list depends on the loopback server probed).
 export function modelsCacheKey(providerId, baseURL) {
-    if (providerId === "openai-compatible")
+    if (providerId === "openai-compatible" || isLocalProviderId(providerId)) {
         return `${providerId}|${baseURL ?? ""}`;
+    }
     return providerId;
 }
 // Pure helpers for the elapsed/stall indicator (injectable now for tests).
@@ -94,6 +318,56 @@ export function elapsedSecsSince(startMs, nowMs) {
 export function isStalledSince(lastActivityMs, nowMs) {
     return nowMs - lastActivityMs > TURN_STALL_AFTER_MS;
 }
+export function modelPickerEntries(opts) {
+    const out = [];
+    const activeLocal = isLocalProviderId(opts.activeProvider);
+    for (const m of opts.activeModels) {
+        out.push({
+            providerId: opts.activeProvider,
+            model: m,
+            ...(activeLocal ? { local: true } : {}),
+            ...(opts.activeProvider === "kilo" && isFreeKiloModel(m) ? { free: true } : {}),
+        });
+    }
+    for (const p of PROVIDERS) {
+        if (p.id === opts.activeProvider)
+            continue;
+        if (!opts.keyFor(p.id) && providerNeedsKey(p.id))
+            continue;
+        if (p.id === "openai-compatible" && !opts.baseURLFor(p.id))
+            continue;
+        const list = opts.cached(p.id, opts.baseURLFor(p.id)) ?? p.fallbackModels;
+        for (const m of list) {
+            out.push({
+                providerId: p.id,
+                model: m,
+                ...(isLocalProviderId(p.id) ? { local: true } : {}),
+                ...(p.id === "kilo" && isFreeKiloModel(m) ? { free: true } : {}),
+            });
+        }
+    }
+    return out;
+}
+// Case-insensitive substring filter over the model id (the provider id is
+// included so "openai" narrows to that section; "free" matches free Kilo
+// models). Empty query returns the list as-is.
+export function filterModelEntries(entries, query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return entries;
+    return entries.filter((e) => e.model.toLowerCase().includes(q) ||
+        e.providerId.toLowerCase().includes(q) ||
+        (e.free === true && "free".includes(q)));
+}
+// Visible window for the picker: at most MODEL_PICKER_VISIBLE rows, scrolled
+// so the highlight stays visible (centered while scrolling, pinned at both
+// ends). Single implementation in ui/pickers (shared by every windowed
+// popup); re-exported here so existing import sites keep working.
+export { MODEL_PICKER_VISIBLE, pickerWindow } from "./ui/pickers.js";
+// Follow-up queue cap: Enter while busy queues instead of submitting, and
+// the turn-end drain auto-sends while non-empty. Bounded so a held-down key
+// can never flood the session; /queue manages, /queue clear wipes.
+export const QUEUE_CAP = 10;
 // Task B smoothness (a): streaming-draft throttle. Token bursts (many
 // onToken calls per frame) would otherwise re-render the whole tree per
 // token; paints coalesce to at most one per trailing window, with
@@ -181,122 +455,112 @@ export function createDraftThrottler(opts) {
         },
     };
 }
-export function renderTranscriptItem(item) {
-    if (!item.turn)
-        return _jsx(StartupBanner, {}, item.id);
-    const t = item.turn;
-    const i = item.id;
-    if (t.role === "user") {
-        return (_jsxs(Text, { children: [_jsxs(Text, { color: "cyan", bold: true, children: ["you>", " "] }), t.content] }, i));
-    }
-    if (t.role === "tool") {
-        return (_jsx(Text, { color: t.error ? "red" : undefined, dimColor: !t.error, children: t.content }, i));
-    }
-    return (_jsxs(Text, { children: [_jsxs(Text, { color: "magenta", bold: true, children: ["ATOM>", " "] }), t.content] }, i));
-}
-// Render-count probe for the timer-isolation test: incremented on every
-// TranscriptView render (a 1s timer tick must leave it unchanged).
-export const transcriptRenderProbe = { count: 0 };
-export const TranscriptView = React.memo(function TranscriptView({ turns, clearGen, renderItem, }) {
-    transcriptRenderProbe.count += 1;
-    const render = renderItem ?? renderTranscriptItem;
-    const items = clearGen === 0
-        ? [{ id: "banner" }, ...turns.map((turn, idx) => ({ id: `turn-${idx}`, turn }))]
-        : [...turns.map((turn, idx) => ({ id: `turn-${idx}`, turn }))];
-    return (_jsx(Static, { items: items, children: (item) => render(item) }, `transcript-${clearGen}`));
-});
 function toolsListText() {
     const lines = Object.entries(TOOL_ONE_LINERS).map(([n, d]) => `${n} — ${d}`);
     return `Tools (${lines.length}):\n${lines.join("\n")}`;
 }
-// Display window for the live thinking block: reasoning streams can run
-// long, so only the frontier (tail) paints. The full text is never stored
-// anywhere else — thinking stays transient, like the answer draft.
-const THINKING_DISPLAY_CAP = 1200;
-// Live session checklist (Claude-Code-style TodoWrite panel). Mounted in
-// the live area below the transcript (NOT in <Static> scrollback) and fed
-// by a snapshot the loop refreshes after every todowrite/todo_update call,
-// so the in-progress row — shown with its activeForm when present — always
-// answers "what is the model doing right now". Returns null when empty.
-export function TodoPanel({ items }) {
-    if (items.length === 0)
-        return null;
-    const done = items.filter((t) => t.status === "completed").length;
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { bold: true, children: ["Tasks ", done, "/", items.length] }), items.map((t, i) => {
-                const mark = t.status === "completed" ? "✅" : t.status === "in_progress" ? "🔧" : "❌";
-                const label = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
-                return (_jsxs(Text, { dimColor: t.status === "completed", children: [mark, " ", label, t.priority ? ` (${t.priority})` : ""] }, `${i}-${t.content}`));
-            })] }));
-}
+// Live thinking block: reasoning streams in full, exactly as it arrives —
+// the output stays as-is no matter how long it runs (no tail window, no
+// truncation). The full text is never stored anywhere else — thinking stays
+// transient like the answer draft (cleared on every turn boundary, never
+// committed to the transcript or model history).
 export function helpListText() {
     const lines = SLASH_COMMANDS.map((c) => `${c.name} — ${c.description}`);
     return (`Commands:\n${lines.join("\n")}` +
-        `\nTab toggles normal/yolo mode (in the / command menu, Tab runs the highlighted command). Tab never enters or exits plan mode (a stray keypress can't drop the safety mode — use /plan).` +
-        `\n/plan toggles read-only plan mode for risky work: explore with read/grep/glob/webfetch/websearch/todos/ask_question (all run free) while write/edit/bash are blocked pre-execution with a replan note (never a prompt, never silent — the ⚙ audit line still renders). Scoped /deny rules still win in plan mode; /allow, /trust, yolo, [a]lways, and skill grants cannot punch through it (/yolo and /trust while in plan stay read-only with a notice — exit with /plan first). Exiting is the human approval: /plan from plan mode returns to normal (never yolo) and the todowrite checklist recorded while planning carries into implementation.` +
+        `\nTab is the only mode switcher: normal → yolo → plan → normal (in the / command menu, Tab runs the highlighted command instead). Yolo runs tools without asking; plan is read-only.` +
+        `\nPlan mode is the read-only mode for risky work: explore with read/grep/glob/webfetch/websearch/todos/ask_question (all run free) while write/edit/bash are blocked pre-execution with a replan note (never a prompt, never silent — the ⚙ audit line still renders). Scoped /deny rules still win in plan mode; /allow, /trust, yolo, [a]lways, and skill grants cannot punch through it (/trust while in plan stays read-only with a notice — Tab out first). Exiting plan is the human approval: Tab from plan mode returns to normal (never yolo) and the todowrite checklist recorded while planning carries into implementation.` +
         `\n/trust toggles the session trust tier: with trust on, write/edit/bash auto-approve (one approval covers the whole task) without global yolo. Default off, normal mode stays the default; in-memory only, never saved. Every auto-approved call still renders its ⚙ line. The approval prompt also offers [t]rust-all mid-run; [n]/Esc still denies one call, Ctrl+C (or Esc while busy) still cancels the whole turn.` +
         `\n/allow <tool[:glob]> pre-approves matching write/edit/bash calls this session (no prompt; e.g. /allow bash:npm test*, /allow write:src/**; bare /allow bash matches any args). /deny <tool[:glob]> refuses matching calls before execution — the model sees the standard denial result and replans. Deny wins over /trust, yolo, [a]lways, and skill grants. Every auto-approved call still renders its ⚙ line. Rules are in-memory only (like /trust, never saved); /rules lists them, /rules clear wipes them.` +
         `\nToken totals accumulate per session from API-reported usage only: the status line shows \`token: n/a\` until the API reports usage (never estimated, never 0-by-default); with usage it shows \`token: (P%) NK\` — NK is the cumulative session spend in K, P% is the CURRENT context load over the model's verified window (last POST prompt_tokens, else the 4ch/token estimate; models with no verified window show a bare \`token: NK\`, never an invented percent). /clear keeps the totals; /new resets them.` +
         `\n/compact [focus text]: summarize older turns into one \`[Compacted context …]\` summary + keep the newest tail (~8000 estimated tokens, tool outputs capped at 2000 chars). Tiny history (≤1 user turn) reports \`(nothing to compact)\`. Works for unknown-window models (estimate only for the tail split).` +
         `\nAuto-compact: after every completed turn the load is checked; on known-window models with load/window ≥ ${Math.round(COMPACT_PCT_DEFAULT * 100)}% (env ATOM_COMPACT_PCT percent, clamped 50–95, invalid→default) history auto-compacts before the next turn. Unknown-window models never auto-compact — use /compact manually.` +
         `\nThrash guard: 3 auto-compactions without the load dropping below threshold disables auto for the session with \`(auto-compact thrashing — disabled, use /compact or /clear)\`; manual /compact still works and resets the counter on success.` +
-        `\n/provider: pick opencode-zen|openai|anthropic|deepseek|mistral|google-gemini|openai-compatible, paste a key once (stored in ~/.atom/auth.json, env wins). Switching provider keeps session history text; system prompt stays.` +
+        `\n/provider: pick kilo|opencode-zen|openai|anthropic|deepseek|mistral|google-gemini|openai-compatible, paste a key once (stored in ~/.atom/auth.json, env wins). Kilo is the default: its free :free models (e.g. kilo-auto/free) work with no key; a Kilo key unlocks the full catalog. Switching provider keeps session history text; system prompt stays.` +
         `\n/effort options: Default/Low/Medium/High/Max (wire: default/low/medium/high/max; Default omits reasoning_effort).` +
         `\nNote: xhigh was requested but only Max is verified, so the top setting is Max, sent as max.` +
         `\nGating: reasoning_effort is sent ONLY when effort != Default AND the model is one of ${[...REASONING_EFFORT_SUPPORTED_MODELS].join(", ")} AND the provider is opencode-zen; otherwise omitted (setting kept, warning shown, status shows (unsupported)). Effort persists across /model switches.` +
-        `\n/resume: restores the last saved session (turns, history, provider/model/effort/mode, usage totals). Startup never auto-restores — sending a message without /resume starts fresh, and the next completed turn overwrites the save. /clear clears the live session only (the save keeps the pre-clear state until the next completed turn overwrites it). /new saves first, then starts a brand-new session (conversation + counters reset, settings kept) — so /resume right after /new restores the pre-/new conversation. Split: /clear = wipe transcript, keep counters; /new = full fresh conversation + counters reset, previous kept for /resume.` +
+        `\n/resume: restores the last saved session (turns, history, provider/model/effort/mode, usage totals). The conversation never auto-restores — sending a message without /resume starts fresh, and the next completed turn overwrites the save. Your provider/model/effort picks DO persist across restarts automatically (saved on every completed turn and on clean exit; explicit OPENCODE_ZEN_MODEL wins over the saved model). /clear clears the live session only (the save keeps the pre-clear state until the next completed turn overwrites it). /new saves first, then starts a brand-new session (conversation + counters reset, settings kept) — so /resume right after /new restores the pre-/new conversation. Split: /clear = wipe transcript, keep counters; /new = full fresh conversation + counters reset, previous kept for /resume.` +
         `\nSession autosave: every completed turn (and clean exit, plus after each successful compaction) writes ~/.atom/session.json (0600 POSIX, may contain pasted secrets — never commit it); failed/cancelled turns never touch it; a corrupt save loads as "(saved session unreadable — starting fresh)".` +
         `\nBusy status shows the live phase plus elapsed seconds in the status line (· thinking… 4s); >3s without token/tool/phase activity adds a dim waiting… hint (status-bar only, never saved). ` +
         `Reasoning streams in its own dim block above the answer draft while busy (transient — never committed); Esc stops a running response (same rollback as Ctrl+C).` +
-        `\n/rewind: every write/edit auto-snapshots prior bytes (silent, no prompt, no config); /rewind lists the session checkpoints and restores exact bytes (hash-verified, never a model rewrite) — files only, files + conversation, or conversation only. Shell side effects (bash) are explicitly out of scope: commands are never snapshotted and cannot be undone.`);
+        `\n/rewind: every write/edit auto-snapshots prior bytes (silent, no prompt, no config); /rewind lists the session checkpoints and restores exact bytes (hash-verified, never a model rewrite) — files only, files + conversation, or conversation only. Shell side effects (bash) are explicitly out of scope: commands are never snapshotted and cannot be undone.` +
+        `\nQueue + steer (follow-ups without losing flow): Enter while busy queues the message (visible Queued line, auto-sent when the turn ends cleanly — never after a cancel); /queue lists, /queue clear wipes (cap ${QUEUE_CAP}, in-memory only). /steer <text> injects into the RUNNING turn at the next step boundary (the current action finishes first — nothing is aborted); when idle it just sends. A steer stranded by a failed/cancelled turn rejoins the queue front instead of vanishing.` +
+        `\nInput: Ctrl+J inserts a newline (Enter always sends, even multiline); ↑/↓ recalls past prompts across lines (in-memory only, never saved); paste lands verbatim via bracketed paste and never submits; Ctrl+A/E line ends, Ctrl+K/U/W kills; Ctrl+P opens the searchable command palette.` +
+        `\nCtrl+O opens the tool-output inspector (browse past tool calls with full output, durations, and error detail: ↑/↓ selects, Enter expands/collapses, PgUp/PgDn scrolls, Esc closes). Read-only — safe in plan mode.` +
+        `\nObservability (local-only, on by default): every turn is traced — iterations, model calls (API-reported tokens only), tool calls (measured durations, ok/fail per tool), retries, and outcomes — into ~/.atom/telemetry/sessions/ (one small JSON file per session, 0600 POSIX, truncated + secret-scrubbed previews, never full prompts/results). /telemetry prints the summary; /dashboard writes the drill-down page (session → turn → iteration → model/tool call → result, with aggregates, charts, filters, timelines) to ~/.atom/telemetry/dashboard.html — open it in a browser, nothing is uploaded. Off via ATOM_TELEMETRY=0 or "telemetry": {"enabled": false} in atom.json. n/a means not reported (never estimated); cost is always n/a until a provider reports it; tool durations span dispatch→result (including any approval-prompt wait in normal mode).`);
 }
 // Session token totals, accumulated ONLY from usage payloads the API
 // actually reported. Null until the first usage payload arrives (rendered
 // as `token: n/a` — never 0, which would imply measurement). The segment
 // itself lives in ./context-windows.js (single source for the exact
-// `token: (P%) NK` format); the footer status line is its only surface.
-// P% tracks CURRENT context load (last prompt_tokens, else 4ch/token
-// estimate); NK tracks cumulative session spend.
-function formatTokens(usage, model, load) {
-    return formatTokenSegment(usage, model, load);
-}
-// Startup banner: the ATOM block-letter art, rendered once at launch inside
-// <Static> (scrollback, so it scrolls away naturally). FIGlet "ANSI Shadow"
-// ATOM (Unicode box-drawing — needs a monospace font with box-drawing
-// support, which Windows Terminal / ConHost / most terminals have). The art
-// is the whole banner: the footer status line is the sole info bar, so no
-// hint lines live here.
-export const ATOM_ART = [
-    " █████╗ ████████╗ ██████╗ ███╗   ███╗",
-    "██╔══██╗╚══██╔══╝██╔═══██╗████╗ ████║",
-    "███████║   ██║   ██║   ██║██╔████╔██║",
-    "██╔══██║   ██║   ██║   ██║██║╚██╔╝██║",
-    "██║  ██║   ██║   ╚██████╔╝██║ ╚═╝ ██║",
-    "╚═╝  ╚═╝   ╚═╝    ╚═════╝ ╚═╝     ╚═╝",
-];
-export function StartupBanner() {
-    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: ATOM_ART.map((line, i) => (_jsx(Text, { color: "cyan", bold: true, children: line }, i))) }));
+// `token: (P%) NK` format); StatusBar (./ui/status-bar.js) is its only
+// surface. P% tracks CURRENT context load (last prompt_tokens, else
+// 4ch/token estimate); NK tracks cumulative session spend.
+function formatKEst(chars) {
+    return `~${(estimateTokensForChars(chars) / 1000).toFixed(1)}K`;
 }
 // Error screen for a missing key (never print the key itself).
 export function MissingKey() {
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: "red", bold: true, children: "Missing OPENCODE_ZEN_API_KEY." }), _jsx(Text, { children: "Copy .env.example -> set your key from https://opencode.ai/auth" }), _jsx(Text, { children: "Or run the TUI and use /provider to paste a key (stored in ~/.atom/auth.json)." }), _jsx(Text, { dimColor: true, children: "Then run `npm start` again." })] }));
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: theme.color.error, bold: true, children: "Missing OPENCODE_ZEN_API_KEY." }), _jsx(Text, { children: "Copy .env.example -> set your key from https://opencode.ai/auth" }), _jsx(Text, { children: "Or run the TUI and use /provider to paste a key (stored in ~/.atom/auth.json)." }), _jsx(Text, { dimColor: true, children: "Then run `npm start` again." })] }));
 }
-export function App({ apiKey, endpoint, initialModel, initialModels, initialProvider, authHome, skillDirs, now, setIntervalFn, clearIntervalFn, setTimeoutFn, clearTimeoutFn }) {
+// 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;
+export function App({ apiKey, endpoint, initialModel, initialModels, initialProvider, restorePrefs, authHome, skillDirs, configDirs, now, setIntervalFn, clearIntervalFn, setTimeoutFn, clearTimeoutFn, localDiscovery }) {
     const { exit } = useApp();
-    const [model, setModel] = useState(initialModel);
-    const modelRef = useRef(initialModel);
+    // 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
+    // missing/corrupt/unusable save — startup then behaves exactly as before.
+    const [prefs] = useState(() => (restorePrefs ? loadPrefs(authHome, endpoint) : null));
+    // atom.json (project + global, per-key merge): first-run defaults sitting
+    // between saved prefs and compiled defaults —
+    // env/props > save > project > global > default.
+    const [atomConfigLoad] = useState(() => loadAtomConfig(configDirs?.projectDir, configDirs?.homeDir ?? authHome));
+    const atomConfig = atomConfigLoad.config;
+    const resolvedInitialProvider = initialProvider && isProviderId(initialProvider)
+        ? initialProvider
+        : (prefs?.provider ?? atomConfig.provider ?? DEFAULT_PROVIDER);
+    // Fresh-install bootstrap: Kilo (the default) starts on its free routing
+    // model until discovery + the user's pick say otherwise — no paid
+    // credentials required. Other providers keep the compiled default.
+    const resolvedInitialModel = initialModel ??
+        prefs?.model ??
+        atomConfig.model ??
+        (resolvedInitialProvider === "kilo"
+            ? (getProvider("kilo")?.defaultModel ?? DEFAULT_MODEL)
+            : DEFAULT_MODEL);
+    const [model, setModel] = useState(resolvedInitialModel);
+    const modelRef = useRef(resolvedInitialModel);
     const [models, setModels] = useState(initialModels ?? [...FALLBACK_MODELS]);
-    // Active provider (default opencode-zen for backward compat).
-    const [provider, setProvider] = useState(initialProvider && isProviderId(initialProvider) ? initialProvider : DEFAULT_PROVIDER);
-    const providerRef = useRef(initialProvider && isProviderId(initialProvider) ? initialProvider : DEFAULT_PROVIDER);
+    // Active provider (explicit prop wins, then saved prefs, then zen default).
+    const [provider, setProvider] = useState(resolvedInitialProvider);
+    const providerRef = useRef(resolvedInitialProvider);
     // Auth store (env wins at resolve time; file holds pasted keys).
     const [auth, setAuth] = useState(() => loadAuth(authHome));
     const authRef = useRef(auth);
     // Resolved keys/endpoints per active provider. apiKey/endpoint props seed
-    // the zen defaults (tests pass test-key; prod passes env-resolved values).
-    const [activeApiKey, setActiveApiKey] = useState(apiKey);
-    const activeApiKeyRef = useRef(apiKey);
-    const [activeEndpoint, setActiveEndpoint] = useState(endpoint);
-    // Permission mode (normal default, yolo toggled via /yolo). The footer
+    // the zen defaults (tests pass test-key; prod passes env-resolved values);
+    // with restorePrefs the saved key/endpoint seed a restored provider instead.
+    const [activeApiKey, setActiveApiKey] = useState(prefs?.apiKey ?? apiKey);
+    const activeApiKeyRef = useRef(prefs?.apiKey ?? apiKey);
+    // Owner of the seeded/active key: the apiKey/endpoint props seed the zen
+    // defaults (tests pass test-key; prod passes env-resolved values), while
+    // restorePrefs seeds the saved provider's key instead. The fallback below
+    // must never hand one provider's seed to another (e.g. the zen seed to an
+    // anonymous Kilo session) — it applies only to its owner.
+    const activeKeyProviderRef = useRef(prefs?.provider ?? "opencode-zen");
+    const [activeEndpoint, setActiveEndpoint] = useState(prefs?.endpoint ?? endpoint);
+    // Permission mode (normal default, Tab cycles normal → yolo → plan). The footer
     // status line always shows it (plus +trust when the session trust tier is
     // on); modeRef mirrors it for async loop callbacks.
     const [mode, setMode] = useState("normal");
@@ -344,17 +608,95 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // synchronous ref mirror (cursor edits must compose within one tick).
     const [cursor, setCursor] = useState(0);
     const cursorRef = useRef(0);
+    // Submitted-prompt history (↑/↓ recall): in-memory only, never persisted
+    // (prompts may carry pasted secrets). histIndex null = editing fresh;
+    // otherwise an index into inputHist. histStash preserves the unsent draft
+    // while browsing (Down past newest restores it).
+    const inputHistRef = useRef([]);
+    const histIndexRef = useRef(null);
+    const histStashRef = useRef("");
+    function pushInputHistory(text) {
+        inputHistRef.current = pushInputHistoryList(inputHistRef.current, text);
+        histIndexRef.current = null;
+        histStashRef.current = "";
+    }
+    function browseHistoryInput(dir) {
+        const hist = inputHistRef.current;
+        if (hist.length === 0)
+            return;
+        const cur = histIndexRef.current;
+        if (cur === null) {
+            if (dir === 1)
+                return; // already at the newest (fresh draft)
+            histStashRef.current = inputRef.current;
+            const idx = historyOlderIndex(hist, null) ?? hist.length - 1;
+            histIndexRef.current = idx;
+            setInputBoth(hist[idx]);
+            return;
+        }
+        const next = dir === -1 ? historyOlderIndex(hist, cur) : historyNewerIndex(hist, cur);
+        if (next === null) {
+            histIndexRef.current = null;
+            const stash = histStashRef.current;
+            histStashRef.current = "";
+            setInputBoth(stash);
+            return;
+        }
+        histIndexRef.current = next;
+        setInputBoth(hist[next]);
+    }
+    // ↑/↓ in plain input: move between lines when multiline, else browse
+    // submitted-prompt history (recall at the first/last line edge).
+    function moveOrRecall(dir) {
+        const t = inputRef.current;
+        if (t.includes("\n")) {
+            const r = moveVertically(t, cursorRef.current, dir);
+            if (!r.edge) {
+                setCursorBoth(r.offset);
+                return;
+            }
+        }
+        browseHistoryInput(dir);
+    }
     const [selecting, setSelecting] = useState(false);
     const [selIndex, setSelIndex] = useState(0);
     // Same synchronous mirror for the dropdown highlight.
     const selIndexRef = useRef(0);
+    // /model picker type-to-filter (unified cross-provider list): the query
+    // narrows entries live; highlight resets to the top on every keystroke.
+    // Cleared on open and on close (Esc/Enter) so every open starts unfiltered.
+    const [modelFilter, setModelFilter] = useState("");
+    const modelFilterRef = useRef("");
+    function setModelFilterBoth(next) {
+        modelFilterRef.current = next;
+        setModelFilter(next);
+    }
+    // /skills picker (opencode-style searchable popup): type-to-filter over the
+    // resolved registry, ↑/↓ + Enter to load, Esc cancels, windowed like the
+    // model picker so any library size stays navigable. Snapshot state (the
+    // registry always renders — names only, never descriptions).
+    const [selectingSkills, setSelectingSkills] = useState(false);
+    const [skillPickerItems, setSkillPickerItems] = useState([]);
+    const [skillIndex, setSkillIndex] = useState(0);
+    const skillIndexRef = useRef(0);
+    const [skillFilter, setSkillFilter] = useState("");
+    const skillFilterRef = useRef("");
+    function setSkillIndexBoth(next) {
+        skillIndexRef.current = next;
+        setSkillIndex(next);
+    }
+    function setSkillFilterBoth(next) {
+        skillFilterRef.current = next;
+        setSkillFilter(next);
+    }
     // Reasoning-effort picker (/effort): same pattern as the /model picker
-    // (↑/↓ + Enter, Esc cancels). Session state, default Default.
+    // (↑/↓ + Enter, Esc cancels). Saved effort restores with restorePrefs,
+    // else the atom.json default, else Default.
     const [selectingEffort, setSelectingEffort] = useState(false);
     const [effortIndex, setEffortIndex] = useState(0);
     const effortIndexRef = useRef(0);
-    const [effort, setEffort] = useState("default");
-    const effortRef = useRef("default");
+    const [effort, setEffort] = useState(prefs?.effort ?? atomConfig.reasoningEffort ?? "default");
+    const effortRef = useRef(prefs?.effort ?? atomConfig.reasoningEffort ?? "default");
     // /provider picker + key/baseURL prompts (same keyboard pattern).
     const [selectingProvider, setSelectingProvider] = useState(false);
     const [providerIndex, setProviderIndex] = useState(0);
@@ -383,11 +725,201 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     const slashIndexRef = useRef(0);
     const [slashDismissed, setSlashDismissed] = useState(false);
     const slashDismissedRef = useRef(false);
+    // Follow-up queue (Claude-Code-style): Enter while busy appends instead of
+    // submitting; the turn-end drain auto-sends while non-empty and the turn
+    // wasn't cancelled. In-memory only, never persisted (like rules). Rendered
+    // as one dim line above the input so a queued thought is never lost.
+    const [queue, setQueue] = useState([]);
+    const queueRef = useRef([]);
+    function setQueueBoth(next) {
+        queueRef.current = next;
+        setQueue(next);
+    }
+    // Steer (inject into the ACTIVE turn, Claude-Code-style): /steer text while
+    // busy sits here until the loop's next step boundary drains it into history
+    // + transcript (see drainSteer below). Null when idle or nothing pending;
+    // rendered as one dim line while set.
+    const [steerPending, setSteerPending] = useState(null);
+    const steerRef = useRef(null);
+    function setSteerPendingBoth(next) {
+        steerRef.current = next;
+        setSteerPending(next);
+    }
+    // Cancellation latch for the queue drain: a cancelled turn keeps its queue
+    // visible but never auto-sends (the user decides what runs next). Reset at
+    // every submit, set in the cancel path.
+    const turnCancelledRef = useRef(false);
+    // Tool-output inspector (display-only): retained results for the browse +
+    // expand panel (Ctrl+O). Records are appended in onToolActivity from the
+    // existing payloads — execution, ordering, and turn content are untouched.
+    const toolLogRef = useRef([]);
+    const toolSeqRef = useRef(0);
+    const [inspecting, setInspecting] = useState(false);
+    const inspectingRef = useRef(false);
+    function setInspectingBoth(next) {
+        inspectingRef.current = next;
+        setInspecting(next);
+    }
+    const [inspectIndex, setInspectIndex] = useState(0);
+    const inspectIndexRef = useRef(0);
+    function setInspectIndexBoth(next) {
+        inspectIndexRef.current = next;
+        setInspectIndex(next);
+    }
+    const [inspectExpanded, setInspectExpanded] = useState(false);
+    const inspectExpandedRef = useRef(false);
+    function setInspectExpandedBoth(next) {
+        inspectExpandedRef.current = next;
+        setInspectExpanded(next);
+    }
+    const [inspectScroll, setInspectScroll] = useState(0);
+    const inspectScrollRef = useRef(0);
+    function setInspectScrollBoth(next) {
+        inspectScrollRef.current = next;
+        setInspectScroll(next);
+    }
+    function openInspector() {
+        if (toolLogRef.current.length === 0) {
+            pushInfo("(no tool calls yet — run something first, then Ctrl+O to inspect)");
+            return;
+        }
+        setInspectIndexBoth(0);
+        setInspectExpandedBoth(false);
+        setInspectScrollBoth(0);
+        setInspectingBoth(true);
+    }
+    function closeInspector() {
+        setInspectingBoth(false);
+    }
+    // Command palette (Ctrl+P): unified searchable commands. Own filter +
+    // highlight (the main input stays untouched behind it); Enter runs
+    // through runSlashCommand with the shared busy-gate.
+    const [paletteOpen, setPaletteOpen] = useState(false);
+    const paletteOpenRef = useRef(false);
+    function setPaletteOpenBoth(next) {
+        paletteOpenRef.current = next;
+        setPaletteOpen(next);
+    }
+    const [paletteFilter, setPaletteFilter] = useState("");
+    const paletteFilterRef = useRef("");
+    function setPaletteFilterBoth(next) {
+        paletteFilterRef.current = next;
+        setPaletteFilter(next);
+    }
+    const [paletteIndex, setPaletteIndex] = useState(0);
+    const paletteIndexRef = useRef(0);
+    function setPaletteIndexBoth(next) {
+        paletteIndexRef.current = next;
+        setPaletteIndex(next);
+    }
+    function openPalette() {
+        setPaletteFilterBoth("");
+        setPaletteIndexBoth(0);
+        setPaletteOpenBoth(true);
+    }
+    function closePalette() {
+        setPaletteOpenBoth(false);
+    }
+    // Transcript scrollback viewport (null = follow the bottom; a number =
+    // viewed end index = held/manual mode). New turns extend a following view
+    // automatically and accumulate below a held one (the `↓ N new` indicator
+    // offers the jump back). Held also freezes the live tail's growing
+    // draft/thinking blocks to one static line (see LiveTail `held`), so a
+    // streaming turn stops yanking the terminal while the user reads back.
+    // List replacement (/clear, /resume, /new) and rewind-truncate re-follow
+    // explicitly. The inspector never touches this (position preserved while
+    // inspecting).
+    const [scrollEnd, setScrollEnd] = useState(null);
+    const scrollEndRef = useRef(null);
+    function setScrollEndBoth(next) {
+        scrollEndRef.current = next;
+        setScrollEnd(next);
+    }
+    // Thinking visibility (the /thinking toggle, rendering-only, default
+    // hidden): committed thinking turns + the live thinking block show only
+    // while on. Never touches the turn, history, or telemetry — purely paint.
+    const [showThinking, setShowThinking] = useState(false);
+    const showThinkingRef = useRef(false);
+    function setShowThinkingBoth(next) {
+        showThinkingRef.current = next;
+        setShowThinking(next);
+    }
+    // /autoscroll (session-only, default on). On = today's behavior: a
+    // following view extends with every appended turn. Off = appends during a
+    // busy turn freeze a following view at its current end instead of yanking
+    // it (the `↓ N new` indicator offers the jump back; End resumes). Idle
+    // appends always follow — freezing only matters while output streams.
+    const [autoScroll, setAutoScroll] = useState(true);
+    const autoScrollRef = useRef(true);
+    function setAutoScrollBoth(next) {
+        autoScrollRef.current = next;
+        setAutoScroll(next);
+    }
+    // Skill registry (cached metadata): one instance per App, scoped to the
+    // same dirs the suite injects via skillDirs. Every discovery path below
+    // reads through it — refresh() revalidates by stat (mtime+size) and only
+    // re-reads added/modified entries, so per-message cost drops from ~1MB of
+    // SKILL.md reads to a directory listing plus stats. Bodies stay lazy
+    // (activateSkill → loadSkillBody, on demand only).
+    const [skillRegistry] = useState(() => createSkillRegistry({ projectDir: skillDirs?.projectDir, homeDir: skillDirs?.homeDir }));
+    // Skill entries for the slash menu (namespaced `/skill:name` commands):
+    // a snapshot of user-invocable skills (name + description), refreshed on
+    // mount, /skills, /clear, and /new — never per keystroke (disk I/O stays
+    // out of the typing path). Empty until the first refresh lands.
+    const [skillMenu, setSkillMenu] = useState([]);
+    async function refreshSkillMenu() {
+        try {
+            const found = await skillRegistry.refresh();
+            const { skills } = resolveSkills(found.skills);
+            setSkillMenu(skills
+                .filter((s) => s.userInvocable)
+                .map((s) => ({ name: s.name, description: s.description })));
+        }
+        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.
     const [pendingApproval, setPendingApproval] = useState(null);
     const approvalResolveRef = useRef(null);
+    // Approval highlight (0..3 = once/always/trust-all/deny): arrows + Enter
+    // select, y/a/t/n shortcut (unchanged). Display-only; reset on every open.
+    const [approveIndex, setApproveIndex] = useState(0);
+    const approveIndexRef = useRef(0);
+    function setApproveIndexBoth(next) {
+        approveIndexRef.current = next;
+        setApproveIndex(next);
+    }
     // ask_question modal: the loop waits until the user picks, types a custom
     // answer (allowCustom), cancels with Esc (question-cancel result), or
     // cancels the whole turn with Ctrl+C (LoopCancelledError).
@@ -403,7 +935,30 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // tool finishes — no new POSTs, no new executions — then the turn rolls
     // back and a dim `(cancelled)` line renders.
     const turnCancelRef = useRef(null);
+    // Display-only tool clock (TUI timing, never execution logic): wall-ms
+    // when the current tool call started, via the injectable `now` clock.
+    // Consumed by onToolActivity into Turn.ms and by the live running line;
+    // parallel batches share it (last start wins — approximate, display-only).
+    const toolStartRef = useRef(null);
+    // Latest streamed answer text (display bookkeeping only): if the turn
+    // FAILS after streaming (rate limits, dead network), the catch path
+    // commits this as a marked partial turn so the output never vanishes.
+    // History still rolls back (the model never sees it); the transcript
+    // keeps what the user already read. Cleared at every turn start.
+    const lastPartialRef = useRef("");
     const [error, setError] = useState(null);
+    // Local observability recorder (src/telemetry.ts): one telemetry session
+    // per App mount. Best-effort and never throwing; off via ATOM_TELEMETRY=0
+    // or atom.json telemetry.enabled=false. The loop reports into it through a
+    // per-turn sink (see submit); one small file per session lands under
+    // ~/.atom/telemetry/sessions/ on turn boundaries.
+    const [telemetry] = useState(() => createTelemetryRecorder({
+        home: authHome,
+        enabled: resolveTelemetryEnabled(process.env, atomConfig.telemetry?.enabled),
+        provider: resolvedInitialProvider,
+        model: resolvedInitialModel,
+        secrets: providerSecrets,
+    }));
     // Session token totals from real API usage payloads only (null = none
     // reported yet -> `token: n/a`). Survives /clear by design (see /help).
     const [usageTotals, setUsageTotals] = useState(null);
@@ -414,6 +969,18 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // completes. NK stays cumulative; P must NOT use the cumulative total.
     const [contextLoad, setContextLoad] = useState(null);
     const contextLoadRef = useRef(null);
+    // Git identity for the status bar (branch only, no status porcelain):
+    // refreshed at turn boundaries (a turn's bash may switch branches), read
+    // from render. Null outside git repos — the bar then shows cwd alone.
+    const [gitInfo, setGitInfo] = useState(null);
+    function refreshGitInfo() {
+        try {
+            setGitInfo(getGitInfo(process.cwd()));
+        }
+        catch {
+            setGitInfo(null);
+        }
+    }
     // Last POST's reported prompt_tokens (load metric source). Summary-request
     // usage never touches this — only main-loop POSTs do.
     const lastPromptTokensRef = useRef(undefined);
@@ -427,7 +994,8 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // never mid-turn. Null = none pending.
     const pendingCompactRef = useRef(null);
     // Startup hint: a save file exists from a previous session. Rendered once
-    // as a dim line while the transcript is empty; startup never auto-restores.
+    // 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));
     // Reasoning label from response metadata (via onReasoning). The status
     // line shows the session effort when non-Default (plus " (unsupported)"
@@ -440,10 +1008,28 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // tool name before its execution line lands.
     const [draft, setDraft] = useState(null);
     // Thinking channel (onThinking): reasoning text streamed apart from the
-    // answer, rendered in its own dim block below. Transient like `draft` —
-    // cleared on every turn boundary below — and never committed to the
-    // transcript or the model history.
+    // answer, rendered in its own dim block below. The live value is transient
+    // like `draft` — cleared on every turn boundary below — but each completed
+    // round commits to the transcript via commitThinking (stays in the TUI,
+    // never the model history) instead of being replaced and lost.
     const [thinking, setThinking] = useState(null);
+    const thinkingRef = useRef(null);
+    // Move the accumulated round thinking into the transcript as a quiet
+    // annotation turn (no-op when empty). Called when a new POST starts and at
+    // turn end, so every round's reasoning stays visible; the /thinking toggle
+    // only controls rendering, never this record.
+    function commitThinking() {
+        const text = thinkingRef.current;
+        thinkingRef.current = null;
+        setThinking(null);
+        if (typeof text === "string" && text.length > 0) {
+            appendTurns({ role: "assistant", content: text, thinking: true });
+        }
+    }
+    function clearThinking() {
+        thinkingRef.current = null;
+        setThinking(null);
+    }
     const [phase, setPhase] = useState("idle");
     const [phaseDetail, setPhaseDetail] = useState("");
     const [toolHint, setToolHint] = useState(null);
@@ -477,6 +1063,72 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // 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());
+    // Local model discovery (Ollama / LM Studio / llama.cpp): one instance
+    // per App (injectable for tests), probed in the background on mount.
+    // Results land in the session models cache above, so the /model picker
+    // serves them through the standard entries path — no parallel registry.
+    const localDiscoveryRef = useRef(localDiscovery ?? createLocalDiscovery());
+    const [localSnap, setLocalSnap] = useState(() => localDiscoveryRef.current.snapshot());
+    const localSnapRef = useRef(localSnap);
+    function setLocalSnapBoth(next) {
+        localSnapRef.current = next;
+        setLocalSnap(next);
+    }
+    // Fold a discovery snapshot into the models cache: reachable providers
+    // contribute their model ids (keyed with their loopback baseURL);
+    // unreachable providers are evicted so stale entries vanish on refresh.
+    function applyLocalSnapshot(snap) {
+        for (const id of ["ollama", "lmstudio", "llamacpp"]) {
+            const r = snap.results[id];
+            const key = modelsCacheKey(id, r.baseURL);
+            if (r.ok) {
+                modelsCacheRef.current.set(key, r.models.map((m) => m.id));
+            }
+            else {
+                modelsCacheRef.current.delete(key);
+            }
+        }
+        setLocalSnapBoth(snap);
+    }
+    // Non-blocking refresh kick: shared in-flight promise dedupes overlapping
+    // calls (mount + picker-open + /models), so servers are never probed twice.
+    function kickLocalDiscovery() {
+        if (initialModels)
+            return;
+        // Suites stay hermetic regardless of loopback servers on the dev
+        // machine: under Vitest only an explicitly injected fake may probe.
+        if (!localDiscovery && process.env.VITEST)
+            return;
+        void localDiscoveryRef.current.refresh().then((snap) => {
+            applyLocalSnapshot(snap);
+        }, () => {
+            // Discovery never rejects (per-provider isolation), but a defensive
+            // catch keeps an unexpected throw from surfacing unhandled.
+        });
+    }
+    // Clear error when the active local server is known-unreachable: the
+    // server disappeared after discovery (or was never reachable). Returns
+    // the notice, or null when local routing is fine.
+    function localUnreachableNotice(id) {
+        if (!isLocalProviderId(id))
+            return null;
+        const r = localSnapRef.current.results[id];
+        if (r.ok)
+            return null;
+        const name = getProvider(id)?.name ?? id;
+        return `${name} is unreachable at ${r.baseURL} — start the server, then run /models refresh.`;
+    }
+    // Loopback baseURL for chat/submit paths (env override wins, else the
+    // probed snapshot base, else the compiled default).
+    function localBaseURL(id) {
+        const snapBase = localSnapRef.current.results[id]?.baseURL;
+        return localBaseURLFor(id, snapBase);
+    }
+    function chatBaseURL(id) {
+        return isLocalProviderId(id)
+            ? localBaseURL(id)
+            : getStoredBaseURL(authRef.current, id);
+    }
     // Phase 5: elapsed + stall indicator (status-bar only, never transcript).
     // `elapsedSecs` ticks at 1s resolution while busy; `stalled` turns true
     // when no token/tool/phase activity arrives for >3s mid-turn and clears
@@ -493,9 +1145,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // subset. Failed user turns are popped (rollback) — but only when the
     // HTTP POST itself fails; tool errors are results the model sees and
     // are never rolled back.
-    const historyRef = useRef([
-        { role: "system", content: withEnvBlock(systemPrompt) },
-    ]);
+    // Tracked from birth: every later push/splice/index-assign flows through
+    // the ContextLedger traps, so per-step accounting stays O(1). Replacements
+    // below re-wrap via trackHistory (never assign a raw array here).
+    const historyRef = useRef(trackHistory([{ role: "system", content: withEnvBlock(systemPrompt) }]));
     // Task 6 per-turn env block (cwd, git branch/status, node, timestamp):
     // pinned to history[0] (the only slot truncateHistory never drops), NEVER
     // to user content. Refreshed once per turn in submit() + after doResume, so
@@ -537,7 +1190,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         }
         else {
             const p = providerRef.current;
-            const baseURL = getStoredBaseURL(authRef.current, p);
+            // Local runtimes resolve loopback baseURLs here too, so the mount
+            // fetch and the discovery refresh share one cache key per server.
+            const baseURL = chatBaseURL(p);
             const cacheKey = modelsCacheKey(p, baseURL);
             const cached = modelsCacheRef.current.get(cacheKey);
             if (cached) {
@@ -546,7 +1201,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     cancelled = true;
                 };
             }
-            const k = resolveApiKey(p, authRef.current) || activeApiKeyRef.current;
+            // Owner-gated seed: an anonymous Kilo mount must not inherit the
+            // zen-seeded prop key (see keyForProvider).
+            const k = keyForProvider(p);
             void fetchModelsForProviderWithStatus(p, k, baseURL, endpoint).then(({ models: list, ok }) => {
                 if (cancelled)
                     return;
@@ -559,8 +1216,31 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             cancelled = true;
         };
     }, [endpoint, apiKey, initialModels]);
+    // Slash-menu skill snapshot once on mount (local disk reads only —
+    // zero fetches; refreshed on /skills, /clear, /new below).
+    useEffect(() => {
+        void refreshSkillMenu();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Local model discovery once on mount (background, non-blocking: the
+    // probes race with first paint and merge into the models cache when they
+    // land — the /model picker then serves local entries with zero extra
+    // fetches. Skipped in tests via initialModels, like the live list above).
+    useEffect(() => {
+        kickLocalDiscovery();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
     // Phase 5: turn timer helpers (injectable now/timers for tests). The
     // interval handle is always cleared on turn end and on unmount.
+    // clockNow shares the injectable `now` (display timestamps only).
+    function clockNow() {
+        try {
+            return (now ?? Date.now)();
+        }
+        catch {
+            return Date.now();
+        }
+    }
     function clearTurnTimer() {
         const h = turnTimerRef.current;
         if (h !== null) {
@@ -621,6 +1301,16 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // in that gap; runLoopWithChat checks the signal before the first POST).
     useEffect(() => {
         return () => {
+            // Local observability: close the session trace on unmount (covers
+            // every exit path — /exit, Ctrl+C idle, test teardown) and flush.
+            // Best-effort, never throws; idempotent with closeTelemetry callers.
+            try {
+                telemetry.endSession();
+            }
+            catch {
+                // ignore
+            }
+            persistTelemetry();
             try {
                 turnCancelRef.current?.abort();
             }
@@ -658,16 +1348,21 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
     function setInputAndCursor(next, cursorPos) {
+        const prev = inputRef.current;
         inputRef.current = next;
         setInput(next);
         const clamped = Math.max(0, Math.min(cursorPos, next.length));
         cursorRef.current = clamped;
         setCursor(clamped);
-        // Any edit restarts menu filtering from the top and re-opens the menu.
-        slashIndexRef.current = 0;
-        setSlashIndex(0);
-        slashDismissedRef.current = false;
-        setSlashDismissed(false);
+        // Slash-prefixed edits restart menu filtering from the top and re-open
+        // the menu; plain-text edits skip the two menu setStates entirely so a
+        // keystroke is always input+cursor only (one batched render).
+        if (next.startsWith("/") || prev.startsWith("/")) {
+            slashIndexRef.current = 0;
+            setSlashIndex(0);
+            slashDismissedRef.current = false;
+            setSlashDismissed(false);
+        }
     }
     function setInputBoth(next) {
         // Append-style callers (and clear/Esc/submit reset): cursor to end.
@@ -679,10 +1374,16 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setCursor(clamped);
     }
     // Cursor-aware edits (plain input + slash menu): typing inserts AT the
-    // cursor, backspace deletes BEFORE it, Delete removes AT it.
+    // cursor, backspace deletes BEFORE it, Delete removes AT it. Every edit
+    // abandons history browse (typing starts a fresh draft; the stash keeps
+    // the pre-browse text for Down-past-newest, which re-stashes on re-entry).
+    function exitHistoryBrowse() {
+        histIndexRef.current = null;
+    }
     function insertAtCursor(text) {
         if (!text)
             return;
+        exitHistoryBrowse();
         const cur = inputRef.current;
         const at = Math.max(0, Math.min(cursorRef.current, cur.length));
         setInputAndCursor(cur.slice(0, at) + text + cur.slice(at), at + text.length);
@@ -692,6 +1393,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         const at = Math.max(0, Math.min(cursorRef.current, cur.length));
         if (at <= 0)
             return;
+        exitHistoryBrowse();
         setInputAndCursor(cur.slice(0, at - 1) + cur.slice(at), at - 1);
     }
     function deleteAtCursor() {
@@ -699,6 +1401,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         const at = Math.max(0, Math.min(cursorRef.current, cur.length));
         if (at >= cur.length)
             return;
+        exitHistoryBrowse();
         setInputAndCursor(cur.slice(0, at) + cur.slice(at + 1), at);
     }
     function setSelIndexBoth(next) {
@@ -749,9 +1452,11 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         authRef.current = next;
         setAuth(next);
     }
-    function setActiveKeyBoth(next) {
+    function setActiveKeyBoth(next, owner) {
         activeApiKeyRef.current = next;
         setActiveApiKey(next);
+        if (owner !== undefined)
+            activeKeyProviderRef.current = owner;
     }
     function setProviderIndexBoth(next) {
         providerIndexRef.current = next;
@@ -779,13 +1484,21 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         const resolved = resolveApiKey(id, authRef.current);
         if (resolved)
             return resolved;
-        if (id === providerRef.current && activeApiKeyRef.current) {
+        // Seeded-key fallback, owner-gated (see activeKeyProviderRef): the
+        // startup seed belongs to exactly one provider and must never leak
+        // into another's requests (notably anonymous Kilo sessions).
+        if (id === providerRef.current &&
+            id === activeKeyProviderRef.current &&
+            activeApiKeyRef.current) {
             return activeApiKeyRef.current;
         }
         return "";
     }
     function closeAllPickers() {
         setSelecting(false);
+        setModelFilterBoth("");
+        setSelectingSkills(false);
+        setSkillFilterBoth("");
         setSelectingEffort(false);
         setSelectingProvider(false);
         setKeyPromptBoth(null);
@@ -794,6 +1507,46 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setSelectingRewindScope(false);
         pendingRewindRef.current = null;
     }
+    // /skills picker (opencode-style searchable popup): opens on the fresh
+    // registry (names only), filters as you type, loads on Enter. Local disk
+    // reads only — zero fetches. Idle-only (history injection mid-turn would
+    // break the loop's assistant/tool pairing).
+    function openSkillPicker() {
+        setInputBoth("");
+        closeAllPickers();
+        setSkillFilterBoth("");
+        setSkillIndexBoth(0);
+        void skillRegistry.refresh().then((found) => {
+            if (busyRef.current) {
+                pushInfo("Skills load when idle — wait for the turn to finish.");
+                return;
+            }
+            const { skills } = resolveSkills(found.skills);
+            setSkillPickerItems(skills.map((s) => ({ name: s.name, userInvocable: s.userInvocable, source: s.source })));
+            setSelectingSkills(true);
+            void refreshSkillMenu();
+        }, () => {
+            // Discovery never throws by contract, but a rejection must never
+            // become an unhandled rejection (Node kills the process) — surface it.
+            pushInfo("(skill discovery failed — no skills listed)");
+        });
+    }
+    // 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,
+    // the picker input branch, and the picker render: all three run on the
+    // same render's state, so open/highlight/filter/paint always agree.
+    function buildModelEntries() {
+        return modelPickerEntries({
+            activeProvider: providerRef.current,
+            activeModels: models,
+            cached: (id, baseURL) => modelsCacheRef.current.get(modelsCacheKey(id, baseURL)),
+            keyFor: (id) => keyForProvider(id),
+            // Local runtimes resolve loopback baseURLs (env/defaults), so cache
+            // reads hit the same keys discovery writes.
+            baseURLFor: (id) => chatBaseURL(id),
+        });
+    }
     function openProviderPicker() {
         setSelecting(false);
         setSelectingEffort(false);
@@ -831,10 +1584,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // reuse the cached live list when available (zero fetches), else fetch
     // the live list and cache successes; failures fall back uncached.
     // /model always reflects the switched-to provider instantly from cache
-    // when available. Keep current model if valid else provider default.
-    async function switchProviderWithKey(pickedId, apiKeyValue) {
+    // when available. Keep current model if valid else provider default —
+    // unless preserveModel names an explicit pick (cross-provider /model
+    // selection), which wins unconditionally so the user's pick sticks even
+    // before the background live refresh lands.
+    async function switchProviderWithKey(pickedId, apiKeyValue, preserveModel) {
         const def = getProvider(pickedId);
-        const baseURL = getStoredBaseURL(authRef.current, pickedId);
+        const baseURL = chatBaseURL(pickedId);
         const cacheKey = modelsCacheKey(pickedId, baseURL);
         const cached = modelsCacheRef.current.get(cacheKey);
         let list;
@@ -853,16 +1609,16 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
         }
         setModels(list);
-        const nextModel = list.includes(modelRef.current)
+        const nextModel = preserveModel ?? (list.includes(modelRef.current)
             ? modelRef.current
-            : def.defaultModel;
+            : def.defaultModel);
         setModelBoth(nextModel);
         setProviderBoth(pickedId);
         // Provider switch resets the load latch: the last reported prompt_tokens
         // belonged to the old provider/model tokenizer, so the estimate applies
         // until the new provider reports (usageTotals spend is untouched).
         resetContextLoadToEstimate();
-        setActiveKeyBoth(apiKeyValue);
+        setActiveKeyBoth(apiKeyValue, pickedId);
         if (pickedId === "openai-compatible") {
             setActiveEndpoint(openaiCompatibleChatEndpoint(baseURL));
         }
@@ -881,6 +1637,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setTurns(next);
     }
     function appendTurns(...items) {
+        // Autoscroll off + busy + following: freeze the view at its current end
+        // BEFORE appending, so streaming output accumulates below instead of
+        // yanking the viewport (smooth-scroll hold). Idle appends and already-
+        // held views pass through untouched.
+        if (!autoScrollRef.current && busyRef.current && scrollEndRef.current === null) {
+            setScrollEndBoth(turnsRef.current.length);
+        }
         const next = [...turnsRef.current, ...items];
         turnsRef.current = next;
         setTurns(next);
@@ -905,7 +1668,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             setContextLoadBoth(null);
             return null;
         }
-        const load = computeContextLoad(lastPromptTokensRef.current, historyChars(historyRef.current));
+        const load = contextManager().usage(historyRef.current, lastPromptTokensRef.current).loadTokens;
         setContextLoadBoth(load);
         return load;
     }
@@ -925,48 +1688,128 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     function pushInfo(content) {
         appendTurns({ role: "tool", content });
     }
-    // Load a resolved skill into the session (tickets 03/06): the body (+any
-    // inlined references) enters model history as one marked message and the
-    // transcript turn, and its `allowed-tools` become turn-scoped grants in
-    // skillGrantsRef (unioned — several skills may load in one turn). Never
-    // throws: loadSkillBody degrades to empty text, surfaced plainly.
-    async function activateSkill(info) {
-        const loaded = await loadSkillBody(info);
+    // The session's ContextManager: window-derived budgets for the active
+    // model, measured tool schemas, configured ceilings. Built fresh per call
+    // (pure math, no I/O beyond the resolved ceiling sources) so it always sees
+    // the current model; history is measured live on every use. The schema size
+    // is memoized once — TOOL_DEFINITIONS never changes at runtime, so every
+    // turn must not re-serialize 15KB to ask.
+    function contextManager() {
+        return createContextManager({
+            model: modelRef.current,
+            toolsChars: TOOLS_SCHEMA_CHARS,
+        });
+    }
+    // /context (Claude-Code-style visibility): where the tokens are going, by
+    // source — system prompt, tool schemas, history, skill injections — plus
+    // the budget and compaction posture. All estimates use the 4ch/token
+    // heuristic (honest `token: n/a` accounting is untouched); all reads are
+    // local, so the command costs zero fetches.
+    function buildContextText() {
+        const hist = historyRef.current;
+        const first = hist[0];
+        const sysChars = first && typeof first.content === "string"
+            ? messageChars(first)
+            : 0;
+        const toolsChars = TOOLS_SCHEMA_CHARS;
+        const mgr = contextManager();
+        const u = mgr.usage(hist, lastPromptTokensRef.current);
+        const b = mgr.budget(hist);
+        const skillLoads = hist.filter((m) => m?.role === "user" &&
+            typeof m.content === "string" &&
+            m.content.includes('[skill "')).length;
+        const loadLine = u.loadPct !== undefined && b.windowTokens !== undefined
+            ? `load: ${formatKEst(u.historyChars)} (${u.loadPct}% of ${(b.windowTokens / 1000).toFixed(0)}K verified window)`
+            : `load: ${formatKEst(u.historyChars)} (no verified window — auto-compact off, use /compact manually)`;
+        const cfg = atomConfigLoad;
+        const cfgSources = cfg.sources.project && cfg.sources.global
+            ? "project + global"
+            : cfg.sources.project
+                ? "project"
+                : cfg.sources.global
+                    ? "global"
+                    : "none";
+        const cfgKeys = Object.keys(atomConfig).length;
+        const cfgLine = `config: atom.json (${cfgSources}${cfgKeys > 0 ? `, ${cfgKeys} key${cfgKeys === 1 ? "" : "s"}` : ", defaults"})` +
+            (cfg.warnings.length > 0 ? `\nconfig warnings:\n${cfg.warnings.map((w) => `- ${w}`).join("\n")}` : "");
+        // Prefix-cache instrumentation (estimates + reported-only hits — a
+        // provider that reports nothing shows "(not reported)", never zeros).
+        // stableTokens are tokens; formatKEst takes chars, hence the ×4 round-trip.
+        const caps = providerCacheSupport(providerRef.current);
+        const prefix = first && typeof first.content === "string"
+            ? assemblePrefix({
+                systemContent: first.content,
+                toolsJson: JSON.stringify(TOOL_DEFINITIONS),
+            })
+            : null;
+        const totals = usageRef.current;
+        const cacheHits = totals?.cacheReadTokens !== undefined || totals?.cacheWriteTokens !== undefined
+            ? `read ${formatKEst((totals?.cacheReadTokens ?? 0) * 4)} / written ${formatKEst((totals?.cacheWriteTokens ?? 0) * 4)}`
+            : "not reported by provider";
+        const cacheLine = prefix !== null
+            ? `cache: ${formatKEst(prefix.stableTokens * 4)} stable/cacheable (fp ${prefix.fingerprint.slice(0, 12)}) + ${formatKEst(prefix.dynamicSystem !== null ? prefix.dynamicSystem.length : 0)} dynamic env · ${caps.explicitBreakpoints ? "explicit breakpoints" : caps.implicitPrefix ? "implicit prefix" : "no caching assumed"} · hits: ${cacheHits}`
+            : `cache: (no system message) · hits: ${cacheHits}`;
+        return (`Context (model ${modelRef.current}):\n` +
+            `system: ${formatKEst(sysChars)} (base + AGENTS overlay + env block)\n` +
+            `tools: ${TOOL_DEFINITIONS.length} defs, ${formatKEst(toolsChars)}\n` +
+            `history: ${u.historyMessages} messages / ${u.userTurns} user turns, ${formatKEst(u.historyChars)}\n` +
+            `skill injections live in history: ${skillLoads}\n` +
+            `${cfgLine}\n` +
+            `${cacheLine}\n` +
+            `${loadLine} · budget: ${b.effectiveMaxMessages} msgs / ${(b.effectiveMaxChars / 1000).toFixed(0)}K chars`);
+    }
+    // Load a resolved skill into the session (tickets 03/06) with
+    // progressive-disclosure tiers (Claude-Code-style):
+    // - manual (explicit user invocation): full body + inlined references enter
+    //   model history as one marked message (the user asked for the whole skill).
+    // - auto (description match): Tier 2 only — body without inlined references
+    //   (the model reads references/<…> via read when needed), capped at
+    //   AUTO_SKILL_BODY_CAP so a trigger can never flood the window.
+    // Both paths print ONE transcript line (never the body — the TUI stays
+    // calm no matter how large the skill is); `allowed-tools` become
+    // turn-scoped grants per the skill-grant trust policy (global skills arm,
+    // project skills never do — see skillGrantsFor). Never throws:
+    // loadSkillBody degrades to empty text, surfaced plainly.
+    async function activateSkill(info, opts) {
+        const auto = opts?.auto === true;
+        const loaded = await loadSkillBody(info, auto ? { inlineRefs: false } : undefined);
         if (loaded.text.trim().length === 0) {
             pushInfo(`Skill "${info.name}" has an empty body — nothing loaded.`);
             return;
         }
-        for (const t of loaded.info.allowedTools)
+        const { grants, blocked } = skillGrantsFor(info.source, loaded.info.allowedTools);
+        for (const t of grants)
             skillGrantsRef.current.add(t);
+        const contextText = auto ? capSkillBodyForAuto(loaded.text, info.dir) : loaded.text;
         historyRef.current.push({
             role: "user",
-            content: `[skill "${info.name}" loaded — follow these instructions]\n${loaded.text}`,
+            content: `[skill "${info.name}" loaded — follow these instructions]\n${contextText}`,
         });
-        const grantNote = loaded.info.allowedTools.length > 0
-            ? ` (tools pre-approved this turn: ${loaded.info.allowedTools.join(", ")})`
-            : "";
-        pushInfo(`Skill "${info.name}" loaded${grantNote}\n${loaded.text}`);
-    }
-    // Manual /skill-name invocation (ticket 03). Idle-only: injecting history
-    // mid-turn would break the loop's assistant/tool pairing. Unknown names
-    // get a helpful error (not a model message); model-only skills refuse
-    // with a pointer instead of loading.
+        const grantNote = grants.length > 0
+            ? ` (tools pre-approved this turn: ${grants.join(", ")})`
+            : blocked.length > 0
+                ? ` (project skill: ${blocked.join(", ")} still needs approval)`
+                : "";
+        pushInfo(`${info.name} loaded${grantNote}`);
+    }
+    // Manual skill invocation (ticket 03; `/skill-name` legacy form and the
+    // namespaced `/skill:name` form both land here with the bare name).
+    // Idle-only: injecting history mid-turn would break the loop's
+    // assistant/tool pairing. Unknown names get a helpful error (not a model
+    // message); model-only skills refuse with a pointer instead of loading.
     async function invokeSkillByName(name) {
         if (busyRef.current) {
             pushInfo("Skills load when idle — wait for the turn to finish.");
             return;
         }
-        const found = await discoverSkills({
-            projectDir: skillDirs?.projectDir,
-            homeDir: skillDirs?.homeDir,
-        });
+        const found = await skillRegistry.refresh();
         const { skills } = resolveSkills(found.skills);
         const info = skills.find((s) => s.name === name);
         if (!info) {
-            const available = skills.filter((s) => s.userInvocable).map((s) => `/${s.name}`);
+            const available = skills.filter((s) => s.userInvocable).map((s) => `/skill:${s.name}`);
             pushInfo(available.length > 0
-                ? `Unknown skill "/${name}". Available: ${available.join(", ")}`
-                : `Unknown skill "/${name}" (no skills installed).`);
+                ? `Unknown skill "/skill:${name}". Available: ${available.join(", ")}`
+                : `Unknown skill "/skill:${name}" (no skills installed).`);
             return;
         }
         if (!info.userInvocable) {
@@ -978,7 +1821,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // Snapshot the committed session (historyRef + turnsRef + settings refs)
     // to ~/.atom/session.json. Disk errors are ignored (in-memory session
     // still applies). Called only for committed state: completed turns and
-    // clean exit — never for rolled-back (failed/cancelled) turns.
+    // clean exit — never for rolled-back (failed/cancelled) turns. The
+    // committed diff previews (Turn.diff) are display-only and never saved:
+    // they can hold whole file contents (bloat) and would render stale
+    // after later edits, so /resume restores label-only turns.
     function persistSession() {
         try {
             saveSession({
@@ -988,13 +1834,66 @@ 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)
         }
     }
+    // Local observability persistence: flush the current telemetry session
+    // file (atomic, best-effort). Called on turn boundaries and session events —
+    // never in the hot path, never throwing.
+    function persistTelemetry() {
+        try {
+            telemetry.flush();
+        }
+        catch {
+            // ignore disk errors (telemetry never breaks the session)
+        }
+    }
+    function closeTelemetry() {
+        try {
+            telemetry.endSession();
+        }
+        catch {
+            // ignore
+        }
+        persistTelemetry();
+    }
+    // One-line /telemetry summary: current-session progress plus stored totals.
+    // Token figures are API-reported only; unavailable values say n/a with the
+    // reason (never zero, never estimated).
+    function telemetrySummaryText() {
+        try {
+            if (!telemetry.isEnabled()) {
+                return "(telemetry off — ATOM_TELEMETRY=0 or atom.json telemetry.enabled=false; no traces recorded)";
+            }
+            const snap = telemetry.getSnapshot();
+            const { sessions } = loadTelemetrySessions(authHome);
+            const agg = summarizeTelemetry(sessions);
+            const tokens = agg.usageReported
+                ? [
+                    agg.usage.prompt_tokens !== undefined ? `in ${agg.usage.prompt_tokens}` : null,
+                    agg.usage.completion_tokens !== undefined ? `out ${agg.usage.completion_tokens}` : null,
+                    agg.usage.total_tokens !== undefined ? `total ${agg.usage.total_tokens}` : null,
+                ]
+                    .filter((p) => p !== null)
+                    .join(" · ") || "reported (empty)"
+                : "n/a (no usage reported yet)";
+            const rate = agg.toolSuccessRate !== null ? `${(agg.toolSuccessRate * 100).toFixed(1)}%` : "n/a (no tool calls)";
+            return (`Telemetry: on · this session ${snap.sessionId} (${snap.turns.length} turn(s)) · ` +
+                `store ${telemetryDir(authHome)} (${agg.sessions} session(s), ${agg.turns} turn(s), ` +
+                `${agg.modelCalls} model call(s), ${agg.toolCalls} tool call(s), success ${rate}, tokens ${tokens}, ` +
+                `${agg.retries} retries) · /dashboard writes the full drill-down page.`);
+        }
+        catch {
+            return "(telemetry unavailable)";
+        }
+    }
     // Compaction routine (atomic): split head/tail, summarize head with
     // tools disabled + 4096 cap, then swap history := [system, summary, tail].
     // On success: boundary line, totals kept, load refreshed, save. On
@@ -1015,12 +1914,21 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         }
         const systemMsg = historyRef.current[0];
         const systemContent = typeof systemMsg.content === "string" ? systemMsg.content : systemPrompt;
-        const submitKey = keyForProvider(providerRef.current) || activeApiKeyRef.current;
-        if (!submitKey) {
+        // Owner-gated (see keyForProvider): never borrow another provider's
+        // seed key — anonymous Kilo sessions POST keyless.
+        const submitKey = keyForProvider(providerRef.current);
+        // Local runtimes need no key; a known-unreachable server fails fast
+        // with a clear notice instead of a bare connection error mid-turn.
+        const compactLocalNotice = localUnreachableNotice(providerRef.current);
+        if (compactLocalNotice) {
+            pushInfo(compactLocalNotice);
+            return false;
+        }
+        if (!submitKey && providerNeedsKey(providerRef.current)) {
             pushInfo(`Missing API key for ${providerRef.current} — run /provider to paste one (stored in ~/.atom/auth.json).`);
             return false;
         }
-        const baseURL = getStoredBaseURL(authRef.current, providerRef.current);
+        const baseURL = chatBaseURL(providerRef.current);
         try {
             const summary = await requestCompactSummary({
                 provider: providerRef.current,
@@ -1045,19 +1953,40 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     if (u.total_tokens !== undefined) {
                         next.total_tokens = (next.total_tokens ?? 0) + u.total_tokens;
                     }
+                    if (u.cacheReadTokens !== undefined) {
+                        next.cacheReadTokens = (next.cacheReadTokens ?? 0) + u.cacheReadTokens;
+                    }
+                    if (u.cacheWriteTokens !== undefined) {
+                        next.cacheWriteTokens = (next.cacheWriteTokens ?? 0) + u.cacheWriteTokens;
+                    }
                     // Only accumulate when the summary actually reported usage;
                     // an empty onUsage keeps totals byte-identical.
                     if (u.prompt_tokens !== undefined ||
                         u.completion_tokens !== undefined ||
-                        u.total_tokens !== undefined) {
+                        u.total_tokens !== undefined ||
+                        u.cacheReadTokens !== undefined ||
+                        u.cacheWriteTokens !== undefined) {
                         setUsageBoth(next);
                     }
+                    // Local observability: compaction spend is session-level (it
+                    // summarizes many turns and often lands after its turn ended), so
+                    // it is kept separate from per-turn usage. No-op when empty.
+                    telemetry.recordCompactionUsage(u, isAuto ? "auto" : "manual");
                 },
             });
             // Atomic swap: build the new history first, then replace.
             const next = buildCompactedHistory(systemMsg, summary, split.tail, split.olderTurnCount);
-            historyRef.current = next;
+            // Replacement: re-wrap so the ledger restarts from the compacted array
+            // (the old ledger is discarded with the old array).
+            historyRef.current = trackHistory(next);
             appendTurns({ role: "tool", content: compactBoundaryLine(split.olderTurnCount) });
+            // New lineage (see src/rollback.ts): the atomic swap invalidates
+            // checkpoint marks — drop them, loudly when non-empty. The summary
+            // keeps the story; stale marks must never truncate the new tail.
+            const compactDrops = clearSnapshots();
+            if (compactDrops > 0) {
+                pushInfo(`(/compact — discarded ${compactDrops} file checkpoint(s); undos do not cross a compaction)`);
+            }
             // P% must drop immediately: the old lastPromptTokens reflects the
             // pre-compact context, so clear it and use the new-history estimate.
             lastPromptTokensRef.current = undefined;
@@ -1103,8 +2032,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             return;
         }
         // Unknown window → no auto trigger (never invent a window); below
-        // threshold → streak resets. shouldAutoCompact owns the pct math.
-        if (!shouldAutoCompact(load, modelRef.current)) {
+        // threshold → streak resets. The manager owns the pct math, so a false
+        // there means either case — re-check the window for the reset.
+        if (!contextManager().needsCompaction(load)) {
             // Distinguish unknown-window (streak untouched — irrelevant) from
             // below-threshold (streak resets). shouldAutoCompact is false for
             // both, so re-check the window for the reset.
@@ -1133,7 +2063,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         }
         const s = result.session;
         setProviderBoth(s.provider);
-        const baseURL = getStoredBaseURL(authRef.current, s.provider);
+        const baseURL = chatBaseURL(s.provider);
         if (s.provider === "openai-compatible") {
             setActiveEndpoint(openaiCompatibleChatEndpoint(baseURL));
         }
@@ -1147,7 +2077,8 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setEffortBoth(s.effort);
         setModeBoth(s.mode);
         setUsageBoth(s.usageTotals);
-        historyRef.current = [...s.history];
+        // Replacement: wrap the restored array (see the init comment).
+        historyRef.current = trackHistory([...s.history]);
         // Task 6: refresh the pinned env block on the restored system line
         // (strips the saved block, appends a fresh one) — keeps the restored
         // AGENTS overlay, never touches user content.
@@ -1165,13 +2096,27 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setAutoDisabledBoth(false);
         pendingCompactRef.current = null;
         const pendingNotices = [];
-        truncateHistory(historyRef.current, (msg) => {
+        // New lineage (see src/rollback.ts): the restored history replaces the
+        // live array, so live checkpoint marks are stale — drop them. Disk files
+        // are untouched; only undo evidence goes.
+        const resumedDrops = clearSnapshots();
+        if (resumedDrops > 0) {
+            pendingNotices.push({
+                role: "tool",
+                content: `(/resume — discarded ${resumedDrops} live file checkpoint(s); undos do not cross a resume)`,
+            });
+        }
+        // Same window-derived caps as the live path (the restored model is
+        // already in modelRef above).
+        contextManager().trimForSend(historyRef.current, (msg) => {
             pendingNotices.push({ role: "tool", content: `⚠ ${msg}` });
-        });
+        }, undefined, openTodoNeedles());
         // 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
-        // misalign and hide the first restored turn(s).
+        // misalign and hide the first restored turn(s). Restored list replaces
+        // the live one, so a held view re-follows (see /clear).
+        setScrollEndBoth(null);
         setClearGen((g) => g + 1);
         setTurnsBoth([
             ...s.turns,
@@ -1181,6 +2126,8 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             },
             ...pendingNotices,
         ]);
+        telemetry.recordEvent("resume", `restored session saved at ${s.savedAt} (${s.turns.length} turns)`);
+        persistTelemetry();
     }
     // /rewind conversation scope (ticket 01): truncate history + transcript to
     // the checkpoint's turn. The cut drops the whole containing turn (submit's
@@ -1199,6 +2146,8 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         const turnsCut = conversationCutIndex(turnsRef.current.map((t) => ({ role: t.role })), cp.turnsLength, 0);
         if (turnsCut < turnsRef.current.length) {
             setTurnsBoth(turnsRef.current.slice(0, turnsCut));
+            // Truncation can strand a held end past the new bottom — re-follow.
+            setScrollEndBoth(null);
         }
         if (droppedMessages <= 0) {
             return `(already at checkpoint #${cp.seq} — conversation untouched)`;
@@ -1267,7 +2216,6 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     // like every slash command except /compact). Rules gate write/edit/bash —
     // the approval tools — so a rule naming a read-only tool is accepted but
     // noted as inert (those calls never consult approve()).
-    const RULE_USAGE = "usage: /allow <tool[:glob]> · /deny <tool[:glob]> · /rules · /rules clear (e.g. /allow bash:npm test*, /deny bash:rm *)";
     function runRulesCommand(raw) {
         const text = raw.trim();
         const space = text.indexOf(" ");
@@ -1304,6 +2252,157 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             : ` (note: ${parsed.tool} is read-only and auto-runs — rules gate write/edit/bash)`;
         pushInfo(`${kind === "allow" ? "allowed" : "denied"}: ${parsed.pattern} (${rulesRef.current.length} rule(s))${gatedNote}`);
     }
+    // Queue + steer surface (Claude-Code-style follow-ups): /queue lists,
+    // /queue clear wipes, /steer <text> steers the running turn (or sends when
+    // idle). Idle-only except /steer-with-text and /queue reads, which also run
+    // while busy — that is their entire purpose. Callers gate on busy like
+    // every slash command except /compact (submit's busy branch routes here).
+    function runQueueCommand(raw) {
+        const text = raw.trim();
+        if (text === "/queue") {
+            if (queueRef.current.length === 0 && !steerRef.current) {
+                pushInfo("(queue empty — type + Enter while busy to queue a follow-up)");
+                return;
+            }
+            const lines = queueRef.current.map((q, i) => `${i + 1}. ${q}`);
+            if (steerRef.current)
+                lines.unshift(`(steering now: ${steerRef.current})`);
+            pushInfo(`Queued (${queueRef.current.length}):\n${lines.join("\n")}`);
+            return;
+        }
+        if (text === "/queue clear") {
+            setQueueBoth([]);
+            pushInfo("(queue cleared)");
+            return;
+        }
+        if (text === "/steer") {
+            pushInfo(STEER_USAGE);
+            return;
+        }
+        if (text.startsWith("/steer ")) {
+            const msg = text.slice("/steer".length).trim();
+            if (!msg) {
+                pushInfo(STEER_USAGE);
+                return;
+            }
+            if (!busyRef.current) {
+                // Idle: steering is just sending (same pipeline as typed input).
+                void submit(msg);
+                return;
+            }
+            // Busy: steer the active turn — drained at the next loop step boundary
+            // (see drainSteer). A second steer while one is pending queues behind
+            // it instead of clobbering it.
+            if (steerRef.current) {
+                if (queueRef.current.length >= QUEUE_CAP) {
+                    pushInfo(`(queue full — ${QUEUE_CAP} pending; /queue lists, /queue clear wipes)`);
+                    return;
+                }
+                setQueueBoth([...queueRef.current, msg]);
+                pushInfo(`(steer pending — queued behind it (${queueRef.current.length}))`);
+                return;
+            }
+            setSteerPendingBoth(msg);
+            return;
+        }
+        pushInfo(QUEUE_USAGE);
+    }
+    // /thinking: rendering-only visibility toggle for model thinking (both
+    // the committed transcript blocks and the live thinking block). Pure
+    // paint — safe while busy (never touches the turn, like /autoscroll).
+    // Bare toggles; anything appended prints usage (there are no arguments).
+    function runThinkingCommand(raw) {
+        if (raw.trim() !== "/thinking") {
+            pushInfo(THINKING_USAGE);
+            return;
+        }
+        const next = !showThinkingRef.current;
+        setShowThinkingBoth(next);
+        pushInfo(next
+            ? "(thinking shown — model reasoning stays visible in the transcript)"
+            : "(thinking hidden — reasoning still runs, it just isn't rendered)");
+    }
+    // /autoscroll [on|off]: follow switch for the scrollback viewport. View-
+    // only state — safe while busy (never touches the turn, like /queue).
+    // Bare prints the state; on jumps to the latest; off freezes a following
+    // view at its current end (mid-turn appends then accumulate below).
+    function runAutoScrollCommand(raw) {
+        const arg = raw.trim() === "/autoscroll" ? "" : raw.trim().slice("/autoscroll".length).trim().toLowerCase();
+        if (arg === "") {
+            pushInfo(autoScrollRef.current
+                ? "(autoscroll on — following new output as it arrives)"
+                : "(autoscroll off — the view freezes while a turn runs; End follows the latest)");
+            return;
+        }
+        if (arg === "on") {
+            if (autoScrollRef.current) {
+                pushInfo("(autoscroll already on)");
+                return;
+            }
+            setAutoScrollBoth(true);
+            setScrollEndBoth(null);
+            pushInfo("(autoscroll on — following the latest)");
+            return;
+        }
+        if (arg === "off") {
+            if (!autoScrollRef.current) {
+                pushInfo("(autoscroll already off)");
+                return;
+            }
+            // Confirm FIRST while still following (visible), then flip the switch:
+            // flipping first would freeze this very confirm below the viewport
+            // (appendTurns freezes busy appends once off). Already-held views stay
+            // held; the next busy append freezes a following view via appendTurns.
+            pushInfo("(autoscroll off — the view freezes while a turn runs; End follows the latest)");
+            setAutoScrollBoth(false);
+            return;
+        }
+        pushInfo(AUTOSCROLL_USAGE);
+    }
+    // /models: local-discovery status + refresh. Bare `/models` reports the
+    // last snapshot (kicking a first probe when discovery never ran);
+    // `/models refresh` re-probes all three runtimes, then reports. Results
+    // merge into the models cache, so the /model picker serves them with no
+    // extra fetches — one dim summary line, never transcript spam.
+    async function runModelsCommand(arg) {
+        const a = arg.trim().toLowerCase();
+        if (a !== "" && a !== "refresh") {
+            pushInfo("usage: /models [refresh] — probe local model servers (Ollama, LM Studio, llama.cpp).");
+            return;
+        }
+        // Manual Kilo refresh: clear the gateway catalog cache and re-fetch.
+        // The current model sticks when still listed; otherwise the fresh
+        // catalog's preferred free model wins (never a hardcoded id).
+        if (providerRef.current === "kilo" && a === "refresh") {
+            pushInfo("(refreshing Kilo model catalog…)");
+            clearKiloModelsCache();
+            try {
+                const res = await fetchModelsForProviderWithStatus("kilo", keyForProvider("kilo"), "", endpoint);
+                if (res.ok)
+                    modelsCacheRef.current.set(modelsCacheKey("kilo"), [...res.models]);
+                setModels(res.models);
+                if (!res.models.includes(modelRef.current)) {
+                    setModelBoth(preferFreeKiloModel(res.models, modelRef.current));
+                }
+                pushInfo(`Kilo models refreshed: ${res.models.length} available${res.ok ? "" : " (offline list)"}.`);
+            }
+            catch {
+                pushInfo("Kilo models refresh failed — keeping the current list.");
+            }
+            return;
+        }
+        if (localSnapRef.current.version === 0 || a === "refresh") {
+            pushInfo("(probing local model servers…)");
+            try {
+                const snap = await localDiscoveryRef.current.refresh();
+                applyLocalSnapshot(snap);
+            }
+            catch {
+                // Discovery never rejects (per-provider isolation); defensive only.
+            }
+        }
+        pushInfo(summarizeLocalSnapshot(localSnapRef.current));
+    }
     function runSlashCommand(cmd) {
         setInputBoth("");
         switch (cmd) {
@@ -1314,13 +2413,19 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 return;
             case "/clear":
                 // Task 6: same base as mount (no AGENTS.md re-read, as before) plus a
-                // fresh env block.
-                historyRef.current = [{ role: "system", content: withEnvBlock(systemPrompt) }];
+                // fresh env block. Fresh array → fresh ledger via trackHistory.
+                historyRef.current = trackHistory([
+                    { role: "system", content: withEnvBlock(systemPrompt) },
+                ]);
                 setTurnsBoth([]);
+                // List replacement re-follows a held view (the frozen end no longer
+                // exists — render clamping would follow the window but leave a
+                // stale held indicator).
+                setScrollEndBoth(null);
                 setClearGen((g) => g + 1);
                 setError(null);
                 setDraft(null);
-                setThinking(null);
+                clearThinking();
                 setToolHint(null);
                 setPhase("idle");
                 setPhaseDetail("");
@@ -1331,11 +2436,21 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 // kept: token totals and effort are per-session (see /help).
                 // autoDisabled stays for the session (thrash guard is session-wide).
                 skillGrantsRef.current = new Set();
+                // Lineage rule (see src/rollback.ts): the fresh history invalidates
+                // checkpoint marks, so /rewind undos never cross a cleared
+                // conversation. Silent when there was nothing to drop.
+                const clearedDrops = clearSnapshots();
+                if (clearedDrops > 0) {
+                    pushInfo(`(/clear — discarded ${clearedDrops} file checkpoint(s); undos do not cross a cleared conversation)`);
+                }
                 // autoDisabled stays for the session (thrash guard is session-wide).
                 lastPromptTokensRef.current = undefined;
                 setContextLoadBoth(null);
                 autoStreakRef.current = 0;
                 pendingCompactRef.current = null;
+                telemetry.recordEvent("clear", "conversation cleared (token totals kept)");
+                persistTelemetry();
+                void refreshSkillMenu();
                 return;
             case "/new":
                 // Claude-Code semantics: end the current conversation and start
@@ -1346,18 +2461,22 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 // session.json, so no archiving is invented here.
                 persistSession();
                 // Fresh system re-read (system.ts base + current AGENTS.md overlay)
-                // plus a fresh Task 6 env block.
-                historyRef.current = [{ role: "system", content: withEnvBlock(buildSystemPrompt()) }];
+                // plus a fresh Task 6 env block. Fresh array → fresh ledger.
+                historyRef.current = trackHistory([
+                    { role: "system", content: withEnvBlock(buildSystemPrompt()) },
+                ]);
                 setTurnsBoth([
                     {
                         role: "tool",
                         content: "(new session started — previous conversation kept, /resume to restore it)",
                     },
                 ]);
+                // Fresh list: a held view has nothing to hold onto — re-follow.
+                setScrollEndBoth(null);
                 setClearGen((g) => g + 1);
                 setError(null);
                 setDraft(null);
-                setThinking(null);
+                clearThinking();
                 setToolHint(null);
                 setPhase("idle");
                 setPhaseDetail("");
@@ -1372,11 +2491,20 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 clearTodos();
                 setTodoSnap([]);
                 skillGrantsRef.current = new Set();
+                // New lineage (see src/rollback.ts): yesterday's checkpoint marks
+                // cannot index the fresh history — drop them, loudly when non-empty.
+                const newDrops = clearSnapshots();
+                if (newDrops > 0) {
+                    pushInfo(`(/new — discarded ${newDrops} file checkpoint(s); undos do not cross sessions)`);
+                }
                 // Compaction state restarts fresh (unlike /clear, where the thrash
                 // guard stays disabled for the session).
                 autoStreakRef.current = 0;
                 setAutoDisabledBoth(false);
                 pendingCompactRef.current = null;
+                telemetry.recordEvent("new", "fresh conversation started (previous kept for /resume)");
+                persistTelemetry();
+                void refreshSkillMenu();
                 return;
             case "/compact":
                 // Bare /compact with no focus text (slash-menu path). Free-text
@@ -1384,14 +2512,25 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 // text survives; both funnel to the same busy/pending logic below.
                 void runCompactCommand("");
                 return;
-            case "/model":
-                setSelIndexBoth(Math.max(0, models.indexOf(model)));
+            case "/model": {
+                // Unified picker opens unfiltered with the highlight on the current
+                // model (active provider's section first, so same-provider rises
+                // stay index-stable when other keyed providers add sections below).
+                // Late lifecycle: if discovery never ran (slow/no startup probe),
+                // kick it now so local sections fill in behind the open picker.
+                if (localSnapRef.current.version === 0)
+                    kickLocalDiscovery();
+                setModelFilterBoth("");
+                const entries = buildModelEntries();
+                const at = entries.findIndex((e) => e.providerId === providerRef.current && e.model === modelRef.current);
+                setSelIndexBoth(Math.max(0, at));
                 setSelecting(true);
                 setSelectingEffort(false);
                 setSelectingProvider(false);
                 setKeyPromptBoth(null);
                 setBaseURLPromptBoth(null);
                 return;
+            }
             case "/provider":
                 openProviderPicker();
                 return;
@@ -1407,13 +2546,31 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 pushInfo(toolsListText());
                 return;
             case "/skills":
-                // Local filesystem read: never rejects (failures become warnings),
-                // so no catch is needed to keep the input responsive.
-                void skillsListText(skillDirs?.projectDir, skillDirs?.homeDir).then((text) => pushInfo(text));
+                // Searchable picker (names only, type to filter, Enter loads).
+                // Local reads only — zero fetches, like the model picker.
+                openSkillPicker();
+                return;
+            case "/skill":
+                pushInfo(SKILL_USAGE);
+                return;
+            case "/context":
+                pushInfo(buildContextText());
+                return;
+            case "/queue":
+                runQueueCommand("/queue");
+                return;
+            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; /plan to approve + exit)");
+                    pushInfo("mode: plan (read-only — write/edit/bash blocked with a replan note; Tab to approve + exit)");
                     return;
                 }
                 pushInfo(trustAllRef.current
@@ -1424,7 +2581,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 // Plan is a deliberate safety mode: trust must not punch through it.
                 // The flag is left untouched so exiting plan restores prior behavior.
                 if (modeRef.current === "plan") {
-                    pushInfo("(plan mode is read-only — exit plan with /plan before /trust; trust unchanged)");
+                    pushInfo("(plan mode is read-only — Tab out of plan before /trust; trust unchanged)");
                     return;
                 }
                 const next = !trustAllRef.current;
@@ -1434,34 +2591,12 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     : "trust: off — write/edit/bash ask again");
                 return;
             }
-            case "/yolo": {
-                // Same deliberate-safety rule as /trust: yolo must not punch through
-                // plan mode (and Tab below never enters/exits plan either). The user
-                // exits explicitly with /plan.
-                if (modeRef.current === "plan") {
-                    pushInfo("(plan mode is read-only — exit plan with /plan before /yolo; mode unchanged)");
-                    return;
-                }
-                const next = modeRef.current === "normal" ? "yolo" : "normal";
-                setModeBoth(next);
-                pushInfo(`mode: ${next}`);
-                return;
-            }
+            case "/yolo":
             case "/plan": {
-                if (modeRef.current === "plan") {
-                    // Human approval: typing /plan to exit approves the recorded plan.
-                    // Always lands in normal (never yolo) so implementation starts
-                    // under asking permissions; the session checklist recorded while
-                    // planning survives the switch (todowrite handoff).
-                    setModeBoth("normal");
-                    const planned = getTodos().length;
-                    pushInfo(planned > 0
-                        ? `(plan approved — ${planned} task(s) carry into implementation under normal permissions)`
-                        : "(plan mode off — no plan recorded)");
-                    return;
-                }
-                setModeBoth("plan");
-                pushInfo("plan mode: on — explore freely (read/grep/glob/web/todos/ask run free; write/edit/bash are blocked with a replan note). Record the plan with todowrite, then /plan to approve + exit into implementation.");
+                // Retired: Tab is the only mode switcher (it cycles
+                // normal → yolo → plan → normal). Kept as explicit cases so typing
+                // them explains instead of falling through to skill lookup.
+                pushInfo("(retired — Tab cycles the permission mode: normal → yolo → plan → normal)");
                 return;
             }
             case "/help":
@@ -1477,6 +2612,16 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             case "/resume":
                 doResume();
                 return;
+            case "/telemetry":
+                pushInfo(telemetrySummaryText());
+                return;
+            case "/dashboard": {
+                const out = writeTelemetryDashboard(authHome);
+                pushInfo(out
+                    ? `(observability dashboard written to ${out} — open it in a browser. Local file, nothing uploaded.)`
+                    : "(dashboard failed to write — telemetry store unavailable)");
+                return;
+            }
             case "/rewind": {
                 // Idle-only like every slash command except /compact (submit's busy
                 // guard already routes here only when idle): restoring mid-turn would
@@ -1514,37 +2659,57 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     async function approve(name, args) {
         if (turnCancelRef.current?.signal.aborted)
             throw new LoopCancelledError();
-        const verdict = checkRules(rulesRef.current, name, args);
-        if (verdict === "deny")
+        // 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.
+        const outcome = decidePolicy(name, args, {
+            mode: modeRef.current,
+            trustAll: trustAllRef.current,
+            rules: rulesRef.current,
+            alwaysAllowed: alwaysAllowedRef.current,
+            skillGrants: skillGrantsRef.current,
+            approvalGated: needsApproval(name),
+        });
+        if (outcome.kind === "deny") {
+            pendingDiffRef.current = null;
             return "no";
-        // Plan mode (ticket 04): read-only. Mutations skip the prompt entirely
-        // and flow to guardedExecute, which refuses them pre-execution with a
-        // replan-friendly note. Returning "once" here only routes past the prompt
-        // — the gate below still blocks, so allow/yolo/trust/always/grants below
-        // cannot punch through.
-        if (modeRef.current === "plan" && needsApproval(name))
-            return "once";
-        if (verdict === "allow")
-            return "once";
-        if (modeRef.current === "yolo")
-            return "once";
-        if (trustAllRef.current)
-            return "once";
-        if (alwaysAllowedRef.current.has(name))
-            return "once";
-        if (skillGrantsRef.current.has(name))
+        }
+        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 };
-            setPendingApproval({ name, args });
+            setApproveIndexBoth(0);
+            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)
@@ -1558,6 +2723,8 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         if (decision === "always" && pendingApproval) {
             alwaysAllowedRef.current.add(pendingApproval.name);
         }
+        if (decision === "no")
+            pendingDiffRef.current = null;
         const h = approvalResolveRef.current;
         approvalResolveRef.current = null;
         setPendingApproval(null);
@@ -1584,7 +2751,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
     function guardedExecute(name, args) {
         if (modeRef.current === "plan" && needsApproval(name)) {
             return Promise.resolve(`Error: plan mode is read-only — ${name} blocked (no writes while planning). ` +
-                `Explore with read/grep/glob/web tools, record the plan with todowrite, then exit plan mode (/plan) to implement.`);
+                `Explore with read/grep/glob/web tools, record the plan with todowrite, then Tab out of plan mode to implement.`);
         }
         return executeTool(name, args);
     }
@@ -1654,8 +2821,56 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         // 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.
-        if (!text || busyRef.current)
+        if (!text)
+            return;
+        // Busy: plain follow-ups queue instead of submitting (Claude-Code-style —
+        // the thought is never lost); /queue + /steer manage and inject. Other
+        // "/" input still needs idle (pickers/modals would race the turn), so it
+        // drops silently exactly as before.
+        if (busyRef.current) {
+            if (text === "/queue" || text.startsWith("/queue ") ||
+                text === "/steer" || text.startsWith("/steer ")) {
+                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) {
+                pushInfo(`(queue full — ${QUEUE_CAP} pending; /queue lists, /queue clear wipes)`);
+                return;
+            }
+            setQueueBoth([...queueRef.current, text]);
+            return;
+        }
+        // Queue + steer routing (idle): exact or free-text forms, mirroring the
+        // /allow pattern above — SLASH_NAMES only holds exact commands.
+        if (text === "/queue" || text.startsWith("/queue ") ||
+            text === "/steer" || text.startsWith("/steer ")) {
+            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.
@@ -1665,21 +2880,54 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             runRulesCommand(text);
             return;
         }
+        // /models takes an optional subcommand (/models refresh), like the
+        // /allow family — SLASH_NAMES only holds exact commands.
+        if (text === "/models" || text.startsWith("/models ")) {
+            const arg = text === "/models" ? "" : text.slice("/models ".length);
+            void runModelsCommand(arg);
+            return;
+        }
         // Exact full-command + Enter runs it. A single-token "/name" not in
-        // SLASH_NAMES resolves through the skill registry (ticket 03); anything
+        // SLASH_NAMES resolves through the skill registry (ticket 03, legacy
+        // form — the namespaced `/skill:name` below is canonical); anything
         // else starting with "/" still falls through as a model message.
         if (SLASH_NAMES.has(text)) {
             runSlashCommand(text);
             return;
         }
+        // Retired commands explain instead of falling through to skill lookup.
+        if (text === "/yolo" || text === "/plan") {
+            runSlashCommand(text);
+            return;
+        }
+        // Namespaced skill invocation: `/skill:name` (bare `/skill` shows usage
+        // via the registry path above). Resolves through the same registry as
+        // the legacy `/name` form and the slash menu.
+        if (text === "/skill" || text === "/skill:") {
+            pushInfo(SKILL_USAGE);
+            return;
+        }
+        const namespaced = /^\/skill:([A-Za-z0-9_-]+)$/.exec(text)?.[1];
+        if (namespaced !== undefined) {
+            void invokeSkillByName(namespaced);
+            return;
+        }
         const skillName = /^\/([A-Za-z0-9_-]+)$/.exec(text)?.[1];
         if (skillName !== undefined) {
             void invokeSkillByName(skillName);
             return;
         }
-        // Missing key: guide to /provider instead of POSTing.
-        const submitKey = keyForProvider(providerRef.current) || activeApiKeyRef.current;
-        if (!submitKey) {
+        // Missing key: guide to /provider instead of POSTing (local runtimes
+        // and Kilo need no key — Kilo serves anonymous free models; a
+        // known-unreachable server fails fast with a clear error instead of a
+        // bare connection error mid-turn). Owner-gated (see keyForProvider).
+        const submitKey = keyForProvider(providerRef.current);
+        const submitLocalNotice = localUnreachableNotice(providerRef.current);
+        if (submitLocalNotice) {
+            setError(submitLocalNotice);
+            return;
+        }
+        if (!submitKey && providerNeedsKey(providerRef.current)) {
             setError(`Missing API key for ${providerRef.current} — run /provider to paste one (stored in ~/.atom/auth.json).`);
             return;
         }
@@ -1687,7 +2935,10 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         setBusy(true);
         setError(null);
         setDraft(null);
-        setThinking(null);
+        clearThinking();
+        // Fresh turn, fresh latch: the queue drain at the end auto-sends only
+        // when this turn was NOT cancelled (see the turn-end finally).
+        turnCancelledRef.current = false;
         // NOTE: skill grants are NOT cleared here — a manually armed skill
         // (loaded while idle) must survive into the turn it was armed for.
         // Expiry happens in the turn-end finally below, plus /clear + /new.
@@ -1703,6 +2954,14 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         // 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,
         // survives failure). Refresh the pinned env block ONCE per turn (not per
         // POST — the loop reuses history[0] for all its POSTs, so this is the
@@ -1714,12 +2973,13 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         // survives failure). History budget at turn start, BEFORE the push +
         // rollbackTo capture below (so the existing splice-rollback indices stay
         // valid): drop oldest user-turns first, reserving room for the incoming user message
-        // so the loop core's own budget check stays a no-op on entry — exactly
+        // so the loop core's own budget check stays a no-op on entry - exactly
         // one dim notice per truncating turn. /clear drops the notice with the
-        // transcript (usage totals still survive).
-        truncateHistory(historyRef.current, (msg) => {
-            appendTurns({ role: "tool", content: `⚠ ${msg}` });
-        }, { messages: 1, chars: text.length });
+        // transcript (usage totals still survive). Caps come from the session
+        // ContextManager (window-derived), with the same live todo pinning.
+        contextManager().trimForSend(historyRef.current, (msg) => {
+            appendTurns({ role: "tool", content: `? ${msg}` });
+        }, { messages: 1, chars: text.length }, openTodoNeedles());
         // SUBMIT STAGE 4/4 — loop-entry (rollback scope: post-rollbackTo, rolls
         // back on failure). Turn boundary: on POST failure (HTTP/network/empty/
         // truncated) the whole user turn (user message plus any partial
@@ -1729,22 +2989,43 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         // catch). Cancellation (LoopCancelledError) shares the same splice
         // contract.
         const rollbackTo = historyRef.current.length;
+        // Local observability: open this turn's trace (no-op when disabled).
+        // Provider/model switches surface here per turn; session-level switches
+        // are derived from the same updates (see setSessionMeta).
+        telemetry.setSessionMeta({ provider: providerRef.current, model: modelRef.current });
+        const telemetryTurnId = telemetry.startTurn(text, {
+            provider: providerRef.current,
+            model: modelRef.current,
+            effort: effortRef.current,
+            mode: modeRef.current,
+        });
+        const telemetrySink = {
+            onModelCall: (info) => telemetry.recordModelCall(telemetryTurnId, info),
+            onToolCall: (info) => telemetry.recordToolCall(telemetryTurnId, info),
+        };
         const controller = new AbortController();
         turnCancelRef.current = controller;
         historyRef.current.push({ role: "user", content: text });
         appendTurns({ role: "user", content: text });
-        // Skill auto-invoke (ticket 04): deterministic description match over a
-        // fresh registry, inside the rollback scope so a failed turn removes
-        // skill context too. Slash invocations skip it (manual path owns those).
-        // Discovery/loading never throw; the guard only protects submit itself.
+        // Skill auto-invoke (ticket 04, progressive disclosure): deterministic
+        // whole-word match over a fresh registry with a high bar (3 distinct
+        // word hits, at most 1 skill per turn), inside the rollback scope so a
+        // failed turn removes skill context too. Slash invocations skip it
+        // (manual path owns those). Auto loads Tier 2 only (body, no inlined
+        // references, 12KB cap — see activateSkill), so a trigger can never flood
+        // the window. Discovery/loading never throw; the guard only protects
+        // submit itself.
         if (!text.startsWith("/")) {
             try {
-                const found = await discoverSkills({
-                    projectDir: skillDirs?.projectDir,
-                    homeDir: skillDirs?.homeDir,
-                });
-                for (const info of matchSkills(text, resolveSkills(found.skills).skills)) {
-                    await activateSkill(info);
+                // Registry refresh: stat-level revalidation (cheap), then the pure
+                // deterministic match over metadata — no LLM, no body reads.
+                const found = await skillRegistry.refresh();
+                for (const info of matchSkills(text, resolveSkills(found.skills).skills, {
+                    max: 1,
+                    minHits: 3,
+                    wholeWords: true,
+                })) {
+                    await activateSkill(info, { auto: true });
                 }
             }
             catch {
@@ -1752,10 +3033,18 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
         }
         try {
-            const baseURL = getStoredBaseURL(authRef.current, providerRef.current);
+            const baseURL = chatBaseURL(providerRef.current);
             const reply = await runAgenticLoopForProvider(providerRef.current, submitKey, modelRef.current, historyRef.current, {
                 approve,
                 askUser,
+                // 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,
@@ -1769,9 +3058,11 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     catch {
                         setDraft(partial);
                     }
+                    lastPartialRef.current = partial;
                     noteTurnActivity();
                 },
                 onThinking: (partial) => {
+                    thinkingRef.current = partial;
                     setThinking(partial);
                     noteTurnActivity();
                 },
@@ -1780,15 +3071,21 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     setPhaseDetail(detail ?? "");
                     noteTurnActivity();
                     if (p === "thinking") {
-                        // New POST: its thinking (if any) replaces the previous round's.
-                        setThinking(null);
+                        // New POST: the previous round's thinking (if any) commits to
+                        // the transcript so it stays in the TUI instead of being
+                        // replaced and lost; the fresh round streams into the live block.
+                        commitThinking();
                     }
                     else if (p === "tool" && detail) {
                         setToolHint(detail);
+                        toolStartRef.current = clockNow();
                     }
                     else if (p === "retry") {
                         const msg = detail ? `↻ retrying… ${detail}` : "↻ retrying…";
                         appendTurns({ role: "tool", content: msg });
+                        // Local observability: transport retries attach to the model call
+                        // they precede (the recorder buffers them until it completes).
+                        telemetry.recordRetry(telemetryTurnId, detail ?? "");
                     }
                     else if (p === "done") {
                         setToolHint(null);
@@ -1797,8 +3094,12 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 },
                 onToolDelta: (name) => {
                     setToolHint(name);
+                    toolStartRef.current = clockNow();
                 },
                 onUsage: (u) => {
+                    // Local observability: per-turn usage accumulates inside the
+                    // recorder when the loop reports the completed model call (same
+                    // payload) — recording it here too would count every POST twice.
                     // Cumulative session spend from REAL reports only: every reporting
                     // POST accumulates (tool-round POSTs and successful retries each
                     // count once — each was billed; failed attempts report nothing, so
@@ -1817,6 +3118,14 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     if (u.total_tokens !== undefined) {
                         next.total_tokens = (next.total_tokens ?? 0) + u.total_tokens;
                     }
+                    // Prefix-cache counters accumulate like spend (real reports only;
+                    // absent fields mean "not reported", never zero).
+                    if (u.cacheReadTokens !== undefined) {
+                        next.cacheReadTokens = (next.cacheReadTokens ?? 0) + u.cacheReadTokens;
+                    }
+                    if (u.cacheWriteTokens !== undefined) {
+                        next.cacheWriteTokens = (next.cacheWriteTokens ?? 0) + u.cacheWriteTokens;
+                    }
                     setUsageBoth(next);
                 },
                 onReasoning: (label) => {
@@ -1825,8 +3134,34 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 onWarning: (msg) => {
                     appendTurns({ role: "tool", content: `⚠ ${msg}` });
                 },
+                // Steering seam: drains one pending /steer message into history +
+                // transcript at each loop step boundary (see drainSteer in zen.ts).
+                // The message joins the turn's fate — a failed turn rolls it back
+                // with everything else (same splice contract as the user turn).
+                drainSteer: () => {
+                    const s = steerRef.current;
+                    if (!s)
+                        return;
+                    steerRef.current = null;
+                    setSteerPending(null);
+                    historyRef.current.push({ role: "user", content: s });
+                    appendTurns({ role: "user", content: s });
+                },
                 onToolActivity: (label, result, isError) => {
-                    const items = [{ role: "tool", content: label }];
+                    // Display-only duration: wall time since the tool started (see
+                    // toolStartRef). Attached as Turn.ms for the `· Ns` suffix; the
+                    // label text itself stays byte-identical to the loop's audit line.
+                    const started = toolStartRef.current;
+                    toolStartRef.current = null;
+                    const ms = started !== null ? Math.max(0, clockNow() - started) : 0;
+                    const items = [{ role: "tool", content: label, ms }];
+                    // Inspector retention (display-only): keep the full result for
+                    // later browsing. Capped count; stored text char-capped inside
+                    // the record with an explicit truncation flag.
+                    toolLogRef.current.push(createToolRecord(toolSeqRef.current++, label, result, isError, ms));
+                    if (toolLogRef.current.length > MAX_TOOL_RECORDS) {
+                        toolLogRef.current.splice(0, toolLogRef.current.length - MAX_TOOL_RECORDS);
+                    }
                     // Todo tools are session state, not side effects: their results
                     // are short checklists, so successful ones join the transcript
                     // (history fidelity — what did the list look like when?) and
@@ -1843,19 +3178,66 @@ 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();
                 },
                 signal: controller.signal,
+                // Window-aware trim caps for this model's real window (the loop
+                // falls back to legacy caps without it — see AgenticOpts.context).
+                context: {
+                    model: modelRef.current,
+                    toolsChars: TOOLS_SCHEMA_CHARS,
+                },
             });
             // 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
             // below) never reach here, so a failure can't clobber the last good save.
             persistSession();
+            // Local observability: close the turn trace with the loop's own outcome
+            // labels (completed / blocked / unverified / budget-exceeded) and flush.
+            telemetry.endTurn(telemetryTurnId, classifyTurnOutcome(reply), reply);
+            persistTelemetry();
             // Drain boundary (still busy, never mid-turn): pending manual /compact
             // first (it resets the thrash counter), else auto-compact when the
             // load is over threshold. Compaction persists via the normal save path.
@@ -1884,12 +3266,38 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 (err instanceof Error && err.name === "LoopCancelledError") ||
                 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
+            // turn traces plus these explicit failure markers — never partial
+            // transcript state.
+            telemetry.endTurn(telemetryTurnId, cancelled ? "cancelled" : "failed", err instanceof Error ? err.message : String(err));
+            persistTelemetry();
             if (cancelled) {
                 // One dim line (tool role renders dim); not an error.
                 // Rolled back above: no save, the last good save stays intact.
-                appendTurns({ role: "tool", content: "(cancelled)" });
+                // The line states the rollback scope outright (see src/rollback.ts):
+                // conversation only — disk and processes were NOT reverted.
+                appendTurns({ role: "tool", content: cancelledTurnLine() });
             }
             else {
+                // Failed (not cancelled): the streamed answer so far is committed
+                // as a marked partial turn BEFORE the error. Without this, a rate
+                // limit or dead network after 30s of streaming wipes everything the
+                // user already read. History stays rolled back (model never sees
+                // it); only the display transcript keeps the partial.
+                const partial = lastPartialRef.current.trim();
+                lastPartialRef.current = "";
+                if (partial) {
+                    appendTurns({
+                        role: "assistant",
+                        content: `${partial}\n\n(request failed before completing — partial output preserved)`,
+                    });
+                }
                 setError(err instanceof Error ? err.message : String(err));
             }
             // Turn-end drain even after failure/rollback: pending manual still
@@ -1913,6 +3321,9 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             turnCancelRef.current = null;
             approvalResolveRef.current = null;
             setPendingApproval(null);
+            // Safety net: the slot is normally consumed by onToolActivity or
+            // cleared on deny/cancel — never let it cross a turn boundary.
+            pendingDiffRef.current = null;
             askResolveRef.current = null;
             setPendingQuestion(null);
             setAskCustomBoth("");
@@ -1922,6 +3333,7 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             skillGrantsRef.current = new Set();
             busyRef.current = false;
             setBusy(false);
+            refreshGitInfo();
             try {
                 draftThrottleRef.current?.cancel();
             }
@@ -1929,13 +3341,30 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                 // ignore
             }
             setDraft(null);
-            setThinking(null);
+            clearThinking();
             setToolHint(null);
             clearTurnTimer();
             setStalled(false);
             setElapsedSecs(0);
             setPhase("idle");
             setPhaseDetail("");
+            // 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
+            // by a failed/cancelled turn rejoins the queue front — the thought is
+            // preserved, the user decides when it runs. Runs after busy resets
+            // above so the chained submit enters a clean turn.
+            const stranded = steerRef.current;
+            if (stranded) {
+                steerRef.current = null;
+                setSteerPending(null);
+                setQueueBoth([stranded, ...queueRef.current]);
+            }
+            if (!turnCancelledRef.current && queueRef.current.length > 0) {
+                const next = queueRef.current[0];
+                setQueueBoth(queueRef.current.slice(1));
+                void submit(next);
+            }
         }
     }
     function cancelTurn() {
@@ -1954,6 +3383,12 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         const rawCancel = ch === "\u0003" || ch === "\u0004";
         const ctrlCancel = (key.ctrl && (ch === "c" || ch === "d" || ch === "C" || ch === "D")) || rawCancel;
         if (ctrlCancel) {
+            // Inspector open (idle): Ctrl+C closes it — never exits the app from
+            // inside the inspector.
+            if (inspectingRef.current) {
+                closeInspector();
+                return;
+            }
             // Mid-turn: cancel the whole turn (works during POST wait, tool
             // execution, and the approval/question modals). Idle: exit as before.
             if (turnCancelRef.current || busyRef.current) {
@@ -1969,11 +3404,32 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             exit();
             return;
         }
-        // 1. Tool approval prompt (normal mode): y = once, a = always this
+        // 1. Tool approval prompt (normal mode): arrows + Enter select
+        // (highlight starts at allow-once), y = once, a = always this
         // session, t = trust all write/edit/bash this session, n/Esc = deny
         // (denial feeds back into the loop as a result).
         // Ctrl+C (handled above) cancels the whole turn instead.
         if (pendingApproval) {
+            if (key.upArrow) {
+                setApproveIndexBoth((approveIndexRef.current + 3) % 4);
+                return;
+            }
+            if (key.downArrow) {
+                setApproveIndexBoth((approveIndexRef.current + 1) % 4);
+                return;
+            }
+            if (key.return) {
+                const i = approveIndexRef.current;
+                if (i === 1)
+                    resolveApproval("always");
+                else if (i === 2)
+                    resolveTrustAll();
+                else if (i === 3)
+                    resolveApproval("no");
+                else
+                    resolveApproval("once");
+                return;
+            }
             const k = (ch ?? "").toLowerCase();
             if (k === "y")
                 resolveApproval("once");
@@ -2042,8 +3498,19 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
             if (key.return) {
                 const draft = kp.draft;
-                if (!draft || kp.validating || busy)
+                if (kp.validating || busy)
                     return;
+                // Kilo keys are optional: empty Enter continues anonymously on
+                // free models (Esc also works — see above).
+                if (!draft) {
+                    if (kp.providerId === "kilo") {
+                        const keep = keyForProvider(kp.providerId);
+                        setKeyPromptBoth(null);
+                        void switchProviderWithKey(kp.providerId, keep);
+                        return;
+                    }
+                    return;
+                }
                 const baseURL = getStoredBaseURL(authRef.current, kp.providerId);
                 setKeyPromptBoth({ ...kp, validating: true, error: null });
                 void validateProviderKey(kp.providerId, draft, baseURL).then((res) => {
@@ -2149,6 +3616,18 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
                     !getStoredBaseURL(authRef.current, picked.id)) {
                     openBaseURLPrompt(picked.id);
                 }
+                else if (picked.id === "kilo" && !keyForProvider(picked.id)) {
+                    // Kilo without a key: offer the optional key prompt — anonymous
+                    // free models stay one (empty) Enter away inside it.
+                    openKeyPrompt(picked.id);
+                }
+                else if (!providerNeedsKey(picked.id)) {
+                    // Local runtime (or keyed Kilo): no key to paste — switch
+                    // straight in (standard switch path refreshes its model list
+                    // in the background).
+                    setSelectingProvider(false);
+                    void switchProviderWithKey(picked.id, keyForProvider(picked.id));
+                }
                 else {
                     // No key -> paste prompt; key on file -> replace prompt
                     // (masked hint; typing replaces, Esc keeps + switches).
@@ -2157,34 +3636,119 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
             return;
         }
-        // 3. Model picker (opening it replaces/closes the slash menu; Esc
-        // returns to plain input, never to the slash menu).
+        // 3. Model picker (unified cross-provider list, type-to-filter, windowed;
+        // opening it replaces/closes the slash menu; Esc returns to plain input,
+        // never to the slash menu).
         if (selecting) {
+            // Rebuilt per keypress from the same render's state the paint uses, so
+            // highlight/filter/paint never disagree mid-tick.
+            const entries = filterModelEntries(buildModelEntries(), modelFilterRef.current);
             if (key.upArrow) {
-                setSelIndexBoth((selIndexRef.current - 1 + models.length) % models.length);
+                if (entries.length > 0) {
+                    setSelIndexBoth((selIndexRef.current - 1 + entries.length) % entries.length);
+                }
             }
             else if (key.downArrow) {
-                setSelIndexBoth((selIndexRef.current + 1) % models.length);
+                if (entries.length > 0) {
+                    setSelIndexBoth((selIndexRef.current + 1) % entries.length);
+                }
             }
             else if (key.escape) {
+                setModelFilterBoth("");
                 setSelecting(false);
             }
             else if (key.return) {
-                const picked = models[selIndexRef.current];
+                const picked = entries[selIndexRef.current];
+                setModelFilterBoth("");
                 if (picked) {
-                    setModelBoth(picked);
-                    // Model switch resets the load latch (different tokenizer: the old
-                    // reported prompt_tokens no longer measures this context); the
-                    // estimate applies until the new model reports.
-                    resetContextLoadToEstimate();
-                    // Re-gate effort on every /model switch: setting persists, but a
-                    // non-Default effort on an unsupported model warns (kept, not sent).
-                    if (effortRef.current !== "default" && !isEffortSupported(picked)) {
-                        warnEffortUnsupported(picked);
+                    if (picked.providerId === providerRef.current) {
+                        setModelBoth(picked.model);
+                        // Model switch resets the load latch (different tokenizer: the old
+                        // reported prompt_tokens no longer measures this context); the
+                        // estimate applies until the new model reports.
+                        resetContextLoadToEstimate();
+                        // Re-gate effort on every /model switch: setting persists, but a
+                        // non-Default effort on an unsupported model warns (kept, not sent).
+                        if (effortRef.current !== "default" && !isEffortSupported(picked.model)) {
+                            warnEffortUnsupported(picked.model);
+                        }
+                    }
+                    else {
+                        // Cross-provider pick: switch with the resolved key (env wins,
+                        // else stored — remote sections only render for keyed providers;
+                        // local sections need no key) and keep the picked model; the
+                        // live refresh lands in the background via the standard switch
+                        // path. reasoning_effort is zen-only, so a non-Default effort
+                        // warns (kept, not sent).
+                        const switchedKey = keyForProvider(picked.providerId);
+                        if (switchedKey || !providerNeedsKey(picked.providerId)) {
+                            const pickedProvider = picked.providerId;
+                            const pickedModel = picked.model;
+                            void (async () => {
+                                await switchProviderWithKey(pickedProvider, switchedKey, pickedModel);
+                                if (effortRef.current !== "default") {
+                                    warnEffortUnsupported(pickedModel);
+                                }
+                            })();
+                        }
                     }
                 }
                 setSelecting(false);
             }
+            else if (key.backspace || key.delete) {
+                setModelFilterBoth(modelFilterRef.current.slice(0, -1));
+                setSelIndexBoth(0);
+            }
+            else if (ch && !key.ctrl && !key.meta && !key.tab) {
+                setModelFilterBoth(modelFilterRef.current + ch);
+                setSelIndexBoth(0);
+            }
+            return;
+        }
+        // 3a. Skills picker (searchable popup, same pattern as /model, but
+        // selection STAGES for confirm: type to filter, ↑/↓ + Enter/Tab puts
+        // `/skill:name` into the input (nothing is sent), Esc cancels.
+        // Backspace edits the filter.
+        if (selectingSkills) {
+            // Rebuilt per keypress from the same render's state the paint uses, so
+            // highlight/filter/paint never disagree mid-tick.
+            const entries = filterSkillPicker(skillPickerItems, skillFilterRef.current);
+            if (key.upArrow) {
+                if (entries.length > 0) {
+                    setSkillIndexBoth((skillIndexRef.current - 1 + entries.length) % entries.length);
+                }
+            }
+            else if (key.downArrow) {
+                if (entries.length > 0) {
+                    setSkillIndexBoth((skillIndexRef.current + 1) % entries.length);
+                }
+            }
+            else if (key.escape) {
+                setSkillFilterBoth("");
+                setSelectingSkills(false);
+            }
+            else if (key.return || key.tab) {
+                const picked = entries[skillIndexRef.current];
+                const name = picked?.name;
+                setSkillFilterBoth("");
+                setSelectingSkills(false);
+                // Stage for confirm, never auto-send: the exact command lands in the
+                // input and a second Enter runs it through the normal submit path
+                // (exact `/skill:name` executes). Model-only entries refuse there,
+                // same as a typed /skill:name.
+                if (name) {
+                    exitHistoryBrowse();
+                    setInputBoth(`/skill:${name}`);
+                }
+            }
+            else if (key.backspace || key.delete) {
+                setSkillFilterBoth(skillFilterRef.current.slice(0, -1));
+                setSkillIndexBoth(0);
+            }
+            else if (ch && !key.ctrl && !key.meta && !key.tab) {
+                setSkillFilterBoth(skillFilterRef.current + ch);
+                setSkillIndexBoth(0);
+            }
             return;
         }
         // 3b. Effort picker (/effort): same keyboard pattern as the /model
@@ -2260,12 +3824,15 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
             return;
         }
-        // 4. "/" slash menu (filter-as-you-type): ↑/↓ + Enter/Tab runs the
-        // highlighted command, Esc dismisses back to plain input.
+        // 4. "/" slash menu (filter-as-you-type): commands first, then matching
+        // skills as namespaced `/skill:name` entries. ↑/↓ + Enter/Tab runs the
+        // highlighted entry, Esc dismisses back to plain input. Single-line only:
+        // a newline anywhere means free text (slash commands never span lines).
         const cur = inputRef.current;
-        const matches = !slashDismissedRef.current && cur.startsWith("/")
-            ? filterSlashCommands(cur)
-            : [];
+        const menu = !slashDismissedRef.current && cur.startsWith("/") && !cur.includes("\n")
+            ? buildSlashMenu(cur, skillMenu)
+            : { items: [], moreSkills: 0 };
+        const matches = menu.items;
         if (matches.length > 0) {
             if (key.leftArrow) {
                 setCursorBoth(cursorRef.current - 1);
@@ -2290,15 +3857,38 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             }
             else if (key.return || key.tab) {
                 const pick = matches[slashIndexRef.current % matches.length];
-                // /compact is allowed while busy (sets the pending flag for turn-end
-                // drain); every other command still waits for idle.
-                if (pick && (pick.name === "/compact" || !busyRef.current)) {
-                    if (pick.name === "/compact" && inputRef.current.startsWith("/compact ")) {
+                // /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) {
+                        // Skill entries stage for confirm (opencode-style): Enter/Tab
+                        // completes `/skill:name` into the input — nothing is sent.
+                        // A second Enter on the exact text runs it; a fully typed
+                        // `/skill:name` or legacy `/name` runs immediately (unambiguous).
+                        const staged = `/skill:${pick.skill}`;
+                        const typed = inputRef.current.trim();
+                        if (typed === staged || typed === `/${pick.skill}`) {
+                            setInputBoth("");
+                            void invokeSkillByName(pick.skill);
+                        }
+                        else {
+                            setInputBoth(staged);
+                        }
+                    }
+                    else if (pick.name === "/compact" && inputRef.current.startsWith("/compact ")) {
                         // Preserve free-text focus when the menu is open on a prefix.
                         const focus = inputRef.current.slice("/compact".length).trim();
                         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*");
@@ -2333,32 +3923,208 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             cancelTurn();
             return;
         }
-        // 5. Plain input. Tab toggles normal<->yolo here; when the "/" slash
-        // menu is open (section 4 above) Tab instead runs the highlighted
-        // command and never reaches this branch.
+        // 4c. Tool-output inspector (read-only: safe in any mode incl. plan).
+        // Ctrl+O toggles when fully idle (no turn, modal, or picker open);
+        // arrows/Enter/Esc drive it while open. Inspector keys never reach the
+        // input, and input keys never reach the inspector.
+        if (key.ctrl && (ch === "o" || ch === "O")) {
+            if (!busyRef.current && !turnCancelRef.current &&
+                !pendingApproval && !pendingQuestion &&
+                !selecting && !selectingSkills && !selectingProvider &&
+                !keyPrompt && !baseURLPrompt && !selectingEffort &&
+                !selectingRewind && !selectingRewindScope) {
+                if (inspectingRef.current)
+                    closeInspector();
+                else
+                    openInspector();
+            }
+            return;
+        }
+        if (inspectingRef.current) {
+            const last = Math.max(0, toolLogRef.current.length - 1);
+            if (key.escape) {
+                if (inspectExpandedRef.current) {
+                    setInspectExpandedBoth(false);
+                    setInspectScrollBoth(0);
+                }
+                else {
+                    closeInspector();
+                }
+            }
+            else if (key.return) {
+                setInspectExpandedBoth(!inspectExpandedRef.current);
+                setInspectScrollBoth(0);
+            }
+            else if (key.upArrow) {
+                if (inspectExpandedRef.current) {
+                    setInspectScrollBoth(Math.max(0, inspectScrollRef.current - 1));
+                }
+                else if (inspectIndexRef.current > 0) {
+                    setInspectIndexBoth(inspectIndexRef.current - 1);
+                }
+            }
+            else if (key.downArrow) {
+                if (inspectExpandedRef.current) {
+                    setInspectScrollBoth(inspectScrollRef.current + 1);
+                }
+                else if (inspectIndexRef.current < last) {
+                    setInspectIndexBoth(inspectIndexRef.current + 1);
+                }
+            }
+            else if (key.pageUp) {
+                if (inspectExpandedRef.current) {
+                    setInspectScrollBoth(Math.max(0, inspectScrollRef.current - VIEWPORT_LINES));
+                }
+                else {
+                    setInspectIndexBoth(Math.max(0, inspectIndexRef.current - 5));
+                }
+            }
+            else if (key.pageDown) {
+                if (inspectExpandedRef.current) {
+                    setInspectScrollBoth(inspectScrollRef.current + VIEWPORT_LINES);
+                }
+                else {
+                    setInspectIndexBoth(Math.min(last, inspectIndexRef.current + 5));
+                }
+            }
+            return;
+        }
+        // 4d. Command palette (Ctrl+P toggles; Ctrl+K stays kill-to-end).
+        // Opens over idle or busy turns alike (no modal/picker/inspector may be
+        // open); Enter runs through the shared busy-gate, so only
+        // compact/queue/steer fire while busy.
+        if (key.ctrl && (ch === "p" || ch === "P")) {
+            if (!pendingApproval && !pendingQuestion &&
+                !selecting && !selectingSkills && !selectingProvider &&
+                !keyPrompt && !baseURLPrompt && !selectingEffort &&
+                !selectingRewind && !selectingRewindScope && !inspecting) {
+                if (paletteOpenRef.current)
+                    closePalette();
+                else
+                    openPalette();
+            }
+            return;
+        }
+        if (paletteOpenRef.current) {
+            const entries = paletteEntries(paletteFilterRef.current);
+            if (key.escape) {
+                closePalette();
+            }
+            else if (key.return) {
+                const pick = entries[paletteIndexRef.current];
+                if (pick && (slashRunsWhileBusy(pick.name) || !busyRef.current)) {
+                    const name = pick.name;
+                    closePalette();
+                    runSlashCommand(name);
+                }
+            }
+            else if (key.upArrow) {
+                if (entries.length > 0) {
+                    setPaletteIndexBoth((paletteIndexRef.current - 1 + entries.length) % entries.length);
+                }
+            }
+            else if (key.downArrow) {
+                if (entries.length > 0) {
+                    setPaletteIndexBoth((paletteIndexRef.current + 1) % entries.length);
+                }
+            }
+            else if (key.backspace) {
+                setPaletteFilterBoth(paletteFilterRef.current.slice(0, -1));
+                setPaletteIndexBoth(0);
+            }
+            else if (ch && !key.ctrl && !key.meta && !key.tab && ch !== "\n") {
+                setPaletteFilterBoth(paletteFilterRef.current + ch);
+                setPaletteIndexBoth(0);
+            }
+            return;
+        }
+        // 5. Plain input (multiline-aware). Tab toggles normal<->yolo here;
+        // when the "/" slash menu is open (section 4 above) Tab instead runs the
+        // highlighted command and never reaches this branch. Enter ALWAYS sends
+        // (even multiline); Ctrl+J (ch "\n") inserts a newline. ↑/↓ move between
+        // lines, falling through to history recall at the first/last line.
         if (key.leftArrow) {
             setCursorBoth(cursorRef.current - 1);
         }
         else if (key.rightArrow) {
             setCursorBoth(cursorRef.current + 1);
         }
-        else if (key.home) {
-            setCursorBoth(0);
+        else if (key.pageUp) {
+            // Transcript scrollback (idle and busy alike): PgUp holds the view —
+            // the window freezes and the growing draft/thinking blocks collapse
+            // to one static line, so the terminal stops yanking mid-turn and
+            // scrollback stays readable. End (or PgDn at the bottom) follows
+            // again; /clear, /resume, /new, and rewind-truncate re-follow too.
+            setScrollEndBoth(applyScrollAction(scrollEndRef.current, turnsRef.current.length, { kind: "pageUp" }));
+        }
+        else if (key.pageDown) {
+            setScrollEndBoth(applyScrollAction(scrollEndRef.current, turnsRef.current.length, { kind: "pageDown" }));
+        }
+        else if (key.home && inputRef.current.length === 0) {
+            setScrollEndBoth(applyScrollAction(scrollEndRef.current, turnsRef.current.length, { kind: "home" }));
+        }
+        else if (key.end && inputRef.current.length === 0) {
+            setScrollEndBoth(applyScrollAction(scrollEndRef.current, turnsRef.current.length, { kind: "end" }));
         }
-        else if (key.end) {
-            setCursorBoth(inputRef.current.length);
+        else if (key.home || (key.ctrl && (ch === "a" || ch === "A"))) {
+            const t = inputRef.current;
+            const { line } = lineColOf(t, cursorRef.current);
+            setCursorBoth(offsetOfLines(splitInputLines(t), line, 0));
+        }
+        else if (key.end || (key.ctrl && (ch === "e" || ch === "E"))) {
+            const t = inputRef.current;
+            const lines = splitInputLines(t);
+            const { line } = lineColOf(t, cursorRef.current);
+            setCursorBoth(offsetOfLines(lines, line, lines[line].length));
+        }
+        else if (key.upArrow) {
+            moveOrRecall(-1);
+        }
+        else if (key.downArrow) {
+            moveOrRecall(1);
+        }
+        else if (ch === "\n" || (key.ctrl && (ch === "j" || ch === "J"))) {
+            insertAtCursor("\n");
+        }
+        else if (key.ctrl && (ch === "k" || ch === "K")) {
+            const r = killToLineEnd(inputRef.current, cursorRef.current);
+            exitHistoryBrowse();
+            setInputAndCursor(r.text, r.offset);
+        }
+        else if (key.ctrl && (ch === "u" || ch === "U")) {
+            const r = killToLineStart(inputRef.current, cursorRef.current);
+            exitHistoryBrowse();
+            setInputAndCursor(r.text, r.offset);
+        }
+        else if (key.ctrl && (ch === "w" || ch === "W")) {
+            const r = killWordBefore(inputRef.current, cursorRef.current);
+            exitHistoryBrowse();
+            setInputAndCursor(r.text, r.offset);
         }
         else if (key.return) {
+            pushInputHistory(inputRef.current);
             void submit(inputRef.current);
         }
         else if (key.tab) {
-            // Tab toggles normal<->yolo only (pinned by tests/status.test.tsx): it
-            // never enters or exits plan mode, so a stray keypress can't drop the
-            // deliberate safety mode — use /plan. Silent no-op in plan (the status
-            // line already shows mode: plan).
-            if (modeRef.current !== "plan") {
-                const next = modeRef.current === "normal" ? "yolo" : "normal";
-                setModeBoth(next);
+            // Tab is the only mode switcher: normal → yolo → plan → normal.
+            // normal→yolo stays silent (the status line shows it); plan
+            // transitions announce, since entering arms read-only mode and
+            // exiting approves the recorded todowrite plan into implementation
+            // (always landing in normal, never yolo — the checklist survives).
+            const cur = modeRef.current;
+            if (cur === "normal") {
+                setModeBoth("yolo");
+            }
+            else if (cur === "yolo") {
+                setModeBoth("plan");
+                pushInfo("plan mode: on — explore freely (read/grep/glob/web/todos/ask run free; write/edit/bash are blocked with a replan note). Record the plan with todowrite, then Tab to approve + exit into implementation.");
+            }
+            else {
+                setModeBoth("normal");
+                const planned = getTodos().length;
+                pushInfo(planned > 0
+                    ? `(plan approved — ${planned} task(s) carry into implementation under normal permissions)`
+                    : "(plan mode off — no plan recorded)");
             }
         }
         else if (key.delete && !key.backspace) {
@@ -2374,23 +4140,45 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             insertAtCursor(ch);
         }
     });
+    // Bracketed paste (Ink enables `\x1b[?2004h` while active): pasted text —
+    // including newlines — inserts at the cursor verbatim and NEVER submits,
+    // so multiline pastes can't fire mid-paste. Separate channel from
+    // useInput above. Active exactly when plain input is focused (idle or
+    // busy queue-draft; never inside a modal, picker, or the inspector).
+    usePaste((text) => {
+        insertAtCursor(normalizePaste(text));
+    }, {
+        isActive: !pendingApproval &&
+            !pendingQuestion &&
+            !selecting &&
+            !selectingSkills &&
+            !selectingProvider &&
+            !keyPrompt &&
+            !baseURLPrompt &&
+            !selectingEffort &&
+            !selectingRewind &&
+            !selectingRewindScope &&
+            !inspecting,
+    });
     const phaseLabel = phase === "thinking" || phase === "idle"
-        ? "thinking…"
+        ? `thinking${theme.symbol.ellipsis}`
         : phase === "streaming"
-            ? "streaming…"
+            ? `streaming${theme.symbol.ellipsis}`
             : phase === "tool"
                 ? phaseDetail
-                    ? `calling ${phaseDetail}…`
-                    : "tool…"
+                    ? `calling ${phaseDetail}${theme.symbol.ellipsis}`
+                    : `tool${theme.symbol.ellipsis}`
                 : phase === "retry"
                     ? phaseDetail
-                        ? `retrying… ${phaseDetail}`
-                        : "retrying…"
+                        ? `retrying${theme.symbol.ellipsis} ${phaseDetail}`
+                        : `retrying${theme.symbol.ellipsis}`
                     : phase === "done"
                         ? "done"
-                        : "thinking…";
-    // Slash menu derived for render (mirrors the useInput computation above).
-    const filteredSlash = !selecting &&
+                        : `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 &&
+        !selectingSkills &&
         !selectingEffort &&
         !selectingProvider &&
         !keyPrompt &&
@@ -2400,15 +4188,51 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
         !selectingRewind &&
         !selectingRewindScope &&
         !slashDismissed &&
-        input.startsWith("/")
-        ? filterSlashCommands(input)
-        : [];
+        input.startsWith("/") &&
+        !input.includes("\n")
+        ? buildSlashMenu(input, skillMenu)
+        : { items: [], moreSkills: 0 };
+    const filteredSlash = slashMenu.items;
     const slashVisible = filteredSlash.length > 0;
-    const slashHighlight = filteredSlash.length > 0 ? filteredSlash[slashIndex % filteredSlash.length]?.name : undefined;
-    // Cursor block renders AT the cursor offset (defensive clamp: the ref is
-    // the source of truth mid-tick and always stays in range via setCursorBoth,
-    // but state may lag it by one render).
-    const safeCursor = Math.max(0, Math.min(cursor, input.length));
+    const slashHi = filteredSlash.length > 0 ? slashIndex % filteredSlash.length : 0;
+    const slashHighlight = filteredSlash.length > 0 ? filteredSlash[slashHi]?.name : undefined;
+    const slashWin = pickerWindow(filteredSlash.length, slashHi);
+    const slashHasSkills = filteredSlash.some((c) => c.skill !== undefined);
+    // Argument hint for the highlighted command (reused usage strings only).
+    const slashUsage = filteredSlash.length > 0 && filteredSlash[slashHi]?.skill === undefined
+        ? commandUsage(filteredSlash[slashHi].name)
+        : null;
+    // 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) : [];
+    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}` +
+        (modelFilter ? ` of ${modelEntriesAll.length}, filter: "${modelFilter}"` : "") +
+        `) — type to filter, up/down + Enter, Esc cancels:`;
+    // /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) : [];
+    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:`;
+    // Memoized render derivations (flicker fix): these rebuild arrays on every
+    // App render (token paints, keystrokes, 1s ticks), which defeats the memo
+    // on the leaf panels below. Memoized, the leaves skip everything but real
+    // changes. Checkpoint listing reads the snapshot dir — never per frame.
+    const paletteEntriesMemo = useMemo(() => (paletteOpen ? paletteEntries(paletteFilter) : []), [paletteOpen, paletteFilter]);
+    const checkpointListMemo = useMemo(() => (selectingRewind ? listCheckpoints() : []), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [selectingRewind]);
+    // (The cursor clamp lives inside the memoized InputBox now, next to its
+    // only use — App body no longer reads cursor state for paint.)
     // Status-line reasoning segment wired to the effort session state:
     // non-Default shows the effort (plus " (unsupported)" when the model is
     // outside the verified-support set OR the provider is not opencode-zen);
@@ -2421,8 +4245,44 @@ export function App({ apiKey, endpoint, initialModel, initialModels, initialProv
             ? effort
             : `${effort} (unsupported)`
         : (reasoning ?? "default");
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TranscriptView, { turns: turns, clearGen: clearGen }), _jsxs(Box, { flexDirection: "column", marginY: 1, children: [turns.length === 0 ? (_jsx(Text, { dimColor: true, children: "Say hi to Atom \u2014 or type / for commands, /provider to pick a provider + key, /model to switch models." })) : null, sessionHint && turns.length === 0 ? (_jsx(Text, { dimColor: true, children: "(last session available \u2014 /resume to restore)" })) : null, draft ? (_jsxs(Text, { children: [_jsxs(Text, { color: "magenta", bold: true, children: ["ATOM>", " "] }), draft, _jsx(Text, { color: "gray", children: "\u258D" })] })) : null, thinking ? (_jsxs(Text, { dimColor: true, children: ["\uD83D\uDCAD ", thinking.length > THINKING_DISPLAY_CAP ? "…" + thinking.slice(-THINKING_DISPLAY_CAP) : thinking, _jsx(Text, { color: "gray", children: "\u258D" })] })) : null, busy && toolHint ? _jsxs(Text, { dimColor: true, children: ["\u25CC calling ", toolHint, "\u2026"] }) : null] }), error ? _jsxs(Text, { color: "red", children: ["error> ", error] }) : null, pendingApproval ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Atom permission \u2014 allow this tool?" }), _jsx(Text, { children: describeToolCall(pendingApproval.name, pendingApproval.args) }), _jsxs(Text, { children: ["[y]es once \u00B7 [a]lways allow ", pendingApproval.name, " this session \u00B7 [t]rust all write/edit/bash this session \u00B7 [n]o (Esc = no)"] })] })) : null, pendingQuestion ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Text, { bold: true, children: ["Atom question \u2014 ", pendingQuestion.question] }), pendingQuestion.options.map((o, i) => (_jsxs(Text, { color: i === askSelIndex ? "magenta" : undefined, children: [i === askSelIndex ? "❯ " : "  ", o] }, `${o}-${i}`))), pendingQuestion.allowCustom ? (_jsxs(Text, { dimColor: true, children: ["Type a custom answer + Enter to send it", askCustom ? `: ${askCustom}` : "", " \u00B7 \u2191/\u2193 + Enter picks \u00B7 Esc cancels"] })) : (_jsx(Text, { dimColor: true, children: "\u2191/\u2193 + Enter to pick \u00B7 Esc cancels" }))] })) : null, _jsx(Box, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: "gray", marginTop: 1 }), _jsx(TodoPanel, { items: todoSnap }), selecting ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Atom \u2014 Select model (up/down + Enter, Esc cancels):" }), models.map((m, i) => (_jsxs(Text, { color: i === selIndex ? "green" : undefined, children: [i === selIndex ? "❯ " : "  ", m, m === model ? " (current)" : ""] }, `${m}-${i}`)))] })) : selectingProvider ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Atom \u2014 Select provider (up/down + Enter, Esc cancels):" }), PROVIDERS.map((p, i) => {
-                        const has = keyForProvider(p.id).length > 0;
-                        return (_jsxs(Text, { color: i === providerIndex ? "green" : undefined, children: [i === providerIndex ? "❯ " : "  ", p.name, " (", p.id, ") ", has ? "✓ key" : "— no key", p.id === provider ? " (current)" : ""] }, p.id));
-                    })] })) : keyPrompt ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, 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" })), _jsxs(Text, { children: ["key: ", "•".repeat(keyPrompt.draft.length), _jsx(Text, { color: "gray", children: "\u2588" })] }), keyPrompt.validating ? _jsx(Text, { dimColor: true, children: "validating\u2026" }) : null, keyPrompt.error ? _jsx(Text, { color: "red", children: keyPrompt.error }) : null] })) : baseURLPrompt ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, 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: "gray", children: "\u2588" })] }), baseURLPrompt.error ? _jsx(Text, { color: "red", children: baseURLPrompt.error }) : null] })) : selectingEffort ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Atom \u2014 Select reasoning effort (up/down + Enter, Esc cancels):" }), EFFORT_OPTIONS.map((o, i) => (_jsxs(Text, { color: i === effortIndex ? "green" : undefined, children: [i === effortIndex ? "❯ " : "  ", 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(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Atom \u2014 Rewind to checkpoint (up/down + Enter, Esc cancels):" }), listCheckpoints().map((c, i) => (_jsxs(Text, { color: i === rewindIndex ? "green" : undefined, children: [i === rewindIndex ? "❯ " : "  ", "#", c.seq, " \u00B7 ", c.label, " \u00B7 ", 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(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Atom \u2014 Rewind scope (up/down + Enter, Esc cancels):" }), REWIND_SCOPES.map((s, i) => (_jsxs(Text, { color: i === rewindScopeIndex ? "green" : undefined, children: [i === rewindScopeIndex ? "❯ " : "  ", s] }, s))), _jsx(Text, { dimColor: true, children: "Shell side effects (bash) are explicitly out of scope and cannot be undone." })] })) : (_jsxs(Box, { children: [_jsxs(Text, { color: "cyan", bold: true, children: ["\u203A", " "] }), _jsxs(Text, { children: [input.slice(0, safeCursor), _jsx(Text, { color: "gray", children: "\u2588" }), input.slice(safeCursor)] })] })), slashVisible ? (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Atom commands (\u2191/\u2193 + Enter/Tab to run, Esc dismisses):" }), filteredSlash.map((c) => (_jsxs(Text, { color: c.name === slashHighlight ? "cyan" : undefined, children: [c.name === slashHighlight ? "❯ " : "  ", c.name, " \u2014 ", c.description] }, c.name)))] })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["provider: ", provider, " \u00B7 model: ", model, " \u00B7 ", formatTokens(usageTotals, model, contextLoad), " \u00B7 reasoning:", " ", reasoningDisplay, " \u00B7 mode: ", mode, trustAll && mode !== "plan" ? "+trust" : null, busy ? _jsxs(Text, { color: "yellow", children: [" \u00B7 ", phaseLabel, " ", elapsedSecs, "s \u00B7 esc stops"] }) : null, busy && stalled ? " · waiting…" : null] }) })] }));
+    // Display-only live tool elapsed: wall-clock now ≈ turn start + elapsed
+    // ticks (the 1s busy tick re-renders, so this stays fresh). Null when no
+    // tool is running — the running line then paints with no duration.
+    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, showThinking: showThinking }), _jsx(LiveTail, { isEmpty: turns.length === 0, sessionHint: sessionHint, draft: draft, thinking: thinking, busy: busy, held: scrollEnd !== null, toolHint: toolHint, toolElapsedSecs: toolElapsedSecs, elapsedSecs: elapsedSecs, showThinking: showThinking }), error ? _jsxs(Text, { color: theme.color.error, children: ["error> ", error] }) : null, pendingApproval ? (_jsx(ApprovalBox, { toolName: pendingApproval.name, description: describeToolCall(pendingApproval.name, pendingApproval.args), selected: approveIndex, diff: pendingApproval.diff ?? null })) : null, pendingQuestion ? (_jsx(QuestionBox, { question: pendingQuestion.question, options: pendingQuestion.options, allowCustom: pendingQuestion.allowCustom, askCustom: askCustom, askSelIndex: askSelIndex })) : null, _jsx(TodoPanel, { items: todoSnap }), steerPending ? _jsxs(Text, { dimColor: true, children: ["Steering: ", steerPending] }) : null, queue.length > 0 ? (_jsxs(Text, { dimColor: true, children: ["Queued (", queue.length, "): ", queue[0], queue.length > 1 ? ` +${queue.length - 1} more (/queue)` : ""] })) : null, paletteOpen ? (_jsx(PalettePanel, { entries: paletteEntriesMemo, index: paletteIndex, filter: paletteFilter })) : inspecting ? (_jsx(InspectorPanel, { records: toolLogRef.current, index: inspectIndex, expanded: inspectExpanded, scroll: inspectScroll })) : selecting ? (_jsxs(PickerShell, { title: modelTitle, children: [_jsx(PickerMoreAbove, { count: modelWin.start }), modelEntries.slice(modelWin.start, modelWin.end).map((e, k) => {
+                        const i = modelWin.start + k;
+                        const entryLocal = e.local === true;
+                        const prevLocal = i === 0 ? null : modelEntries[i - 1]?.local === true;
+                        const showGroup = i === 0 || prevLocal !== entryLocal;
+                        const showHeader = showGroup || modelEntries[i - 1]?.providerId !== e.providerId;
+                        const def = getProvider(e.providerId);
+                        return (_jsxs(React.Fragment, { children: [showGroup ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.descSeparator, " ", entryLocal ? "Local" : "Remote"] })) : null, showHeader ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.descSeparator, " ", def?.name ?? e.providerId, entryLocal && isLocalProviderId(e.providerId)
+                                            ? ` ${theme.symbol.separator} ${localBaseURLFor(e.providerId)}`
+                                            : null, e.providerId === provider ? " (current)" : ""] })) : null, _jsxs(PickerRow, { highlighted: i === modelHi, children: [e.model, e.free === true ? _jsx(Text, { dimColor: true, children: " (free)" }) : null, e.providerId === provider && e.model === model ? " (current)" : ""] })] }, `${e.providerId}-${e.model}-${i}`));
+                    }), _jsx(PickerMoreBelow, { count: modelEntries.length - modelWin.end }), modelEntries.length === 0 ? (_jsx(Text, { dimColor: true, children: "No models match \u2014 backspace to widen the filter." })) : null] })) : selectingSkills ? (_jsxs(PickerShell, { title: skillTitle, children: [_jsx(PickerMoreAbove, { count: skillWin.start }), skillEntries.slice(skillWin.start, skillWin.end).map((e, k) => {
+                        const i = skillWin.start + k;
+                        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) => {
+                    const has = keyForProvider(p.id).length > 0;
+                    const keyMark = isLocalProviderId(p.id)
+                        ? `local ${theme.symbol.descSeparator} no key needed`
+                        : has
+                            ? `${theme.symbol.keyPresent} key`
+                            : p.id === "kilo"
+                                ? `${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: [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
+            // replace it (never stack with it), each carrying their own semantic
+            // 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 })] }));
 }