@visual-z/xeno 0.1.4 → 0.2.1

package/src/apps/shell.ts

@@ -6,11 +6,20 @@
  * CI run never constructs it — `-p` output is parsed by scripts.
  */
 
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { homedir, tmpdir } from "node:os";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { assertNever } from "../core/exhaustive.ts";
 import type { LogEvent } from "../core/events.ts";
+import { userInputData, type ImageRef, type UserInput } from "../core/images.ts";
+import { droppedImagePaths } from "../core/attachment-input.ts";
+import { attachImageFile, attachImageBytes, loadDisplayImage } from "../runtime/images.ts";
+import { readClipboard, writeClipboard, type ClipboardContent } from "../runtime/clipboard.ts";
+import type { ExtensionContext, ExtensionRegistry } from "../runtime/extensions.ts";
+import { headlessUI } from "../runtime/extension-ui.ts";
+import { ExtensionUiController } from "./extension-ui.ts";
+import { highlightCode, transformMermaid, warmSyntaxLanguages } from "../runtime/rich-text.ts";
 import { projectTranscript, type TranscriptItem } from "../core/transcript.ts";
 import { fileReferences } from "../core/file-references.ts";
 import { readNodeHistory } from "../store/restore.ts";
@@ -22,6 +31,7 @@ import { anchoredCount, estimateTokens, type Anchor, type TokenCounter } from ".
 import type { RestorePoint, RewindMode, LoopEvent } from "../runtime/loop.ts";
 import { createProvider, findModelByPattern, groupedModels, loadCatalog } from "../runtime/catalog.ts";
 import { outputTokenBudget, type Effort, type ModelSpec } from "../runtime/model.ts";
+import { scopedModels } from "../runtime/model-scope.ts";
 import { equivalentCost, reportedCost } from "../runtime/usage.ts";
 import type { ProviderConfig } from "../runtime/provider.ts";
 import { describeMissingCredential, envLabel, ensureFreshCredential, storedIsOAuth } from "../runtime/auth.ts";
@@ -34,40 +44,55 @@ import {
   type CallbackServer, type OAuthCredential, type SubscriptionId,
 } from "../runtime/oauth.ts";
 import { writeAuthFile } from "../store/auth-store.ts";
-import { authPath } from "../store/config.ts";
-import { modelsPath, readModelsText, writeModelsFile } from "../store/models.ts";
+import { authPath, configDir } from "../store/config.ts";
+import { catalogCachePath, readModelSources, writeCatalogCache } from "../store/models.ts";
 import {
   buildFileIndex, indexTruncationNote, type FileIndex,
 } from "../store/file-index.ts";
 import { currentBranch } from "../store/git-branch.ts";
-import { saveTrust, trustPath } from "../store/trust.ts";
+import { projectTrust, trustPath } from "../store/trust.ts";
+import { discoverResources, themeResourcePath } from "../store/resource-index.ts";
+import { ResourceBrowser } from "./resource-browser.ts";
+import { TrustSelector, applyTrustChoice, type TrustChoice } from "./project-trust.ts";
+import { reloadAppResources } from "./resources.ts";
+import { publishModelCatalog } from "./model-catalog.ts";
 import type { PermissionRequest } from "../core/permissions.ts";
 import type { ApprovalChoice } from "../runtime/tools.ts";
 import { approvalHeading, approvalItems, choiceFromValue } from "./approve.ts";
-import { readCursor, writeCursor, listNodes, readNode } from "../store/log.ts";
+import { readCursor, writeCursor, listNodes, readNode, readManifest, setSessionLabel } from "../store/log.ts";
+import { registerSessionRoot } from "../store/session-browser.ts";
 import {
-  createSession, findSessionByPrefix, listSessions, truncationNote, type ListedSession,
+  createSession, findSessionByPrefix, listSessions, truncationNote,
+  sessionsDir,
 } from "../store/sessions.ts";
+import { exportSessionArchive, importSessionArchive } from "../store/session-archive.ts";
 import { Editor } from "../tui/editor.ts";
 import type { Key } from "../tui/keys.ts";
-import { editorBindings, encodeKey, keyMatches } from "../tui/input.ts";
+import { editorBindings, installBindings, encodeKey, keyMatches } from "../tui/input.ts";
 import { interactiveAutocomplete } from "./completions.ts";
-import { Container, createInteractiveTui, Lines, PiText, MarkdownBlock, thinkingBorderColor } from "../tui/host.ts";
-import type { TuiMainScreen } from "../tui/host.ts";
+import { Container, PaddedDocument, createInteractiveTui, replaceInteractiveTui, Lines, PiText, MarkdownBlock, thinkingBorderColor } from "../tui/host.ts";
+import type { InteractiveScreen, MarkdownFeatures } from "../tui/host.ts";
+import { createChatViewport, type ChatViewport } from "../tui/chat-viewport.ts";
+import { generateSystemThemeColors } from "../tui/system-theme.ts";
 import { Settings } from "../tui/settings.ts";
 import { SelectList, type SelectItem } from "../tui/select.ts";
-import { TreeList, renderTree, treeFromPoints, type TreeNode, type NodeParent } from "../tui/tree.ts";
+import { TreeList, renderTree, treeFromPoints, type TreeNode, type NodeParent, type TreePoint } from "../tui/tree.ts";
 import { renderStatus, type StatusState } from "../tui/statusline.ts";
-import { nextDelivery, type Phase, type QueuedMessage, type QueueKind } from "../core/queue.ts";
+import { deliveryBatch, type Phase, type QueuedMessage, type QueueKind } from "../core/queue.ts";
 import { cycle } from "../core/cycle.ts";
+import { THINKING_LEVELS, asThinkingLevel as asEffort, supportedThinkingLevels, clampThinkingLevel } from "../core/thinking.ts";
+import { changeModelScope, scopeReference, type ScopeChange } from "../core/model-scope.ts";
+import { modelKey } from "../core/session-position.ts";
 import { usableColumns, type Terminal } from "../tui/terminal.ts";
 import { ANSI, IDENTITY, PLAIN_ATTRS, createStyle, paint, type Style } from "../tui/style.ts";
 import { defaultKeymap, listBindings, type ActionId } from "../core/keymap.ts";
-import { builtinTheme } from "../core/theme.ts";
-import { writeUserSettings } from "../store/resources.ts";
+import { builtinTheme, parseTheme, THEME_TOKENS, type Theme } from "../core/theme.ts";
+import { DISPLAY_SETTINGS, settingValues, settingValue, settingPatch, mergeSettings } from "../core/settings.ts";
+import { writeUserSettings, removeModelThinkingOverride, loadUiResources, resolveTheme, watchTheme, discoverThemes, selectedThemePath } from "../store/resources.ts";
 import { colorEnabled } from "./render.ts";
 import { renderToolView } from "../tui/toolview.ts";
-import { lastAssistantText, toHtml, toJsonl } from "../core/export.ts";
+import { lastAssistantText, toHtml } from "../core/export.ts";
+import { visibleWidth } from "../vendor/pi-tui/utils.ts";
 import { toJsonEvent } from "../core/json-event.ts";
 import { COMMANDS, commandDefinition, parseCommand, type Command } from "./commands.ts";
 import {
@@ -77,13 +102,86 @@ import {
   describeError, firstLine, formatEvent, indent, stdinIsTty, stdoutIsTty, wrap,
 } from "./render.ts";
 import {
-  createSessionFor, retryHandler, whyNot, splitModelPatterns, runModelsRefresh, type App,
+  openSessionFor, sessionDirFor, retryHandler, whyNot, splitModelPatterns, runModelsRefresh, visibleSchemas, type App,
 } from "./startup.ts";
+import { SessionBrowser } from "./session-browser.ts";
 
 const HINT = `type a prompt, or ${COMMANDS.map((command) => `/${command.name}`).join(" ")}`;
 const OAUTH_PASTE = "\0oauth";
+const OAUTH_DEVICE = "\0oauth-device";
+
+const initializedExtensions = new WeakSet<ExtensionRegistry>();
+const extensionHistories = new WeakMap<App, LogEvent[]>();
+function extensionContext(app: App, tui?: Tui): ExtensionContext {
+  const entries = () => structuredClone([...(extensionHistories.get(app) ?? []).filter(event => !app.session.state.events.some(current => current.id === event.id)), ...app.session.state.events]);
+  return {
+    ui: tui?.extensionUi.context ?? headlessUI((text, type) => app.io.say(type === "error" ? app.io.palette.red(text) : text)),
+    cwd: app.workspace, mode: tui ? "tui" : app.args.mode === "json" ? "json" : "print", hasUI: !!tui,
+    model: app.providerConfig.spec, thinkingLevel: app.providerConfig.effort, signal: tui?.signal,
+    isIdle: () => !app.session.running, isProjectTrusted: () => app.projectTrusted === true,
+    hasPendingMessages: () => !!tui?.queue.length,
+    abort: () => { tui?.abort?.abort(); app.session.cancel(); }, shutdown: () => { app.shutdownRequested = true; app.session.cancel(); tui?.requestShutdown(); },
+    getSystemPrompt: () => app.session.config.frozen.system,
+    getContextUsage: () => ({ tokens: app.session.state.anchor?.promptTokens ?? null, contextWindow: app.providerConfig.spec.contextWindow }),
+    waitForIdle: () => app.session.whenIdle(),
+    reload: async () => { if (app.session.running) throw new Error("Reload requires an idle session"); await reloadAppResources(app); await tui?.refreshResources(); },
+    newSession: async () => { await openNewSession(app, tui); await bindExtensions(app, tui); return { cancelled: false }; },
+    switchSession: async (path: string) => { const changed = await adoptLogDir(app, path); if (changed) { await bindExtensions(app, tui); await tui?.refreshResources(); } return { cancelled: !changed }; },
+    fork: async (id: string) => { const changed = await spawnForkedSession(app, id, "forked by extension", "before"); if (changed) await bindExtensions(app, tui); return { cancelled: !changed }; },
+    sessionManager: { getEntries: entries, getBranch: entries, getSessionId: () => basename(app.logDir), getSessionFile: () => app.logDir, getCwd: () => app.workspace },
+    modelRegistry: { getAll: () => [...app.catalog], getAvailable: () => app.catalog.filter(model => app.credentialOf(model).ok), find: (provider: string, id: string) => app.catalog.find(model => model.provider === provider && model.id === id) },
+  };
+}
+
+async function bindExtensions(app: App, tui?: Tui): Promise<void> {
+  await tui?.extensionUi.bind(app.extensions, app.resources);
+  const registry = app.extensions; if (!registry) return;
+  const history = await readNodeHistory(app.logDir, app.session.state.node);
+  if (history.ok) extensionHistories.set(app, history.nodes.flatMap(node => node.events));
+  registry.bind({
+    context: () => extensionContext(app, tui),
+    append: async (entry, options) => {
+      if (entry.inContext && app.session.running) await app.session.whenIdle();
+      await app.session.appendExtension(entry); await tui?.syncTranscript();
+      if (options?.triggerTurn) { if (tui) tui.deliverExtension("Continue.", "followup"); else await run(app, "Continue."); }
+    },
+    user: async (text, options) => { if (tui) tui.deliverExtension(text, options?.deliverAs === "steer" ? "steering" : "followup"); else await run(app, text); },
+    setName: name => nameSession(app, name, tui),
+    setLabel: async (id, label) => { await setSessionLabel(app.logDir, id, label ?? "", app.session.clock.now()); },
+    getTools: () => visibleSchemas(app.args, registry).map(tool => ({ name: tool.name, description: tool.description, parameters: tool.input_schema })),
+    setTools: async names => {
+      if (app.session.running) throw new Error("Active tools can only change at an idle checkpoint");
+      const args = { ...app.args, tools: names, noTools: false };
+      const tools = visibleSchemas(args, registry);
+      if (names.some(name => !tools.some(tool => tool.name === name))) throw new Error("Unknown active tool");
+      await app.session.reloadResources({ ...app.session.config.frozen, tools }); app.args = args;
+    },
+    setModel: async model => {
+      if (typeof model !== "object" || !model || !("provider" in model) || !("id" in model)) return false;
+      await switchByPattern(app, String(model.provider) + "/" + String(model.id)); return app.providerConfig.spec.id === model.id && app.providerConfig.spec.provider === model.provider;
+    },
+    setThinking: async level => { await applyThinkingCommand(app, level, tui ?? null); },
+    exec: async (command, args, options) => {
+      const process = Bun.spawn([command, ...args], { cwd: options?.cwd ?? app.workspace, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+      let killed = false;
+      const kill = () => { killed = true; process.kill(); };
+      options?.signal?.addEventListener("abort", kill, { once: true });
+      if (options?.signal?.aborted) kill();
+      const timer = options?.timeout ? setTimeout(kill, options.timeout) : undefined;
+      try { const [stdout, stderr, code] = await Promise.all([new Response(process.stdout).text(), new Response(process.stderr).text(), process.exited]); return { stdout, stderr, code, killed }; }
+      finally { clearTimeout(timer); options?.signal?.removeEventListener("abort", kill); }
+    },
+  });
+  if (!initializedExtensions.has(registry)) {
+    initializedExtensions.add(registry);
+    const start = async () => { await registry.emit("session_start"); await registry.settle(); };
+    if (tui) tui.runExtensionAction(start); else await start();
+  }
+}
 
 function parseLine(app: App, text: string): Command {
+  const match = /^\/([^\s]+)(?:\s+([\s\S]*))?$/.exec(text.trim());
+  if (match && app.extensions?.commands.has(match[1]!)) return { kind: "extension", name: match[1]!, args: match[2] ?? "" };
   return parseCommand(text, app.slash);
 }
 
@@ -216,23 +314,27 @@ async function fileIndexFor(app: App, refresh = false): Promise<FileIndex> {
 }
 
 export async function runPrompt(app: App, prompt: string): Promise<void> {
+  await bindExtensions(app);
+  if (app.shutdownRequested) { await app.extensions?.dispose(); return; }
   const ok = await run(app, prompt);
+  await app.extensions?.dispose();
   printUsage(app);
   // One-shot mode is scriptable, so a failed turn has to be a failed exit.
   if (!ok) process.exit(1);
 }
 
-export async function runRepl(app: App): Promise<void> {
+export async function runRepl(app: App, releaseEarlyTty?: () => void): Promise<void> {
   if (stdinIsTty() && stdoutIsTty()) {
-    await runTui(app);
+    await runTui(app, releaseEarlyTty);
   } else {
     await runLines(app);
   }
 }
 
 async function runLines(app: App): Promise<void> {
+  await bindExtensions(app);
   const C = app.io.palette;
-  app.io.say(C.dim(HINT));
+  if (app.ui?.settings.quietStartup !== true || app.args.verbose) app.io.say(C.dim(HINT));
   /** Set by `/login <provider>`; the next line typed is the key, not a prompt. */
   let awaitingKeyFor: string | null = null;
   for await (const line of console) {
@@ -241,12 +343,12 @@ async function runLines(app: App): Promise<void> {
       const provider = awaitingKeyFor;
       awaitingKeyFor = null;
       if (text.length === 0) {
-        if (provider === OAUTH_PASTE) await cancelPendingOAuth();
+        if (provider === OAUTH_PASTE) await cancelPendingOAuth(app);
         app.io.say(C.dim("  cancelled\n"));
         continue;
       }
       if (provider === OAUTH_PASTE) {
-        if (pendingOAuth === null || pendingOAuth.done) {
+        if (!pendingLogins.has(app) || pendingLogins.get(app)?.done) {
           const outcome = await execute(app, parseLine(app, text), null);
           if (outcome === "quit") break;
           if (typeof outcome === "object") awaitingKeyFor = outcome.login;
@@ -260,37 +362,69 @@ async function runLines(app: App): Promise<void> {
     }
     if (!text) continue;
     const outcome = await execute(app, parseLine(app, text), null);
-    if (outcome === "quit") break;
+    if (outcome === "quit" || app.shutdownRequested) break;
     if (typeof outcome === "object") awaitingKeyFor = outcome.login;
   }
+  await cancelPendingOAuth(app);
+  await app.extensions?.dispose();
   printUsage(app);
 }
 
-async function runTui(app: App): Promise<void> {
+async function runTui(app: App, releaseEarlyTty?: () => void): Promise<void> {
   const C = app.io.palette;
-  app.io.say(C.dim(HINT));
+  if (!app.args.noSession) await registerSessionRoot({ path: dirname(app.logDir), workspace: app.workspace }).catch(error => app.io.say(String(error)));
+  if (app.ui?.settings.quietStartup !== true || app.args.verbose) app.io.say(C.dim(HINT));
   const tui = new Tui(app);
   const previousSay = app.io.say;
   app.io.say = (line) => tui.writeLine(line);
   await tui.syncTranscript();
+  // Transfer ownership synchronously: Pi must remember the shell's cooked mode, not startup's temporary raw mode.
+  releaseEarlyTty?.();
   tui.attach();
+  await bindExtensions(app, tui);
   app.askSlot.current = (request) => tui.ask(request);
   tui.paint();
+  let shuttingDown = false;
+  const stop = (code: number) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    process.exitCode = code;
+    tui.requestShutdown();
+  };
+  const terminate = () => stop(143);
+  const hangup = () => stop(129);
+  const crash = (error: unknown) => { stop(1); try { app.io.err(describeError(error)); } catch { /* dead terminal */ } };
+  const lastResort = () => tui.detach();
+  process.on("SIGTERM", terminate);
+  process.on("SIGHUP", hangup);
+  process.on("uncaughtException", crash);
+  process.on("unhandledRejection", crash);
+  process.on("exit", lastResort);
   try {
     while (true) {
       const data = await tui.nextInput();
-      const result = await tui.applyInput(data).catch((error: unknown) => {
+      if (shuttingDown || tui.shutdownRequested) { await tui.settle(); break; }
+      const result = await tui.applyInput(data, true).catch((error: unknown) => {
         tui.writeLine(app.io.palette.red(describeError(error)));
         return "continue" as const;
       });
       if (result === "quit") { await tui.settle(); break; }
     }
   } finally {
-    await cancelPendingOAuth();
-    await tui.screen.terminal.drainInput();
-    tui.detach();
-    delete app.askSlot.current;
-    app.io.say = previousSay;
+    try {
+      await app.extensions?.dispose();
+      await cancelPendingOAuth(app);
+      await tui.screen.terminal.drainInput();
+    } finally {
+      tui.detach();
+      delete app.askSlot.current;
+      app.io.say = previousSay;
+    }
+    process.off("SIGTERM", terminate);
+    process.off("SIGHUP", hangup);
+    process.off("uncaughtException", crash);
+    process.off("unhandledRejection", crash);
+    process.off("exit", lastResort);
     printUsage(app);
   }
 }
@@ -299,6 +433,14 @@ type Outcome = "continue" | "quit" | { login: string };
 
 async function execute(app: App, command: Command, tui: Tui | null): Promise<Outcome> {
   switch (command.kind) {
+    case "extension":
+      if (tui) tui.runExtensionCommand(command.name, command.args);
+      else { await bindExtensions(app); await app.extensions?.command(command.name, command.args); }
+      return "continue";
+    case "attachments":
+      if (tui) tui.openAttachments();
+      else app.io.say("Attachments are edited in the interactive prompt.");
+      return "continue";
     case "quit":
       return "quit";
     case "usage":
@@ -315,6 +457,19 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
       return "continue";
     case "settings":
       return applySettingsCommand(app, command.field, command.value, tui);
+    case "reload": {
+      const cut = await reloadAppResources(app);
+      if (tui) await tui.refreshResources(); else await bindExtensions(app);
+      app.io.say(app.io.palette.green(`  Resources reloaded${cut ? " at a context checkpoint" : ""}`));
+      return "continue";
+    }
+    case "config":
+      if (tui) await tui.openResourceSelect();
+      else {
+        const resources = await discoverResources({ ...app.args, workspace: app.workspace, trusted: (await projectTrust(app.workspace, app.projectTrusted ?? app.args.approve)).trusted });
+        for (const entry of resources.entries) app.io.say(`${entry.enabled ? "[x]" : "[ ]"} ${entry.kind} ${entry.scope} ${entry.path}`);
+      }
+      return "continue";
     case "session":
       await printSession(app);
       return "continue";
@@ -329,6 +484,10 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
       }
       printModels(app);
       return "continue";
+    case "scoped-models":
+      if (tui) tui.openScopedModels();
+      else app.io.say((app.ui?.settings.scopedModels ?? app.catalog.filter(spec => app.credentialOf(spec).ok).map(modelKey)).join("\n"));
+      return "continue";
     case "thinking":
       return applyThinkingCommand(app, command.level, tui);
     case "login": {
@@ -361,6 +520,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
       return { login: command.provider };
     }
     case "logout": {
+      if (tui && command.provider === undefined) { tui.openLogoutSelect(); return "continue"; }
       await logout(app, command.provider);
       return "continue";
     }
@@ -393,7 +553,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
         return "continue";
       }
       if (tui) {
-        await tui.openResumeSelect();
+        void tui.openResumeSelect();
         return "continue";
       }
       await printSessionList(app);
@@ -404,20 +564,49 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
     case "export":
       await exportSession(app, command.file);
       return "continue";
+    case "import": {
+      if (!command.file) { app.io.say("  Usage: /import <session.jsonl>"); return "continue"; }
+      const importing = async () => {
+        if (tui && !await tui.extensionUi.context.confirm("Import session", "Open the archive as a separate session? The current session stays saved.")) { app.io.say("  Import cancelled"); return; }
+        try {
+          const path = await importSessionArchive(resolve(app.workspace, command.file!), sessionsDir(app.workspace, sessionDirFor(app.args, app.workspace)), app.workspace);
+          if (await adoptLogDir(app, path)) { await bindExtensions(app, tui ?? undefined); await tui?.refreshResources(); await tui?.syncTranscript(); app.io.say(`  Imported session: ${path}`); }
+        } catch (error) { app.io.say(app.io.palette.red(`  Cannot import: ${describeError(error)}`)); }
+      };
+      if (tui) tui.runSessionTransition(importing); else await importing();
+      return "continue";
+    }
+    case "debug": {
+      const file = resolve(app.workspace, command.file ?? join(configDir(), "debug.log"));
+      const width = tui?.screen.terminal.columns ?? 80, height = tui?.screen.terminal.rows ?? 0;
+      const lines = tui?.screen.render(width) ?? [];
+      const messages = projectContext({ frozen: app.session.config.frozen, handoff: app.session.state.handoff, events: app.session.state.events });
+      const body = [`xeno diagnostics ${app.session.clock.now()}`, `Terminal: ${width}x${height}`, `Total lines: ${lines.length}`,
+        ...lines.map((line, i) => `[${i}] (w=${visibleWidth(line)}) ${JSON.stringify(line)}`), "", "Agent messages (JSONL)", ...messages.messages.map(message => JSON.stringify(message)), ""].join("\n");
+      try { await mkdir(dirname(file), { recursive: true }); await writeFile(file, body, { mode: 0o600 }); app.io.say(`  Debug log written: ${file}`); }
+      catch (error) { app.io.say(`  Cannot write debug log: ${describeError(error)}`); }
+      return "continue";
+    }
+    case "changelog": {
+      const text = await readFile(new URL("../../CHANGELOG.md", import.meta.url), "utf8");
+      if (tui) tui.showDocument(text); else app.io.say(text);
+      return "continue";
+    }
     case "copy":
-      await copyLastReply(app);
+      await copyLastReply(app, tui ?? undefined);
       return "continue";
     case "fork":
       if (tui && command.arg === undefined) { await tui.openForkSelect(); return "continue"; }
-      await forkSession(app, command.arg);
-      await tui?.syncTranscript();
+      await forkSession(app, command.arg, tui ?? undefined);
       return "continue";
     case "clone":
       await cloneSession(app);
       await tui?.syncTranscript();
       return "continue";
     case "trust":
-      await trustProject(app, command.target);
+      if (command.target) await trustProject(app, command.target, tui ?? undefined);
+      else if (tui) await tui.openTrustSelect();
+      else app.io.say("  /trust once|here|parent|never controls project resources; tool permissions are separate.");
       return "continue";
     case "models-refresh":
       await refreshModels(app);
@@ -437,24 +626,28 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
 async function handleLine(app: App, text: string, tui: Tui): Promise<Outcome> {
   if (tui.awaitingKeyFor !== null) {
     const provider = tui.awaitingKeyFor;
-    tui.awaitingKeyFor = null;
-    tui.editor.setSecret(false);
+    if (provider === OAUTH_DEVICE) {
+      if (!text) await cancelPendingOAuth(app);
+      else app.io.say("  Waiting for account login. Escape cancels.");
+      return "continue";
+    }
     if (text.length === 0) {
-      if (provider === OAUTH_PASTE) await cancelPendingOAuth();
+      if (provider === OAUTH_PASTE) await cancelPendingOAuth(app);
+      tui.endCredentialInput();
       app.io.say(app.io.palette.dim("  cancelled\n"));
       return "continue";
     }
     if (provider === OAUTH_PASTE) {
-      await completeOAuthPaste(app, text);
+      tui.editor.applyExternal("");
+      tui.runExtensionAction(() => completeOAuthPaste(app, text));
       return "continue";
     }
-    await login(app, provider, text);
+    try { await login(app, provider, text); } finally { tui.endCredentialInput(); }
     return "continue";
   }
   const outcome = await execute(app, parseLine(app, text), tui);
   if (typeof outcome === "object") {
-    tui.awaitingKeyFor = outcome.login;
-    tui.editor.setSecret(true);
+    tui.beginCredentialInput(outcome.login);
   }
   return outcome;
 }
@@ -573,71 +766,34 @@ async function commitSetting(app: App, field: string, value: string, tui: Tui |
     app.io.say(C.yellow("  settings are not available in this session"));
     return;
   }
-  if (key === "theme") {
-    const theme = value === "dark" || value === "light" ? builtinTheme(value) : app.ui.theme;
-    if (value === "dark" || value === "light") {
-      app.ui.theme = theme;
-      app.ui.style = colorEnabled() ? createStyle(theme.colors) : IDENTITY;
-    } else {
-      app.io.say(C.yellow("  theme must be dark or light (a path is --theme / file)"));
-      return;
-    }
-    app.ui.settings = { ...app.ui.settings, theme: value };
-    app.ui.userOverrides = { ...app.ui.userOverrides, theme: value };
-    await writeUserSettings({ theme: value });
-    app.io.say(C.dim(`  theme ${value}`));
-    tui?.paint();
-    return;
-  }
   if (key === "thinking") {
     const effort = asEffort(value);
-    if (effort === undefined) {
-      app.io.say(C.yellow("  thinking must be low|medium|high|xhigh|max"));
-      return;
-    }
-    if (!applyThinking(app, effort, tui)) return;
-    app.ui.settings = { ...app.ui.settings, thinking: effort };
-    app.ui.userOverrides = { ...app.ui.userOverrides, thinking: effort };
-    await writeUserSettings({ thinking: effort });
-    return;
+    if (!effort || !await applyThinking(app, effort, tui)) return;
   }
-  if (key === "statusbar" || key === "status") {
-    const on = value === "on" || value === "true" || value === "1";
-    const off = value === "off" || value === "false" || value === "0";
-    if (!on && !off) {
-      app.io.say(C.yellow("  statusBar must be on or off"));
-      return;
-    }
-    app.ui.settings = { ...app.ui.settings, statusBar: on };
-    app.ui.userOverrides = { ...app.ui.userOverrides, statusBar: on };
-    await writeUserSettings({ statusBar: on });
-    app.io.say(C.dim(`  statusBar ${on ? "on" : "off"}`));
-    tui?.paint();
-    return;
-  }
-  app.io.say(C.yellow(`  unknown setting: ${field}`));
-}
-
-function asEffort(value: string): import("../runtime/model.ts").Effort | undefined {
-  if (value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max") {
-    return value;
-  }
-  return undefined;
+  const parsed = settingPatch(key === "status" ? "statusBar" : field, value);
+  if (parsed.diagnostics.length) { app.io.say(C.yellow(parsed.diagnostics.join("\n"))); return; }
+  if (key === "theme") {
+    const diagnostics: string[] = [];
+    const theme = await resolveTheme(app.resources ? themeResourcePath(app.resources, value) ?? value : value, diagnostics);
+    if (diagnostics.length) { app.io.say(C.yellow(diagnostics.join("\n"))); return; }
+    app.ui.theme = theme;
+    app.ui.style = colorEnabled() ? createStyle(theme.colors) : IDENTITY;
+  }
+  await writeUserSettings(parsed.settings);
+  app.ui.settings = mergeSettings({ builtin: app.ui.settings, user: parsed.settings });
+  app.ui.userOverrides = mergeSettings({ builtin: app.ui.userOverrides, user: parsed.settings });
+  if (key === "enableskillcommands") { await reloadAppResources(app); await tui?.refreshResources(); }
+  app.io.say(C.dim(`  ${field} ${value}`));
+  tui?.applyConfiguration();
+  if (key === "theme") tui?.followTheme();
+  tui?.paint();
 }
 
-const EFFORTS: readonly Effort[] = ["low", "medium", "high", "xhigh", "max"];
+const EFFORTS = THINKING_LEVELS;
 
-/**
- * null in thinkingLevelMap means the model does not have that level.
- * An absent map or absent entry is passthrough, not a missing level.
- * Never treat null as "nearest neighbour" — that silently changes a
- * deliberate slower/dearer choice (feat-model-and-thinking).
- */
+/** Explicit user choices are refused; automatic model changes use the pure clamp policy. */
 function effortSupported(spec: ModelSpec, level: Effort): boolean {
-  const map = spec.thinkingLevelMap;
-  if (map === undefined) return true;
-  if (!(level in map)) return true;
-  return map[level] !== null;
+  return supportedThinkingLevels(spec).includes(level);
 }
 
 /**
@@ -645,7 +801,7 @@ function effortSupported(spec: ModelSpec, level: Effort): boolean {
  * must not cut: a cut drops the prefix cache, and thinking blocks stay
  * valid because the model did not change.
  */
-function applyThinking(app: App, level: Effort, tui: Tui | null): boolean {
+async function applyThinking(app: App, level: Effort, tui: Tui | null): Promise<boolean> {
   const C = app.io.palette;
   if (!effortSupported(app.providerConfig.spec, level)) {
     app.io.say(
@@ -659,6 +815,7 @@ function applyThinking(app: App, level: Effort, tui: Tui | null): boolean {
   if (app.credential.ok) {
     app.session.provider = makeProvider(app, app.providerConfig, app.credential.key);
   }
+  await app.session.setThinking(level);
   if (app.ui !== undefined) {
     app.ui.settings = { ...app.ui.settings, thinking: level };
   }
@@ -667,14 +824,14 @@ function applyThinking(app: App, level: Effort, tui: Tui | null): boolean {
   return true;
 }
 
-function applyThinkingCommand(app: App, level: string | undefined, tui: Tui | null): Outcome | Promise<Outcome> {
+async function applyThinkingCommand(app: App, level: string | undefined, tui: Tui | null): Promise<Outcome> {
   if (level !== undefined) {
     const effort = asEffort(level);
     if (effort === undefined) {
-      app.io.say(app.io.palette.yellow("  thinking must be low|medium|high|xhigh|max"));
+      app.io.say(app.io.palette.yellow("  thinking must be " + THINKING_LEVELS.join("|")));
       return "continue";
     }
-    applyThinking(app, effort, tui);
+    await applyThinking(app, effort, tui);
     return "continue";
   }
   if (tui) {
@@ -699,33 +856,32 @@ function printThinking(app: App): void {
   app.io.say(C.dim("\n  /thinking <level> to switch. Shift+Tab cycles supported levels.\n"));
 }
 
-function cycleThinking(app: App, tui: Tui | null): void {
+async function cycleThinking(app: App, tui: Tui | null): Promise<void> {
   const supported = EFFORTS.filter((level) => effortSupported(app.providerConfig.spec, level));
   const next = cycle(supported, app.providerConfig.effort, 1);
   if (next === undefined) return;
-  applyThinking(app, next, tui);
+  await applyThinking(app, next, tui);
 }
 
 async function cycleScopedModel(app: App, dir: 1 | -1): Promise<void> {
   const C = app.io.palette;
   const fromFlag = splitModelPatterns(app.args.models);
-  const names = fromFlag.length > 0 ? fromFlag : [...(app.ui?.settings.scopedModels ?? [])];
+  const names = app.args.modelsExplicit || fromFlag.length > 0 ? fromFlag : app.ui?.settings.scopedModels ?? app.catalog.filter(spec => app.credentialOf(spec).ok).map(modelKey);
   if (names.length === 0) {
     app.io.say(C.dim("  no scoped models. Pass --models a,b or set scopedModels."));
     return;
   }
-  const ids: string[] = [];
-  for (const pattern of names) {
-    const found = findModelByPattern(pattern, app.catalog);
-    if (found.ok && !ids.includes(found.spec.id)) ids.push(found.spec.id);
-  }
+  const scope = scopedModels(names, app.catalog.filter(spec => app.credentialOf(spec).ok));
+  for (const message of scope.diagnostics) app.io.say(C.yellow(`  ${message}`));
+  const ids = scope.entries.map(entry => modelKey(entry.model));
   if (ids.length === 0) {
     app.io.say(C.yellow("  --models matched nothing"));
     return;
   }
-  const next = cycle(ids, app.providerConfig.spec.id, dir);
-  if (next === undefined || next === app.providerConfig.spec.id) return;
-  await switchByPattern(app, next);
+  const next = cycle(ids, modelKey(app.providerConfig.spec), dir);
+  if (next === undefined) return;
+  const selected = scope.entries.find(entry => modelKey(entry.model) === next)!;
+  await switchToModel(app, selected.model, selected.thinking);
 }
 
 function printHelp(app: App): void {
@@ -735,6 +891,7 @@ function printHelp(app: App): void {
     const hint = "argumentHint" in command ? ` ${command.argumentHint}` : "";
     app.io.say(`  /${(command.name + hint).padEnd(34)} ${command.description}`);
   }
+  for (const [name, command] of app.extensions?.commands ?? []) app.io.say(`  /${name.padEnd(34)} ${command.description ?? "Extension command"}`);
   app.io.say('  @file or @"file name"  attach a project file anywhere in the prompt');
   app.io.say("  !cmd              run in the workspace and send stdout/stderr/exit to the model");
   app.io.say("  !!cmd             run without sending output");
@@ -756,7 +913,7 @@ async function printSession(app: App): Promise<void> {
 
 async function printSessionList(app: App): Promise<void> {
   const C = app.io.palette;
-  const { sessions, truncated } = await listSessions(app.workspace, sessionDirOf(app));
+  const { sessions, truncated } = await listSessions(app.workspace, sessionDirOf(app), Infinity);
   const note = truncationNote(truncated);
   app.io.say(C.bold("\nsessions"));
   if (note) app.io.say(C.yellow(`  ${note}`));
@@ -828,31 +985,29 @@ async function printTree(app: App): Promise<void> {
 }
 
 async function treeNodesFor(app: App): Promise<TreeNode[]> {
-  const points = await app.session.restorePoints();
   const parents = await loadNodeParents(app.logDir);
-  const messages = new Map<string, TreeNode[]>();
+  const manifest = await readManifest(app.logDir);
+  const history = await readNodeHistory(app.logDir, app.session.state.node);
+  if (!history.ok) throw new Error(history.error);
+  const onPath = new Set(history.nodes.flatMap(n => n.events.map(e => `${n.node}:${e.id}`)));
+  const points: TreePoint[] = [];
   for (const node of parents.keys()) {
-    const { events } = await readNode(app.logDir, node);
-    const turns = points.filter((point) => point.node === node);
-    let turn = -1;
+    const { events, corrupt } = await readNode(app.logDir, node);
+    if (corrupt.length) throw new Error("Cannot display corrupt session events");
     for (const event of events) {
-      if (event.t === "user") { turn++; continue; }
-      const point = turns[turn];
-      if (!point) continue;
-      const target = `${point.node}:${point.atEvent}`;
-      const labels = event.t === "assistant" ? event.blocks.map((block) =>
-        block.type === "tool_use" ? `tool · ${block.name}` : `${block.type === "text" ? "assistant" : "thinking"} · ${firstLine(block.text, 120)}`)
-        : event.t === "tool_result" ? [`tool result · ${event.ok ? "ok" : "failed"} · ${firstLine(event.content, 100)}`]
-        : event.t === "cut" ? [`context boundary · ${event.reason}`] : [];
-      const children = messages.get(target) ?? [];
-      labels.forEach((prompt, i) => children.push({ id: `${node}:${event.id}:${i}`, target, prompt,
-        onPath: point.onPath, current: false, kind: "other", children: [] }));
-      messages.set(target, children);
+      const content = event.t === "user" ? [event.text, ...(event.images ?? []).map(i => `[Image: ${i.name}]`)].filter(Boolean).join("\n") :
+        event.t === "assistant" ? event.blocks.map(b => b.type === "tool_use" ? `tool · ${b.name} ${JSON.stringify(b.input)}` : `${b.type === "thinking" ? "thinking · " : ""}${b.text}`).join("\n") :
+        event.t === "tool_result" ? event.content : event.t === "user_bash" ? `$ ${event.command}\n${event.content}` :
+        event.t === "cut" ? `context boundary · ${event.reason}` : JSON.stringify(event);
+      const tool = event.t === "tool_result" || event.t === "user_bash" || event.t === "assistant" && event.blocks.every(b => b.type === "tool_use");
+      const category = tool ? "tool" : event.t === "user" || event.t === "assistant" ? "message" : "metadata";
+      const label = manifest.labels?.[event.id];
+      points.push({ node, atEvent: event.id, target: event.id, prompt: `${event.t === "user" ? "" : event.t === "assistant" ? "assistant · " : `${event.t} · `}${firstLine(content, 160)}`,
+        onPath: onPath.has(`${node}:${event.id}`), kind: event.t === "user" ? "user" : "other", category, content, at: event.at,
+        ...(label ? { label: label.text, labelAt: label.at } : {}) });
     }
   }
-  const enrich = (nodes: readonly TreeNode[]): TreeNode[] => nodes.map((node) => ({ ...node,
-    children: [...(messages.get(node.id) ?? []), ...enrich(node.children)] }));
-  return enrich(treeFromPoints(points, parents, app.session.state.node));
+  return treeFromPoints(points, parents, app.session.state.node);
 }
 
 async function loadNodeParents(logDir: string): Promise<Map<number, NodeParent>> {
@@ -963,7 +1118,7 @@ function printModels(app: App): void {
     app.io.say(C.bold(`  ${group.provider}`));
     for (const spec of group.models) {
       const got = app.credentialOf(spec);
-      const here = spec.id === app.providerConfig.spec.id;
+      const here = modelKey(spec) === modelKey(app.providerConfig.spec);
       const mark = here ? C.cyan(" now ") : got.ok ? C.green("ready") : C.dim("  -- ");
       app.io.say(`    ${mark}  ${spec.id.padEnd(28)}${C.dim(spec.name.padEnd(28))}${whyNot(spec, got, app.auth, C)}`);
     }
@@ -976,19 +1131,18 @@ async function refreshModels(app: App): Promise<void> {
   const C = app.io.palette;
   const result = await runModelsRefresh({
     fetch: globalThis.fetch,
-    write: writeModelsFile,
+    write: writeCatalogCache,
   });
   if (!result.ok) {
     app.io.say(C.yellow(`  ${result.reason}`));
     app.io.say(C.dim("  existing models.json left unchanged\n"));
     return;
   }
-  const userFile = await readModelsText();
-  const loaded = loadCatalog({ userText: userFile.text });
-  app.catalog = loaded.models;
+  const loaded = loadCatalog(await readModelSources());
+  await publishModelCatalog(app, loaded.models);
   for (const warning of loaded.warnings) app.io.say(C.yellow(`  ${warning}`));
   app.io.say(
-    C.green(`  added ${result.added}, changed ${result.changed} (${result.count} total) → ${modelsPath()}`),
+    C.green(`  added ${result.added}, changed ${result.changed} (${result.count} total) → ${catalogCachePath()}`),
   );
   app.io.say(C.dim(`  ${app.catalog.length} reachable after overlay\n`));
 }
@@ -1001,8 +1155,9 @@ async function login(app: App, provider: string, key: string): Promise<void> {
     app.io.say(C.dim(`  known: ${[...new Set(app.catalog.map((m) => m.provider))].join(", ")}\n`));
     return;
   }
-  app.auth[provider] = { type: "api_key", key };
-  await writeAuthFile(app.auth);
+  const next = { ...app.auth, [provider]: { type: "api_key" as const, key } };
+  await writeAuthFile(next);
+  app.auth[provider] = next[provider]!;
   // The editor masked the paste. Printing `key` here would be the only
   // remaining way it reaches scrollback.
   app.io.say(C.green(`  stored ${provider} in ${authPath()}`) + C.dim("  (mode 0600)"));
@@ -1033,8 +1188,13 @@ async function logout(app: App, provider: string | undefined): Promise<void> {
     app.io.say(C.dim(`  no stored credential for ${provider}\n`));
     return;
   }
+  const next = { ...app.auth };
+  delete next[provider];
+  await writeAuthFile(next);
   delete app.auth[provider];
-  await writeAuthFile(app.auth);
+  const resolved = app.credentialOf(app.providerConfig.spec);
+  app.credential = resolved;
+  app.session.provider = makeProvider(app, app.providerConfig, resolved.ok ? resolved.key : "");
   app.io.say(C.green(`  removed ${provider} from ${authPath()}\n`));
 }
 
@@ -1044,7 +1204,7 @@ function providerOAuthOpts(app: App, spec: ModelSpec): { oauth: true } | undefin
 }
 
 function makeProvider(app: App, config: ProviderConfig, key: string) {
-  return createProvider(config, key, retryHandler(app.io), providerOAuthOpts(app, config.spec));
+  return createProvider(config, key, retryHandler(app.io), { ...providerOAuthOpts(app, config.spec), effects: app.effects });
 }
 
 interface PendingOAuth {
@@ -1057,22 +1217,28 @@ interface PendingOAuth {
   server: CallbackServer;
   done: boolean;
   tui: Tui | null;
+  abort: AbortController;
 }
 
-let pendingOAuth: PendingOAuth | null = null;
+// Authentication is scoped to its application, independent of the model/session log.
+const pendingLogins = new WeakMap<App, PendingOAuth>();
+const pendingDevices = new WeakMap<App, { abort: AbortController; tui: Tui | null }>();
+const loginEffects = { fetch: ((input, init) => globalThis.fetch(input, init)) as typeof globalThis.fetch,
+  openBrowser: tryOpenBrowser, callback: startCallbackServer, device: loginGitHubCopilot };
 
-async function cancelPendingOAuth(): Promise<void> {
-  const pending = pendingOAuth;
-  pendingOAuth = null;
-  if (pending === null) return;
-  pending.done = true;
-  await pending.server.close();
+async function cancelPendingOAuth(app: App): Promise<void> {
+  const pending = pendingLogins.get(app), device = pendingDevices.get(app);
+  pendingLogins.delete(app); pendingDevices.delete(app);
+  device?.abort.abort(); pending?.abort.abort();
+  const tui = pending?.tui ?? device?.tui;
+  tui?.endCredentialInput();
+  if (pending) { pending.done = true; await pending.server.close(); }
 }
 
 async function storeOAuth(app: App, provider: string, credential: OAuthCredential): Promise<void> {
   const C = app.io.palette;
+  await writeAuthFile({ ...app.auth, [provider]: credential });
   app.auth[provider] = credential;
-  await writeAuthFile(app.auth);
   app.io.say(C.green(`  stored ${provider} in ${authPath()}`) + C.dim("  (mode 0600)"));
   const ready = app.catalog.filter((m) => m.provider === provider && app.credentialOf(m).ok);
   if (ready.length === 0) {
@@ -1087,11 +1253,7 @@ async function storeOAuth(app: App, provider: string, credential: OAuthCredentia
 async function finishOAuthCode(app: App, pending: PendingOAuth, code: string): Promise<void> {
   if (pending.done) return;
   pending.done = true;
-  pendingOAuth = null;
-  if (pending.tui) {
-    pending.tui.awaitingKeyFor = null;
-    pending.tui.editor.setSecret(false);
-  }
+  const effects = pending.tui?.oauthEffects ?? loginEffects;
   try {
     const credential =
       pending.exchange === "anthropic"
@@ -1100,36 +1262,44 @@ async function finishOAuthCode(app: App, pending: PendingOAuth, code: string): P
             state: pending.state,
             verifier: pending.verifier,
             redirectUri: pending.redirectUri,
-            fetch: globalThis.fetch,
+            fetch: effects.fetch,
+            signal: pending.abort.signal,
           })
         : await exchangeOpenAICode({
             code,
             verifier: pending.verifier,
             redirectUri: pending.redirectUri,
-            fetch: globalThis.fetch,
+            fetch: effects.fetch,
+            signal: pending.abort.signal,
           });
+    if (pending.abort.signal.aborted || pendingLogins.get(app) !== pending) return;
     await storeOAuth(app, pending.provider, credential);
   } catch (err) {
+    if (pending.abort.signal.aborted || pendingLogins.get(app) !== pending) return;
     const message = err instanceof Error ? err.message : "token exchange failed";
     app.io.say(app.io.palette.red(`  ${message}`));
     app.io.say(app.io.palette.dim("  nothing was stored.\n"));
   } finally {
+    if (pendingLogins.get(app) === pending) {
+      pendingLogins.delete(app);
+      pending.tui?.endCredentialInput();
+    }
     await pending.server.close();
   }
 }
 
 async function completeOAuthPaste(app: App, input: string): Promise<void> {
-  const pending = pendingOAuth;
-  if (pending === null || pending.done) return;
+  const pending = pendingLogins.get(app);
+  if (!pending || pending.done) return;
   const parsed = parseAuthorizationInput(input);
   if (parsed.state !== undefined && parsed.state !== pending.state) {
     app.io.say(app.io.palette.red("  OAuth state mismatch"));
-    await cancelPendingOAuth();
+    await cancelPendingOAuth(app);
     return;
   }
   if (!parsed.code) {
     app.io.say(app.io.palette.red("  Missing authorization code"));
-    await cancelPendingOAuth();
+    await cancelPendingOAuth(app);
     return;
   }
   await finishOAuthCode(app, pending, parsed.code);
@@ -1147,23 +1317,35 @@ async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Pr
   const C = app.io.palette;
   const sub = subscriptionById(id);
   if (sub === undefined) return "continue";
+  await cancelPendingOAuth(app);
+  const effects = tui?.oauthEffects ?? loginEffects;
   app.io.say(C.yellow(`  ${SUBSCRIPTION_NOTICE}`));
   if (sub.id === "github-copilot") {
-    try {
-      const credential = await loginGitHubCopilot({
-        notify: (message) => app.io.say(`  ${message}`),
+    const pending = { abort: new AbortController(), tui };
+    pendingDevices.set(app, pending);
+    const work = async () => { try {
+      const credential = await effects.device({
+        notify: (message) => { if (pendingDevices.get(app) === pending) app.io.say(`  ${message}`); },
         prompt: async () => "",
-        fetch: globalThis.fetch,
-        signal: new AbortController().signal,
+        fetch: effects.fetch,
+        signal: pending.abort.signal,
       });
+      if (pending.abort.signal.aborted || pendingDevices.get(app) !== pending) return;
       await storeOAuth(app, sub.provider, credential);
     } catch (err) {
+      if (pending.abort.signal.aborted || pendingDevices.get(app) !== pending) return;
       const message = err instanceof Error ? err.message : "login failed";
       app.io.say(C.red(`  ${message}\n`));
-    }
+    } finally {
+      if (pendingDevices.get(app) === pending) {
+        pendingDevices.delete(app);
+        tui?.endCredentialInput();
+      }
+    } };
+    if (tui) { tui.beginCredentialInput(OAUTH_DEVICE); tui.runExtensionAction(work); return "continue"; }
+    await work();
     return "continue";
   }
-  await cancelPendingOAuth();
   const pkce = await generatePKCE();
   const state = generateState();
   const anthropic = sub.id === "claude-pro";
@@ -1172,7 +1354,7 @@ async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Pr
     : openaiCodexAuthorizeUrl({ challenge: pkce.challenge, state });
   let server: CallbackServer;
   try {
-    server = await startCallbackServer({
+    server = await effects.callback({
       expectedState: state,
       host: "127.0.0.1",
       port: anthropic ? ANTHROPIC_CALLBACK_PORT : OPENAI_CALLBACK_PORT,
@@ -1192,7 +1374,7 @@ async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Pr
   }
   app.io.say(`  ${url}`);
   app.io.say(C.dim("  complete login in the browser, or paste the redirect URL. It is not shown."));
-  tryOpenBrowser(url);
+  effects.openBrowser(url);
   const pending: PendingOAuth = {
     id: sub.id,
     provider: sub.provider,
@@ -1203,8 +1385,9 @@ async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Pr
     server,
     done: false,
     tui,
+    abort: new AbortController(),
   };
-  pendingOAuth = pending;
+  pendingLogins.set(app, pending);
   void pending.server.waitForCode().then(async (got) => {
     if (!got.ok || pending.done) return;
     await finishOAuthCode(app, pending, got.code);
@@ -1232,14 +1415,14 @@ async function adoptCredential(app: App, ready: readonly ModelSpec[]): Promise<v
   if (spec === undefined) return;
   const got = app.credentialOf(spec);
   if (!got.ok) return;
-  if (app.credential.ok) {
+  if (app.credential.ok || app.session.state.handoff !== null || app.session.state.events.some((e) => e.t === "assistant")) {
     await switchToModel(app, spec);
     return;
   }
   const nextConfig: ProviderConfig = {
     spec,
     maxTokens: outputTokenBudget(spec),
-    effort: app.providerConfig.effort,
+    effort: clampThinkingLevel(spec, app.ui?.settings.modelThinkingLevels?.[modelKey(spec)] ?? app.providerConfig.effort),
     thinkingDisplay: app.providerConfig.thinkingDisplay,
   };
   app.session.provider = makeProvider(app, nextConfig, got.key);
@@ -1250,6 +1433,8 @@ async function adoptCredential(app: App, ready: readonly ModelSpec[]): Promise<v
     await writeCursor(app.logDir, {
       ...cursor,
       model: spec.id,
+      provider: spec.provider,
+      thinking: nextConfig.effort,
       updated_at: app.session.clock.now(),
     });
   }
@@ -1258,17 +1443,19 @@ async function adoptCredential(app: App, ready: readonly ModelSpec[]): Promise<v
 
 async function switchByPattern(app: App, pattern: string): Promise<void> {
   const C = app.io.palette;
-  const found = findModelByPattern(pattern, app.catalog);
-  if (!found.ok) {
-    app.io.say(C.red(`  ${found.reason}`));
+  const found = scopedModels([pattern], app.catalog, true), selected = found.entries[0];
+  if (!selected) {
+    const diagnostic = findModelByPattern(pattern, app.catalog);
+    app.io.say(C.red(`  ${diagnostic.ok ? found.diagnostics.join("; ") : diagnostic.reason}`));
     return;
   }
-  await switchToModel(app, found.spec);
+  await switchToModel(app, selected.model, selected.thinking);
 }
 
-async function switchToModel(app: App, spec: ModelSpec): Promise<void> {
+async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort): Promise<void> {
   const C = app.io.palette;
-  if (spec.id === app.providerConfig.spec.id) {
+  if (spec.id === app.providerConfig.spec.id && spec.provider === app.providerConfig.spec.provider) {
+    if (thinking) await applyThinking(app, clampThinkingLevel(spec, thinking), null);
     app.io.say(C.dim(`  already on ${spec.id}`));
     return;
   }
@@ -1283,7 +1470,7 @@ async function switchToModel(app: App, spec: ModelSpec): Promise<void> {
   const nextConfig: ProviderConfig = {
     spec,
     maxTokens: outputTokenBudget(spec),
-    effort: app.providerConfig.effort,
+    effort: clampThinkingLevel(spec, thinking ?? app.ui?.settings.modelThinkingLevels?.[modelKey(spec)] ?? app.providerConfig.effort),
     thinkingDisplay: app.providerConfig.thinkingDisplay,
   };
   const next = makeProvider(app, nextConfig, got.key);
@@ -1301,7 +1488,7 @@ async function switchToModel(app: App, spec: ModelSpec): Promise<void> {
 }
 
 function sessionDirOf(app: App): string | undefined {
-  return (app.args.sessionDir ?? "").length > 0 ? app.args.sessionDir : undefined;
+  return sessionDirFor(app.args, app.workspace);
 }
 
 async function openNewSession(app: App, tui?: Tui): Promise<void> {
@@ -1337,26 +1524,26 @@ async function resumeSession(app: App, idOrPath: string, tui?: Tui): Promise<voi
 }
 
 async function adoptLogDir(app: App, logDir: string): Promise<boolean> {
-  const next = createSessionFor({
-    args: app.args,
-    workspace: app.workspace,
-    logDir,
-    blobDir: app.blobDir,
-    system: app.system,
-    providerConfig: app.providerConfig,
-    credential: app.credential,
-    io: app.io,
-    askSlot: app.askSlot,
-    ...(providerOAuthOpts(app, app.providerConfig.spec) ? { oauth: true } : {}),
-  });
   try {
-    await next.start();
+    const opened = await openSessionFor({ ...app, logDir, fallback: app.providerConfig, interactive: true });
+    await app.extensions?.dispose();
+    app.session = opened.session;
+    app.providerConfig = opened.providerConfig;
+    app.credential = opened.credential;
+    app.logDir = logDir;
+    app.workspace = opened.workspace;
+    app.blobDir = opened.blobDir;
+    app.system = opened.system;
+    app.loadedContext = opened.resources.loadedContext;
+    app.slash = opened.resources.slash;
+    app.ui = opened.resources.ui;
+    app.resources = opened.resources.index;
+    app.projectTrusted = opened.resources.trusted;
+    app.extensions = opened.resources.extensions;
   } catch (err) {
     app.io.say(app.io.palette.red(`  ${describeError(err)}`));
     return false;
   }
-  app.session = next;
-  app.logDir = logDir;
   return true;
 }
 
@@ -1373,15 +1560,13 @@ async function exportSession(app: App, file?: string): Promise<void> {
   const dest = file !== undefined && file.length > 0 ? file : defaultPath;
   const abs = dest.startsWith("/") ? dest : join(app.workspace, dest);
   const html = abs.toLowerCase().endsWith(".jsonl") === false;
-  const body = html
-    ? toHtml(events, {
+  try {
+    if (html) await writeFile(abs, toHtml(events, {
         title: basename(app.logDir),
         exportedAt: app.session.clock.now(),
         sessionId: basename(app.logDir),
-      })
-    : toJsonl(events);
-  try {
-    await writeFile(abs, body, "utf8");
+      }), "utf8");
+    else await exportSessionArchive(app.logDir, abs, app.blobDir);
   } catch (err) {
     app.io.say(C.red(`  cannot write ${abs}: ${describeError(err)}`));
     return;
@@ -1389,51 +1574,25 @@ async function exportSession(app: App, file?: string): Promise<void> {
   app.io.say(C.green(`  exported ${abs}`));
 }
 
-async function copyLastReply(app: App): Promise<void> {
+async function copyLastReply(app: App, tui?: Tui): Promise<void> {
   const C = app.io.palette;
   const text = lastAssistantText(await transcriptEvents(app));
   if (text === null) {
     app.io.say(C.dim("  no assistant reply to copy yet"));
     return;
   }
-  const copied = copyToClipboard(text);
+  const copied = await (tui?.clipboardWriter ?? writeClipboard)(text);
   if (copied) {
     app.io.say(C.green("  copied last assistant reply"));
     return;
   }
-  app.io.say(C.yellow("  no clipboard command (tried pbcopy, wl-copy, xclip). Printing it instead:"));
+  app.io.say(C.yellow("  Clipboard unavailable. Printing the reply instead:"));
   app.io.say(text);
 }
 
-/**
- * System clipboard without an npm package. Missing binaries are a fallback
- * that prints the text, not a silent no-op.
- */
-function copyToClipboard(text: string): boolean {
-  const cmds: string[][] = [
-    ["pbcopy"],
-    ["wl-copy"],
-    ["xclip", "-selection", "clipboard"],
-  ];
-  for (const cmd of cmds) {
-    try {
-      const proc = Bun.spawnSync({
-        cmd,
-        stdin: Buffer.from(text),
-        stdout: "ignore",
-        stderr: "ignore",
-      });
-      if (proc.exitCode === 0) return true;
-    } catch {
-      // Try the next binary.
-    }
-  }
-  return false;
-}
-
-async function forkSession(app: App, arg?: string): Promise<void> {
+async function forkSession(app: App, arg?: string, tui?: Tui): Promise<void> {
   const C = app.io.palette;
-  const points = await app.session.restorePoints();
+  const points = await app.session.userMessages();
   if (arg === undefined) {
     app.io.say(C.bold("\nfork from a user turn") + C.dim("  (newest last)"));
     if (points.length === 0) {
@@ -1443,9 +1602,9 @@ async function forkSession(app: App, arg?: string): Promise<void> {
     }
     points.forEach((p, i) => {
       const n = String(i + 1).padStart(2);
-      app.io.say(`  ${C.bold(n)}  ${firstLine(p.prompt, 60)}`);
+      app.io.say(`  ${C.bold(n)}  ${firstLine(p.text, 60)}`);
     });
-    app.io.say(C.dim("\n  /fork <n>  copies up to that turn into a new session\n"));
+    app.io.say(C.dim("\n  /fork <n>  resumes before that user message and restores its draft\n"));
     return;
   }
   const i = Number(arg);
@@ -1454,39 +1613,46 @@ async function forkSession(app: App, arg?: string): Promise<void> {
     app.io.say(C.red(`  no such turn: ${arg}. /fork lists them.`));
     return;
   }
-  await spawnForkedSession(app, point.atEvent, `forked at ${firstLine(point.prompt, 40)}`);
+  if (await spawnForkedSession(app, point.id, `forked before ${firstLine(point.text, 40)}`, "before")) {
+    await tui?.syncTranscript();
+    tui?.restoreDraft(point.text, point.images ?? []);
+    tui?.paint();
+  }
 }
 
 async function cloneSession(app: App): Promise<void> {
   await spawnForkedSession(app, undefined, "cloned");
 }
 
-async function spawnForkedSession(app: App, untilEvent: string | undefined, label: string): Promise<void> {
+async function spawnForkedSession(app: App, untilEvent: string | undefined, label: string, position: "at" | "before" = "at"): Promise<boolean> {
   const C = app.io.palette;
   const created = await createSession(app.workspace, undefined, sessionDirOf(app));
   try {
-    await app.session.fork(created.path, untilEvent);
+    await app.session.fork(created.path, untilEvent, position);
   } catch (err) {
     app.io.say(C.red(`  cannot fork: ${describeError(err)}`));
-    return;
+    return false;
   }
   const switched = await adoptLogDir(app, created.path);
-  if (!switched) return;
+  if (!switched) return false;
   app.io.say(C.green(`  ${label} → ${created.id}`) + C.dim(`  ${created.path}`));
+  return true;
 }
 
-async function trustProject(app: App, target: "here" | "parent" | "never"): Promise<void> {
+async function trustProject(app: App, target: TrustChoice, tui?: Tui): Promise<void> {
   const C = app.io.palette;
   const dir = target === "parent" ? dirname(app.workspace) : app.workspace;
-  const trusted = target !== "never";
-  await saveTrust(dir, trusted);
+  const trusted = await applyTrustChoice(app.workspace, target);
+  app.projectTrusted = trusted;
   app.io.say(
     C.green(`  ${trusted ? "trusted" : "will not trust"} ${dir}`) +
-      C.dim(`  saved in ${trustPath()}`),
+      C.dim(target === "once" ? "  for this session" : `  saved in ${trustPath()}`),
   );
   app.io.say(
-    C.dim("  restart to load or skip .xeno/settings.json. Trust does not affect tool execution."),
+    C.dim("  Project resources reloaded. Tool permissions remain separate."),
   );
+  await reloadAppResources(app);
+  await tui?.refreshResources();
 }
 
 async function nameSession(app: App, name: string, tui?: Tui): Promise<void> {
@@ -1509,13 +1675,29 @@ async function nameSession(app: App, name: string, tui?: Tui): Promise<void> {
 }
 
 /** Runs a prompt. Returns false if the turn failed, having already said why. */
-async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Tui): Promise<boolean> {
+async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Tui, images: readonly ImageRef[] = []): Promise<boolean> {
+  if (app.extensions && !initializedExtensions.has(app.extensions)) await bindExtensions(app, tui);
+  for (const result of await app.extensions?.emit("input", { text: prompt, images, source: "interactive" }) ?? []) {
+    if (result["action"] === "handled") return true;
+    if (result["action"] === "transform" && typeof result["text"] === "string") prompt = result["text"];
+  }
+  if (prompt.startsWith("!")) {
+    const excluded = prompt.startsWith("!!");
+    if (tui) tui.beginBash(prompt.slice(excluded ? 2 : 1));
+    const result = await app.session.runUserBash(prompt.slice(excluded ? 2 : 1), excluded, signal,
+      tui ? chunk => tui.pushBash(chunk) : undefined);
+    if (tui) { await tui.syncTranscript(); tui.commitStream(); }
+    else app.io.say(`$ ${result.command}\n${result.content}`);
+    return true;
+  }
   if (!app.credential.ok) {
     // Must not call session.send: that records a user event before the
     // request, and a refused prompt is not a turn.
     const C = app.io.palette;
     app.io.say(C.yellow("  no credential yet -- this prompt was not sent."));
+    app.io.say(C.dim(`  ${app.credential.reason}`));
     app.io.say(C.dim("  export an API key, or /login <provider>.\n"));
+    tui?.restoreDraft(prompt, images);
     return false;
   }
 
@@ -1538,6 +1720,7 @@ async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Tui): P
     const C = app.io.palette;
     app.io.say(C.red(`  ${fresh.reason}`));
     app.io.say(C.dim("  this prompt was not sent.\n"));
+    tui?.restoreDraft(prompt, images);
     return false;
   }
   if (!app.credential.ok || fresh.key !== app.credential.key) {
@@ -1545,6 +1728,8 @@ async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Tui): P
     app.session.provider = makeProvider(app, app.providerConfig, fresh.key);
   }
 
+  let input: UserInput;
+  try {
   const needsIndex = fileReferences(prompt).length > 0;
   const index: FileIndex = needsIndex
     ? await fileIndexFor(app)
@@ -1553,10 +1738,23 @@ async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Tui): P
     workspace: app.workspace,
     index,
     say: (text) => app.io.say(text),
+    attachImage: path => attachImageFile(path, app.blobDir, app.ui?.settings.images?.autoResize ?? true),
   });
-  if (!expanded.send) return true;
+  if (!expanded.send && !images.length) return true;
+  const attached = [...images, ...expanded.images ?? []];
+  input = attached.length ? { text: expanded.message, images: attached } : expanded.message;
+  app.session.config.imageOptions = app.ui?.settings.images ?? {};
+  if (attached.length && (app.ui?.settings.images?.blockImages || !app.providerConfig.spec.input?.includes("image"))) {
+    app.io.say("  Images are kept in this session; this request uses text placeholders because " +
+      (app.ui?.settings.images?.blockImages ? "image transmission is disabled." : "the selected model does not support image input."));
+  }
+  } catch (error) {
+    app.io.say("  Attachment failed: " + describeError(error));
+    tui?.restoreDraft(prompt, images);
+    return false;
+  }
   try {
-    await runTurn(app, expanded.message, signal, tui);
+    await runTurn(app, input, signal, tui);
     return true;
   } catch (error) {
     tui?.discardStream();
@@ -1578,17 +1776,18 @@ export interface TurnSurface {
   discardStream(): void;
   /** Tool/thinking events that stay in the live region until commit. */
   pushEvent?(e: LoopEvent): void;
+  pushProgress?(progress: NonNullable<LoopEvent["progress"]>): void;
   /**
    * Called by send() at a pairable after_tools moment. Returns already
    * expanded text, or null. Expansion happens here, not at enqueue —
    * the model is editing files while the line waits.
    */
-  pullQueued?(phase: Phase): Promise<string | null>;
+  pullQueued?(phase: Phase): Promise<UserInput | null>;
 }
 
 export async function runTurn(
-  app: Pick<App, "session" | "io"> & { readonly ui?: App["ui"]; readonly args?: App["args"] },
-  prompt: string,
+  app: Pick<App, "session" | "io"> & { readonly ui?: App["ui"]; readonly args?: App["args"]; readonly extensions?: App["extensions"] },
+  prompt: UserInput,
   signal?: AbortSignal,
   tui?: TurnSurface,
 ): Promise<void> {
@@ -1598,19 +1797,33 @@ export async function runTurn(
   let skipFinal = false;
   const json = app.args?.mode === "json";
   const pull = tui?.pullQueued?.bind(tui);
-  for await (const e of app.session.send(prompt, signal, pull)) {
+  const registry = app.extensions;
+  const before = await registry?.emit("before_agent_start", { prompt: userInputData(prompt).text, systemPrompt: app.session.config.frozen.system }) ?? [];
+  for (const result of before) {
+    if (typeof result["systemPrompt"] === "string" && result["systemPrompt"] !== app.session.config.frozen.system)
+      await app.session.reloadResources({ ...app.session.config.frozen, system: result["systemPrompt"] });
+  }
+  await registry?.emit("agent_start");
+  await registry?.emit("turn_start", { turnIndex: 0 });
+  try { for await (const e of app.session.send(prompt, signal, pull)) {
+    if (e.kind === "text_delta" || e.kind === "thinking_delta") await registry?.emit("message_update", { assistantMessageEvent: { type: e.kind, delta: e.text } });
+    if (e.kind === "assistant_text") await registry?.emit("message_end", { message: { role: "assistant", content: [{ type: "text", text: e.text }] } });
+    if (e.kind === "done") await registry?.emit("turn_end", { reason: e.reason });
     if (json) {
       const payload = toJsonEvent(e, app.session.clock.now());
       if (payload !== null) process.stdout.write(`${JSON.stringify(payload)}\n`);
       continue;
     }
+    if (e.kind === "progress") { if (e.progress) tui?.pushProgress?.(e.progress); continue; }
     if (tui?.syncTranscript) {
+      if (e.kind === "usage" && e.ok === false && e.prefix && app.ui?.settings.showCacheMissNotices === true)
+        app.io.say(app.io.palette.yellow(`  Cache: ${e.prefix}`));
       if (e.kind === "text_delta" || e.kind === "thinking_delta") {
         tui.pushDelta(e.kind === "text_delta" ? "text" : "thinking", e.text ?? "");
       } else {
         if (e.kind === "discard") tui.discardStream();
         await tui.syncTranscript();
-        if (["assistant_text", "thinking", "tool_call", "done", "cut"].includes(e.kind)) tui.commitStream();
+        if (["assistant_text", "thinking", "tool_call", "tool_result", "done", "cut"].includes(e.kind)) tui.commitStream();
         if (e.kind === "snapshot_failed" || e.kind === "undeclared_change" || e.kind === "stop_and_ask") {
           for (const line of formatEvent(e, app.io.palette, usableColumns(process.stdout.columns), {}, app.ui?.style)) app.io.say(line);
         }
@@ -1661,7 +1874,7 @@ export async function runTurn(
     )) {
       app.io.say(line);
     }
-  }
+  } } finally { await registry?.emit("agent_end", { messages: structuredClone(app.session.state.events) }); }
 }
 
 // ---------------------------------------------------------------------------
@@ -1671,12 +1884,31 @@ export async function runTurn(
 export class Tui {
   readonly term: Terminal;
   editor: Editor;
+  readonly extensionUi: ExtensionUiController;
   /** Not yet delivered. Retracting a line must leave no trace in `.xeno/`. */
   queue: QueuedMessage[] = [];
+  pendingImages: ImageRef[] = [];
+  clipboardReader = readClipboard;
+  oauthEffects = { ...loginEffects };
+  clipboardWriter: (text: string) => boolean | Promise<boolean> = writeClipboard;
+  private pasteBuffer = "";
+  private readonly displayImages = new Map<string, string>();
+  private readonly unavailableImages = new Set<string>();
+  private readonly markdownFeatures: MarkdownFeatures = {
+    highlight: (code, lang, style) => highlightCode(code, lang, (token, text) => style.token?.(token, text) ?? text),
+    transform: (text, width, streaming, style, messageType = "assistant") => transformMermaid(this.extensionUi.transformMarkdown(text, width, streaming, messageType), width, this.app.ui?.settings.markdown?.mermaid ?? "streaming", streaming,
+      (token, content) => style.token?.(token, content) ?? content),
+  };
   select: SelectList | null = null;
   settings: Settings | null = null;
   tree: TreeList | null = null;
-  screen: TuiMainScreen;
+  screen: InteractiveScreen;
+  private readonly document: PaddedDocument;
+  private readonly viewport: ChatViewport;
+  private stopThemeWatch: (() => void) | undefined;
+  private stopColorWatch: (() => void) | undefined;
+  private themeGeneration = 0;
+  private previewTheme: Theme | undefined;
   private readonly chat: Container;
   private noticeDir: string;
   private readonly transcript = new Transcript();
@@ -1693,7 +1925,18 @@ export class Tui {
   liveRows = 0;
   abort: AbortController | null = null;
   inflight = false;
+  private sessionTransition = false;
+  executionKind: "idle" | "model" | "bash" | "shutdown" = "idle";
+  shutdownRequested = false;
+  private bashOutput: string | null = null;
+  private bashDecoder = new TextDecoder();
+  private readonly toolArguments = new Map<string, { name: string; arguments: string }>();
+  private toolOutput = "";
+  private retryUntil = 0;
+  private retryAttempt = 0;
+  private retryTimer: ReturnType<typeof setInterval> | undefined;
   awaitingKeyFor: string | null = null;
+  private credentialDraft: string | undefined;
   streamThinking = "";
   streamText = "";
   flushed = 0;
@@ -1701,44 +1944,156 @@ export class Tui {
   thinkingExpanded = false;
   sessionName: string | null;
   private onPick: ((item: SelectItem) => Promise<void>) | null = null;
+  private onSelectCancel: (() => void) | undefined;
   private onTreePick: ((node: TreeNode) => Promise<void>) | null = null;
   /** Which selector Ctrl+S should persist. Other lists ignore Ctrl+S. */
-  private selectKind: "model" | "thinking" | "other" = "other";
+  private selectKind: "model" | "scoped-models" | "thinking" | "other" = "other";
   private approvalResolve: ((choice: ApprovalChoice) => void) | null = null;
   private inputs: string[] = [];
   private wake: (() => void) | null = null;
   private attached = false;
+  private progressActive = false;
+  private resumeSuspended: (() => void) | undefined;
   private lastInterrupt = 0;
   private lastEscape = 0;
   private pasting = false;
   private turn: Promise<void> | null = null;
+  private readonly extensionWork = new Set<Promise<void>>();
   readonly app: App;
   /** Read once: a git spawn on every keystroke would stall the live region. */
-  private readonly branch: string | null;
+  private branch: string | null;
 
   constructor(app: App, term?: Terminal) {
     this.app = app;
     this.historyDir = app.logDir;
     this.noticeDir = app.logDir;
-    this.screen = createInteractiveTui(term);
+    this.screen = createInteractiveTui(term, app.ui?.settings.showHardwareCursor ?? true, { ...app.ui?.settings, copySelection: async text => this.clipboardWriter(text) });
     this.term = this.screen.terminal;
     this.editor = new Editor({ tui: this.screen });
     this.editor.bindings = editorBindings((app.ui?.keymap ?? defaultKeymap()).byAction);
-    this.editor.setAutocompleteProvider(interactiveAutocomplete(app, async (refresh) => (await fileIndexFor(app, refresh)).paths));
     this.editor.onInput = (data) => { this.inputs.push(data); this.wake?.(); };
     this.chat = new Container();
     this.live = new Container();
     this.editorBox = new Container();
     this.footerBox = new Container();
-    this.screen.addChild(this.transcript);
-    this.screen.addChild(this.chat);
-    this.transcriptItems = projectTranscript(app.session.state.events);
-    this.screen.addChild(this.live);
-    this.screen.addChild(this.editorBox);
-    this.screen.addChild(this.footerBox);
+    this.extensionUi = new ExtensionUiController({
+      screen: () => this.screen, editor: this.editor, theme: () => this.app.ui?.theme ?? builtinTheme("dark"), colored: () => this.style !== IDENTITY,
+      bindings: () => this.editor.bindings!, branch: () => this.branch,
+      redraw: () => this.paint(), refreshTranscript: () => this.configureTranscript(), input: data => this.editor.onInput?.(data),
+      notify: (text, type) => this.app.io.say(type === "error" ? this.app.io.palette.red(text) : text),
+      setTheme: theme => this.setTheme(theme), expanded: () => this.toolsExpanded, expand: value => { this.toolsExpanded = value; },
+      cwd: () => this.app.workspace, showImages: () => this.app.ui?.settings.terminal?.showImages !== false, outputPad: () => this.app.ui?.settings.outputPad ?? 1,
+      saveTheme: name => {
+        if (this.app.ui) this.app.ui.settings = { ...this.app.ui.settings, theme: name };
+        this.runExtensionAction(() => writeUserSettings({ theme: name }));
+      },
+    });
+    this.extensionUi.setCompletion(interactiveAutocomplete(app, async refresh => (await fileIndexFor(app, refresh)).paths));
+    this.document = new PaddedDocument();
+    this.document.addChild(this.extensionUi.header);
+    this.document.addChild(this.transcript);
+    this.document.addChild(this.chat);
+    this.transcriptItems = projectTranscript(app.session.state.events, new Set(app.extensions?.entryRenderers.keys()));
+    this.document.addChild(this.live);
+    this.viewport = createChatViewport({ document: this.document, pendingMessages: new Container(), status: new Container(), editor: this.editorBox, footer: this.footerBox,
+      widgetsAbove: this.extensionUi.above, widgetsBelow: this.extensionUi.below,
+      scrollbarTrackStyle: text => this.style.token?.("muted", text) ?? text, scrollbarThumbStyle: text => this.style.token?.("text", text) ?? text });
+    this.mountScreen();
+    this.applyConfiguration();
     this.sessionName = app.args.sessionName || null;
     // Before attach: a hung git must not freeze an already-captured tty.
     this.branch = currentBranch(app.workspace);
+    void warmSyntaxLanguages().then(() => { this.configureTranscript(); this.liveMarkdown?.invalidate(); this.paint(); });
+  }
+
+  private mountScreen(): void {
+    this.screen.addChild(this.document);
+    this.screen.addChild(this.extensionUi.above);
+    this.screen.addChild(this.editorBox);
+    this.screen.addChild(this.extensionUi.below);
+    this.screen.addChild(this.footerBox);
+    if (this.screen.mode === "fullscreen") this.screen.setLayoutRoot(this.viewport.root);
+  }
+
+  applyConfiguration(): void {
+    const settings = this.app.ui?.settings ?? {};
+    // Preserve xeno's collapsed default; explicit settings and Ctrl+T share one source of truth.
+    this.thinkingExpanded = settings.hideThinkingBlock === false;
+    const mode = settings.tuiMode ?? "regular";
+    if (this.screen.mode !== mode) {
+      if (this.attached) this.screen.stop({ preserveScreen: true });
+      this.screen = replaceInteractiveTui(this.screen, { ...settings, copySelection: async text => this.clipboardWriter(text) });
+      this.editor.rebind(this.screen);
+      this.mountScreen();
+      this.extensionUi.rebind();
+      if (this.attached) { this.screen.start(); this.screen.requestRender(true); this.followTheme(); }
+    }
+    this.screen.setShowHardwareCursor(settings.showHardwareCursor ?? true);
+    this.screen.setClearOnShrink(settings.terminal?.clearOnShrink ?? false);
+    if (this.screen.mode === "fullscreen") {
+      this.screen.setCopyOnSelect(settings.fullscreenCopyOnSelect ?? true);
+      this.screen.setWheelScrollLines(settings.fullscreenWheelScrollLines ?? "auto");
+    }
+    this.viewport.transcript.setScrollbar(settings.fullscreenScrollbar ?? "auto");
+    this.editor.configure(settings.editorPaddingX ?? 0, settings.autocompleteMaxVisible ?? 5);
+    this.transcript.setPadding(0);
+    this.document.padding = settings.outputPad ?? 1;
+    this.editor.bindings = installBindings((this.app.ui?.keymap ?? defaultKeymap()).byAction);
+    this.app.session.config.imageOptions = settings.images ?? {};
+    this.configureTranscript();
+  }
+
+  async refreshResources(): Promise<void> {
+    await bindExtensions(this.app, this);
+    this.historyLength = -1;
+    this.applyConfiguration(); this.followTheme();
+    fileIndexes.delete(this.app.workspace); indexNotes.delete(this.app.workspace);
+    this.extensionUi.setCompletion(interactiveAutocomplete(this.app, async refresh => (await fileIndexFor(this.app, refresh)).paths));
+    this.branch = currentBranch(this.app.workspace);
+    this.extensionUi.branchChanged();
+    await this.syncTranscript(); this.paint();
+  }
+
+  private configureTranscript(): void {
+    const settings = this.app.ui?.settings;
+    this.transcript.configure(this.markdownFeatures, this.displayImages, settings?.terminal?.showImages ?? true, settings?.terminal?.imageWidthCells ?? 60);
+    this.transcript.setExtensions({
+      message: (type, text, data, expanded, fallback, metadata) => this.extensionUi.renderMessage(type, text, data, expanded, fallback, metadata),
+      tool: (name, input, result, expanded, call, output, id) => this.extensionUi.renderTool(name, input, result, expanded, call, output, id),
+      hiddenThinkingLabel: this.extensionUi.hiddenThinkingLabel,
+    });
+  }
+
+  private setTheme(theme: Theme): void {
+    if (!this.app.ui) return;
+    this.app.ui.theme = theme;
+    this.app.ui.style = colorEnabled() ? createStyle(theme.colors) : IDENTITY;
+    this.extensionUi.rebind(false); this.configureTranscript();
+    this.paint();
+  }
+
+  followTheme(): void {
+    this.stopThemeWatch?.(); this.stopColorWatch?.();
+    const generation = ++this.themeGeneration;
+    const name = this.app.ui?.settings.theme ?? "dark";
+    const spec = this.app.resources ? selectedThemePath(this.app.resources, name, this.app.args.noThemes) : name;
+    this.stopThemeWatch = watchTheme(spec, theme => this.setTheme(theme), message => this.writeLine(message));
+    const automatic = spec === "system" || spec === "auto";
+    this.screen.setTerminalColorSchemeNotifications(automatic);
+    const update = async (appearance?: "dark" | "light") => {
+      const apply = (colors: Awaited<ReturnType<InteractiveScreen["queryTerminalColors"]>>) => {
+        if (generation !== this.themeGeneration || this.previewTheme) return;
+        const generated = generateSystemThemeColors({ ...colors, ...(appearance ? { appearanceHint: appearance } : {}) });
+        if (spec === "auto") { this.setTheme(builtinTheme(generated.appearance ?? "dark")); return; }
+        const mapped = Object.fromEntries(THEME_TOKENS.map(token => [token, generated.colors[token === "status" ? "dim" : token === "prompt" ? "text" : token]]));
+        this.setTheme(parseTheme({ name: "system", colors: mapped }).theme);
+      };
+      apply(await this.screen.queryTerminalColors({ timeoutMs: 150, onLateReply: apply }));
+    };
+    if (automatic && this.attached) {
+      this.stopColorWatch = this.screen.onTerminalColorSchemeChange(scheme => { void update(scheme); });
+      void update();
+    }
   }
 
   get style(): Style {
@@ -1765,17 +2120,43 @@ export class Tui {
   }
 
   private clearStream(): void {
+    this.extensionUi.clearPartials();
     this.streamThinking = "";
     this.streamText = "";
     this.flushed = 0;
+    this.bashOutput = null;
+    this.toolArguments.clear();
+    this.toolOutput = "";
+    this.stopRetryTimer();
   }
 
   pushDelta(kind: "text" | "thinking", text: string): void {
+    this.stopRetryTimer();
     if (kind === "thinking") this.streamThinking += text;
     else this.streamText += text;
     this.paintStream();
   }
 
+  pushProgress(progress: NonNullable<LoopEvent["progress"]>): void {
+    if (progress.kind === "retry") {
+      this.stopRetryTimer();
+      this.retryUntil = Date.now() + progress.delayMs;
+      this.retryAttempt = progress.attempt;
+      this.retryTimer = setInterval(() => this.paint(), 200);
+    } else {
+      this.stopRetryTimer();
+      if (progress.kind === "tool") this.toolArguments.set(progress.id, { name: progress.name, arguments: progress.arguments });
+      else this.toolOutput = `${this.toolOutput}${progress.text}`.slice(-64 * 1024);
+    }
+    this.paint();
+  }
+
+  private stopRetryTimer(): void {
+    clearInterval(this.retryTimer);
+    this.retryTimer = undefined;
+    this.retryUntil = 0;
+  }
+
   discardStream(): void {
     this.clearStream();
     this.dropLive();
@@ -1790,6 +2171,7 @@ export class Tui {
   }
 
   async syncTranscript(): Promise<void> {
+    if (this.attached && this.app.extensions && !initializedExtensions.has(this.app.extensions)) await bindExtensions(this.app, this);
     const session = this.app.session;
     const dir = this.app.logDir;
     const node = session.state.node;
@@ -1803,11 +2185,17 @@ export class Tui {
       }
       if (this.app.session !== session || this.app.logDir !== dir) return;
       if (this.historyDir !== dir) {
+        this.applyConfiguration();
+        this.followTheme();
         if (this.noticeDir !== dir) this.chat.clear();
         this.noticeDir = dir;
         this.queue = [];
+        this.pendingImages = [];
+        this.displayImages.clear(); this.unavailableImages.clear();
         this.clearStream();
         this.editor.applyExternal("");
+        this.editor.setAutocompleteProvider(interactiveAutocomplete(this.app, async (refresh) => (await fileIndexFor(this.app, refresh)).paths));
+        this.branch = currentBranch(this.app.workspace);
         this.sessionName = (await readCursor(dir))?.name ?? null;
       }
       this.ancestors = history.nodes.filter((entry) => entry.node !== node).flatMap((entry) => entry.events);
@@ -1815,9 +2203,19 @@ export class Tui {
       this.historyNode = node;
       this.historyLength = -1;
     }
-    if (this.historyLength !== session.state.events.length) {
-      this.transcriptItems = projectTranscript([...this.ancestors, ...session.state.events]);
-      this.historyLength = session.state.events.length;
+    const physical = await readNode(dir, node);
+    if (this.app.session !== session || session.state.node !== node) return;
+    if (physical.corrupt.length > 0) throw new Error("Cannot render corrupt session history");
+    if (this.historyLength !== physical.events.length) {
+      this.transcriptItems = projectTranscript([...this.ancestors, ...physical.events], new Set(this.app.extensions?.entryRenderers.keys()));
+      this.historyLength = physical.events.length;
+      const images = this.transcriptItems.flatMap(item => item.kind === "user" ? item.images ?? [] : item.kind === "tool" ? item.result?.images ?? [] : []);
+      for (const image of images) {
+        if (this.displayImages.has(image.sha256) || this.unavailableImages.has(image.sha256)) continue;
+        try { this.displayImages.set(image.sha256, await loadDisplayImage(image, this.app.blobDir)); }
+        catch { this.unavailableImages.add(image.sha256); }
+      }
+      this.configureTranscript();
     }
     this.paint();
   }
@@ -1837,6 +2235,11 @@ export class Tui {
   }
 
   private renderScreen(): void {
+    const progress = this.inflight && this.app.ui?.settings.terminal?.showTerminalProgress !== false;
+    if (this.attached && this.progressActive !== progress) {
+      this.screen.terminal.setProgress(progress);
+      this.progressActive = progress;
+    }
     this.transcript.update(this.transcriptItems, this.markdownStyle(), this.toolsExpanded, this.thinkingExpanded);
     if (this.attached) this.screen.requestRender();
     else this.screen.renderNow();
@@ -1845,17 +2248,22 @@ export class Tui {
   private rebuildLive(): void {
     this.live.clear();
     const style = this.markdownStyle();
+    if (this.bashOutput !== null) this.live.addChild(new PiText(this.bashOutput, 0, 0));
+    for (const tool of this.toolArguments.values()) this.live.addChild(new PiText(`Preparing ${tool.name}\n${tool.arguments}`, 0, 0));
+    if (this.extensionUi.partials.children.length) this.live.addChild(this.extensionUi.partials);
+    else if (this.toolOutput) this.live.addChild(new PiText(this.toolOutput, 0, 0));
+    if (this.retryUntil) this.live.addChild(new PiText(`Retry ${this.retryAttempt} in ${Math.max(0, (this.retryUntil - Date.now()) / 1000).toFixed(1)}s · Esc to cancel`, 0, 0));
     if (this.streamThinking.length > 0) {
       this.live.addChild(
-        new Lines((width) =>
-          renderToolView({ kind: "thinking", text: this.streamThinking }, this.thinkingExpanded, width, style),
+        !this.thinkingExpanded && this.extensionUi.hiddenThinkingLabel !== undefined ? new PiText(this.extensionUi.hiddenThinkingLabel, 0, 0) : new Lines((width) =>
+          renderToolView({ kind: "thinking", text: this.extensionUi.transformMarkdown(this.streamThinking, width, true, "assistant-thinking") }, this.thinkingExpanded, width, style),
         ),
       );
     }
     if (this.streamText.length > 0) {
       if (this.liveStyle !== style || this.liveMarkdown === null) {
         this.liveStyle = style;
-        this.liveMarkdown = new MarkdownBlock(this.streamText, style);
+        this.liveMarkdown = new MarkdownBlock(this.streamText, style, this.markdownFeatures, true);
       }
       this.liveMarkdown.setText(this.streamText);
       this.live.addChild(this.liveMarkdown);
@@ -1867,10 +2275,18 @@ export class Tui {
     inner.setStyle(this.style);
     inner.onInput = this.editor.onInput;
     this.editorBox.clear();
-    this.editorBox.addChild(inner);
-    this.screen.setFocus(inner);
+    this.editorBox.addChild(this.extensionUi.modal ?? inner);
+    if (!this.extensionUi.overlayFocused) this.screen.setFocus(this.extensionUi.modal ?? inner);
     this.footerBox.clear();
-    this.footerBox.addChild(new Lines((width) => this.statusLines(width)));
+    for (const item of this.queue) this.footerBox.addChild(new PiText(`${item.kind === "steering" ? "Steering" : "Follow-up"}: ${firstLine(item.text, 160)}${item.images?.length ? ` · ${item.images.length} image(s)` : ""}`, 0, 0));
+    if (this.pendingImages.length) this.footerBox.addChild(new PiText(`Images: ${this.pendingImages.map(i => i.name).join(", ")} · /attachments to remove`, 0, 0));
+    const working = this.extensionUi.working(this.inflight, this.executionKind === "bash" ? "Running command" : "Working");
+    if (working) this.footerBox.addChild(new PiText(working, 0, 0));
+    if (this.extensionUi.customFooter) this.footerBox.addChild(this.extensionUi.customFooter);
+    else {
+      this.footerBox.addChild(new Lines((width) => this.statusLines(width)));
+      if (this.extensionUi.status) this.footerBox.addChild(new PiText(this.extensionUi.status, 0, 0));
+    }
   }
 
   private statusLines(width: number): string[] {
@@ -1920,43 +2336,168 @@ export class Tui {
       { id: "theme", label: "Theme", currentValue: settings?.theme ?? "dark", values: ["dark", "light"], description: "Apply the palette to the editor, menus and complete history." },
       { id: "thinking", label: "Thinking", currentValue: this.app.providerConfig.effort, values: EFFORTS.filter((effort) => effortSupported(this.app.providerConfig.spec, effort)), description: "Reasoning effort for the next turn." },
       { id: "statusBar", label: "Status bar", currentValue: settings?.statusBar === false ? "off" : "on", values: ["on", "off"], description: "Workspace, usage and distance to the next context boundary." },
+      { id: "steeringMode", label: "Steering mode", currentValue: settings?.steeringMode ?? "one-at-a-time", values: ["one-at-a-time", "all"], description: "Deliver queued messages after tool results." },
+      { id: "followUpMode", label: "Follow-up mode", currentValue: settings?.followUpMode ?? "one-at-a-time", values: ["one-at-a-time", "all"], description: "Deliver queued messages after the current turn." },
+      { id: "defaultModel", label: "Default model", currentValue: settings?.defaultModel ?? "automatic", values: ["configure"], description: "Choose the provider and model for new sessions." },
+      { id: "modelThinkingLevels", label: "Model thinking defaults", currentValue: `${Object.keys(settings?.modelThinkingLevels ?? {}).length} configured`, values: ["configure"], description: "Set or clear a thinking default by provider/model." },
+      ...DISPLAY_SETTINGS.map(item => ({ ...item, currentValue: settingValue(settings ?? {}, item.id, item.fallback), values: settingValues(item.id) })),
     ], this.style);
+    const menu = this.settings;
+    void discoverThemes(this.app.resources).then(names => { if (this.settings === menu) { menu.updateValues("theme", names); this.paint(); } }).catch(error => this.writeLine(String(error)));
     this.paint();
   }
 
-  openLoginSelect(): void {
+  openLoginSelect(method?: "oauth" | "api_key"): void {
     const providers = [...new Set(this.app.catalog.map((model) => model.provider))];
+    const status = (provider: string): string => {
+      const spec = this.app.catalog.find(model => model.provider === provider);
+      const resolved = spec ? this.app.credentialOf(spec) : undefined;
+      const stored = this.app.auth[provider];
+      return resolved?.ok ? `${stored?.type === "oauth" && resolved.source === "auth.json" ? "account" : "API key"} · ${resolved.source}` : stored ? "stored credential unavailable" : "login required";
+    };
     this.select = new SelectList([
-      ...SUBSCRIPTION_OPTIONS.map((option) => ({ value: option.id, label: option.id, description: option.label })),
-      ...providers.map((provider) => ({ value: provider, label: provider, description: "API key" })),
+      ...(method ? [] : [
+        { value: "auth:oauth", label: "Sign in with an account", description: "Choose a subscription provider" },
+        { value: "auth:api_key", label: "Sign in with an API key", description: "Choose a key provider" },
+      ]),
+      ...(method === "api_key" ? [] : SUBSCRIPTION_OPTIONS.map(option => ({ value: option.id, label: option.id, description: `${option.label} · ${status(option.provider)}` }))),
+      ...(method === "oauth" ? [] : providers.map(provider => ({ value: provider, label: provider, description: `API key · ${status(provider)}` }))),
     ], { style: this.style, title: "Login · choose a provider" });
-    this.onPick = async (item) => { await handleLine(this.app, "/login " + item.value, this); };
+    this.selectKind = "other";
+    this.onSelectCancel = method ? () => this.openLoginSelect() : undefined;
+    this.onPick = async item => {
+      if (item.value === "auth:oauth" || item.value === "auth:api_key") { this.openLoginSelect(item.value === "auth:oauth" ? "oauth" : "api_key"); return; }
+      const provider = subscriptionById(item.value)?.provider ?? item.value;
+      const spec = this.app.catalog.find(model => model.provider === provider);
+      const resolved = spec ? this.app.credentialOf(spec) : undefined;
+      if (resolved?.ok && resolved.source !== "auth.json") this.app.io.say(`  Current credential source: ${resolved.source}. /logout only removes stored credentials. Environment: ${envLabel(provider)}.`);
+      await handleLine(this.app, "/login " + item.value, this);
+    };
+    this.paint();
+  }
+
+  beginCredentialInput(provider: string): void {
+    this.credentialDraft ??= this.editor.state.text;
+    this.awaitingKeyFor = provider;
+    this.editor.setSecret(true);
+    this.editor.applyExternal("");
+    this.paint();
+  }
+
+  endCredentialInput(): void {
+    if (this.credentialDraft === undefined && this.awaitingKeyFor === null) return;
+    const draft = this.credentialDraft ?? "";
+    this.credentialDraft = undefined;
+    this.awaitingKeyFor = null;
+    this.editor.setSecret(false);
+    this.editor.applyExternal(draft);
+    this.paint();
+  }
+
+  openLogoutSelect(): void {
+    this.selectKind = "other";
+    this.select = new SelectList(Object.keys(this.app.auth).filter(provider => this.app.auth[provider] !== undefined)
+      .map(provider => ({ value: provider, label: provider, description: "Remove stored credential" })),
+    { style: this.style, title: "Logout · choose a provider", emptyMessage: "No stored credentials" });
+    this.onPick = async item => { await logout(this.app, item.value); };
     this.paint();
   }
 
+  private scopeModels(): ModelSpec[] {
+    return this.app.catalog.filter(spec => this.app.credentialOf(spec).ok);
+  }
+
+  private activeScope(): string[] {
+    return this.scopeEntries().map(entry => modelKey(entry.model));
+  }
+
+  private scopeEntries() {
+    const fromFlag = splitModelPatterns(this.app.args.models);
+    const configured = this.app.args.modelsExplicit || fromFlag.length ? fromFlag : this.app.ui?.settings.scopedModels;
+    return scopedModels(configured ?? this.scopeModels().map(modelKey), this.scopeModels()).entries;
+  }
+
+  private scopedItems(): SelectItem[] {
+    const enabled = this.activeScope();
+    return this.scopeModels().sort((a, b) => {
+      const ai = enabled.indexOf(modelKey(a)), bi = enabled.indexOf(modelKey(b));
+      return (ai < 0 ? Infinity : ai) - (bi < 0 ? Infinity : bi);
+    }).map(spec => ({ value: modelKey(spec), label: `${enabled.includes(modelKey(spec)) ? "[x]" : "[ ]"} ${spec.id}`,
+      description: `${spec.provider} · ${spec.name}` }));
+  }
+
+  openScopedModels(): void {
+    this.selectKind = "scoped-models";
+    this.select = new SelectList(this.scopedItems(), { style: this.style, title: "Scoped models · session changes",
+      hint: "Enter toggle · Ctrl+A enable · Ctrl+X clear · Ctrl+P provider · Alt+↑↓ order · Ctrl+S save · Esc close",
+      emptyMessage: "No available models. Use /login to add a credential." });
+    this.onPick = null;
+    this.paint();
+  }
+
+  private matchesAction(data: string, action: string): boolean {
+    return (this.app.ui?.keymap ?? defaultKeymap()).byAction[action]?.some(chord => keyMatches(data, chord)) ?? false;
+  }
+
+  private async scopedInput(data: string): Promise<boolean> {
+    if (!this.select || this.selectKind !== "scoped-models") return false;
+    const state = this.select.state, selected = state.items[state.selected]?.value;
+    const ids = state.items.map(item => item.value);
+    if (this.matchesAction(data, "app.models.save")) {
+      const scopedModels = this.scopeEntries().map(scopeReference);
+      await writeUserSettings({ scopedModels });
+      if (this.app.ui) this.app.ui.userOverrides = { ...this.app.ui.userOverrides, scopedModels };
+      this.app.io.say(this.app.io.palette.green(`  saved ${scopedModels.length} scoped models`));
+      return true;
+    }
+    let change: ScopeChange | undefined;
+    if (this.matchesAction(data, "app.models.enableAll")) change = { kind: "enable", ids };
+    else if (this.matchesAction(data, "app.models.clearAll")) change = { kind: "disable", ids };
+    else if (selected && this.matchesAction(data, "tui.select.confirm")) change = { kind: "toggle", ids: [selected] };
+    else if (selected && this.matchesAction(data, "app.models.toggleProvider")) {
+      const provider = this.app.catalog.find(spec => modelKey(spec) === selected)?.provider;
+      change = { kind: "toggle", ids: this.scopeModels().filter(spec => spec.provider === provider).map(modelKey) };
+    } else if (selected && this.matchesAction(data, "app.models.reorderUp")) change = { kind: "move", id: selected, delta: -1 };
+    else if (selected && this.matchesAction(data, "app.models.reorderDown")) change = { kind: "move", id: selected, delta: 1 };
+    if (!change) return false;
+    const before = new Map(this.scopeEntries().map(entry => [modelKey(entry.model), scopeReference(entry)]));
+    const scopedModels = changeModelScope(this.activeScope(), change).map(id => before.get(id) ?? id);
+    this.app.args.models = "";
+    this.app.args.modelsExplicit = false;
+    if (this.app.ui) this.app.ui.settings = { ...this.app.ui.settings, scopedModels };
+    this.select.setItems(this.scopedItems());
+    return true;
+  }
+
   async openForkSelect(): Promise<void> {
-    const points = await this.app.session.restorePoints();
-    this.select = new SelectList(points.flatMap((point, i) => point.onPath ? [{ value: String(i + 1), label: firstLine(point.prompt, 120), description: "node " + point.node }] : []),
-      { style: this.style, title: "Fork · choose a completed exchange", emptyMessage: "No exchanges on this branch yet" });
-    this.onPick = async (item) => { await forkSession(this.app, item.value); await this.syncTranscript(); };
+    const points = await this.app.session.userMessages();
+    this.select = new SelectList(points.map((point, i) => ({ value: String(i + 1), label: firstLine(point.text, 120), description: "node " + point.node })),
+      { style: this.style, title: "Fork · edit a previous user message", emptyMessage: "No user messages yet" });
+    this.onPick = async (item) => { await forkSession(this.app, item.value, this); };
     this.paint();
   }
 
   private openSettingValues(field: string): void {
     const key = field.toLowerCase();
+    if (key === "defaultmodel") { this.openDefaultModelSelect(); return; }
+    if (key === "modelthinkinglevels") { this.openModelThinkingDefaults(); return; }
     let items: SelectItem[] = [];
     if (key === "theme") {
       items = [
         { value: "dark", label: "dark" },
         { value: "light", label: "light" },
+        { value: "system", label: "system" },
+        { value: "auto", label: "auto" },
       ];
     } else if (key === "thinking") {
-      items = ["low", "medium", "high", "xhigh", "max"].map((v) => ({ value: v, label: v }));
+      items = supportedThinkingLevels(this.app.providerConfig.spec).map((v) => ({ value: v, label: v }));
     } else if (key === "statusbar" || key === "status") {
       items = [
         { value: "on", label: "on" },
         { value: "off", label: "off" },
       ];
+    } else if (settingValues(field).length) {
+      items = settingValues(field).map(value => ({ value, label: value }));
     } else {
       this.app.io.say(this.app.io.palette.yellow(`  unknown setting: ${field}`));
       this.paint();
@@ -1964,27 +2505,85 @@ export class Tui {
     }
     this.select = new SelectList(items, { style: this.style, title: "Setting · " + field });
     this.selectKind = "other";
+    if (key === "theme") {
+      this.previewTheme = this.app.ui?.theme;
+      const selector = this.select;
+      void discoverThemes(this.app.resources).then(names => { if (this.select === selector) { selector.setItems(names.map(name => ({ value: name, label: name }))); this.paint(); } }).catch(error => this.writeLine(String(error)));
+    }
     this.onPick = async (item) => {
+      this.previewTheme = undefined;
       await commitSetting(this.app, key === "status" ? "statusBar" : field, item.value, this);
     };
     this.paint();
   }
 
+  private openDefaultModelSelect(): void {
+    this.selectKind = "other";
+    const current = this.app.ui?.settings;
+    this.select = new SelectList(this.app.catalog.map(spec => ({ value: modelKey(spec), label: spec.id, description: spec.provider })),
+      { style: this.style, title: "Default model · new sessions", selectedValue: `${current?.defaultProvider}/${current?.defaultModel}` });
+    this.onPick = async item => {
+      const spec = this.app.catalog.find(model => modelKey(model) === item.value);
+      if (!spec || !this.app.ui) return;
+      const patch = { defaultProvider: spec.provider, defaultModel: spec.id };
+      await writeUserSettings(patch);
+      this.app.ui.settings = { ...this.app.ui.settings, ...patch };
+      this.app.ui.userOverrides = { ...this.app.ui.userOverrides, ...patch };
+      this.app.io.say(`  saved default model ${item.value}`);
+    };
+    this.paint();
+  }
+
+  private openModelThinkingDefaults(identity?: string): void {
+    const ui = this.app.ui;
+    if (!ui) return;
+    const models = new Map(this.app.catalog.map(spec => [modelKey(spec), spec]));
+    this.selectKind = "other";
+    if (!identity) {
+      const keys = [...new Set([...models.keys(), ...Object.keys(ui.settings.modelThinkingLevels ?? {})])];
+      this.select = new SelectList(keys.map(key => ({ value: key, label: key, description: ui.settings.modelThinkingLevels?.[key] ?? "inherited" })),
+        { style: this.style, title: "Model thinking defaults" });
+      this.onPick = async item => this.openModelThinkingDefaults(item.value);
+    } else {
+      const model = models.get(identity);
+      this.select = new SelectList([
+        { value: "clear", label: "Clear user override", description: "Use the project or global default" },
+        ...(model ? supportedThinkingLevels(model).map(level => ({ value: level, label: level })) : []),
+      ], { style: this.style, title: `Thinking default · ${identity}`, selectedValue: ui.settings.modelThinkingLevels?.[identity] ?? "clear" });
+      this.onPick = async item => {
+        const level = asEffort(item.value);
+        if (item.value === "clear") {
+          await removeModelThinkingOverride(identity);
+          const loaded = await loadUiResources({ ...this.app.args, workspace: this.app.workspace, trusted: this.app.projectTrusted ?? this.app.args.approve ?? false });
+          ui.settings = { ...ui.settings, modelThinkingLevels: loaded.settings.modelThinkingLevels ?? {} };
+          ui.userOverrides = { ...ui.userOverrides, modelThinkingLevels: loaded.userOverrides.modelThinkingLevels ?? {} };
+        } else if (level && model && effortSupported(model, level)) {
+          const patch = { modelThinkingLevels: { [identity]: level } };
+          await writeUserSettings(patch);
+          ui.settings = mergeSettings({ builtin: ui.settings, user: patch });
+          ui.userOverrides = mergeSettings({ builtin: ui.userOverrides, user: patch });
+        }
+        this.openModelThinkingDefaults();
+      };
+    }
+    this.paint();
+  }
+
   openModelSelect(): void {
     const items: SelectItem[] = [];
     for (const spec of this.app.catalog) {
       const got = this.app.credentialOf(spec);
-      const here = spec.id === this.app.providerConfig.spec.id;
+      const here = modelKey(spec) === modelKey(this.app.providerConfig.spec);
       items.push({
-        value: spec.id,
+        value: modelKey(spec),
         label: spec.id,
         description: `${spec.provider} · ${spec.name}${here ? "  ✓ current" : got.ok ? "  ready" : "  login required"}`,
       });
     }
-    this.select = new SelectList(items, { style: this.style, title: "Model", selectedValue: this.app.providerConfig.spec.id, hint: "↑↓ select · Enter apply · Ctrl+S save default · Esc cancel" });
+    this.select = new SelectList(items, { style: this.style, title: "Model", selectedValue: modelKey(this.app.providerConfig.spec), hint: "↑↓ select · Enter apply · Ctrl+S save default · Esc cancel" });
     this.selectKind = "model";
     this.onPick = async (item) => {
-      const spec = this.app.catalog.find((m) => m.id === item.value);
+      const spec = this.app.catalog.find((m) => modelKey(m) === item.value);
       if (spec !== undefined) await switchToModel(this.app, spec);
     };
     this.app.io.say(this.app.io.palette.dim("  switching cuts this node so the next model starts from a handoff"));
@@ -2008,7 +2607,7 @@ export class Tui {
     this.onPick = async (item) => {
       const effort = asEffort(item.value);
       if (effort === undefined) return;
-      applyThinking(this.app, effort, this);
+      await applyThinking(this.app, effort, this);
     };
     this.paint();
   }
@@ -2020,10 +2619,12 @@ export class Tui {
     const C = this.app.io.palette;
     if (this.selectKind === "model") {
       // Patch only this key: dumping merged settings would freeze today's defaults.
-      await writeUserSettings({ defaultModel: item.value });
+      const spec = this.app.catalog.find(model => modelKey(model) === item.value);
+      if (!spec) return;
+      await writeUserSettings({ defaultModel: spec.id, defaultProvider: spec.provider });
       if (this.app.ui !== undefined) {
-        this.app.ui.userOverrides = { ...this.app.ui.userOverrides, defaultModel: item.value };
-        this.app.ui.settings = { ...this.app.ui.settings, defaultModel: item.value };
+        this.app.ui.userOverrides = { ...this.app.ui.userOverrides, defaultModel: spec.id, defaultProvider: spec.provider };
+        this.app.ui.settings = { ...this.app.ui.settings, defaultModel: spec.id, defaultProvider: spec.provider };
       }
       this.app.io.say(C.green(`  saved default model ${item.value}`));
       return;
@@ -2034,66 +2635,69 @@ export class Tui {
         this.app.io.say(C.yellow("  Cannot save an unsupported thinking level."));
         return;
       }
-      await writeUserSettings({ defaultThinking: item.value });
+      const patch = { modelThinkingLevels: { [modelKey(this.app.providerConfig.spec)]: effort } };
+      await writeUserSettings(patch);
       if (this.app.ui !== undefined) {
-        this.app.ui.userOverrides = { ...this.app.ui.userOverrides, defaultThinking: item.value };
-        this.app.ui.settings = { ...this.app.ui.settings, defaultThinking: item.value };
+        this.app.ui.userOverrides = mergeSettings({ builtin: this.app.ui.userOverrides, user: patch });
+        this.app.ui.settings = mergeSettings({ builtin: this.app.ui.settings, user: patch });
       }
       this.app.io.say(C.green(`  saved default thinking ${item.value}`));
     }
   }
 
   async openResumeSelect(): Promise<void> {
-    const { sessions, truncated } = await listSessions(this.app.workspace, sessionDirOf(this.app));
-    const note = truncationNote(truncated);
-    if (note) this.app.io.say(this.app.io.palette.yellow(`  ${note}`));
-    const ok = sessions.filter((s): s is Extract<ListedSession, { ok: true }> => s.ok);
-    if (ok.length === 0) {
-      this.app.io.say(this.app.io.palette.dim("  no sessions yet"));
-      return;
-    }
-    this.select = new SelectList(
-      ok.map((s) => ({
-        value: s.path,
-        label: s.name ?? s.id,
-        description: [s.model ?? "", s.updated_at ?? "", `${s.events} events`].filter((x) => x.length > 0).join("  "),
-      })),
-      { style: this.style, title: "Resume session", selectedValue: this.app.logDir },
-    );
+    if (this.select instanceof SessionBrowser) this.select.dispose();
+    const browser = new SessionBrowser({ root: { path: dirname(this.app.logDir), workspace: this.app.workspace },
+      style: this.style, active: this.app.logDir, redraw: () => this.paint(), bindings: () => this.app.ui?.keymap ?? defaultKeymap(),
+      renamed: (path, name) => { if (path === this.app.logDir) this.sessionName = name || null; } });
+    this.select = browser;
     this.selectKind = "other";
     this.onPick = async (item) => {
       await resumeSession(this.app, item.value, this);
     };
     this.paint();
+    await browser.load();
+  }
+
+  async openResourceSelect(): Promise<void> {
+    const trusted = (await projectTrust(this.app.workspace, this.app.projectTrusted ?? this.app.args.approve)).trusted;
+    const resources = { ...this.app.args, workspace: this.app.workspace, trusted };
+    const index = await discoverResources(resources);
+    if (this.select instanceof SessionBrowser) this.select.dispose();
+    this.select = new ResourceBrowser({ resources, index, style: this.style, redraw: () => this.paint(), changed: async () => {
+      await reloadAppResources(this.app); await this.refreshResources();
+    } });
+    this.selectKind = "other"; this.onPick = null; this.paint();
+  }
+
+  async openTrustSelect(): Promise<void> {
+    const trust = await projectTrust(this.app.workspace, this.app.projectTrusted ?? this.app.args.approve);
+    if (this.select instanceof SessionBrowser) this.select.dispose();
+    this.select = new TrustSelector(this.app.workspace, trust, this.style);
+    this.selectKind = "other";
+    this.onPick = async item => { await trustProject(this.app, item.value as TrustChoice, this); };
+    this.paint();
   }
 
   /**
-   * Live-region tree. Selection is UI state; Enter calls Session.rewind
-   * rather than a second restore implementation. If a turn is in flight,
+   * Selection resolves an exact log position through Session.navigateTo.
+   * User messages become drafts; other messages remain included. If a turn is in flight,
    * the existing AbortSignal fires first — same path Escape already uses.
    */
   async openTreeSelect(): Promise<void> {
+    if (this.select instanceof SessionBrowser) this.select.dispose();
     this.select = null;
     this.onPick = null;
-    const points = await this.app.session.restorePoints();
     const nodes = await treeNodesFor(this.app);
-    this.tree = new TreeList(nodes, { style: this.style });
+    this.tree = new TreeList(nodes, { style: this.style, filter: this.app.ui?.settings.treeFilterMode ?? "default", bindings: (this.app.ui?.keymap ?? defaultKeymap()).byAction });
     this.onTreePick = async (node) => {
-      const point = points.find((p) => `${p.node}:${p.atEvent}` === (node.target ?? node.id));
-      if (point === undefined) return;
+      if (node.target === undefined) return;
       if (this.inflight) { await this.settle(); this.returnQueueToEditor(); }
-      const done = await this.app.session.rewind(point, "context");
+      const done = await this.app.session.navigateTo(node.target);
       await this.syncTranscript();
+      if (done.editorText !== undefined) this.restoreDraft(done.editorText, done.images ?? []);
       const C = this.app.io.palette;
-      if (!done.ok) {
-        this.app.io.say(C.red(`\n  could not go back: ${done.error}\n`));
-        return;
-      }
-      this.app.io.say(
-        C.green(`\n  back at node ${done.node}`) +
-          C.dim(`  ${done.restored.length} restored, ${done.removed.length} removed`),
-      );
-      if (done.note.length > 0) this.app.io.say(C.dim(`  ${done.note}`));
+      this.app.io.say(C.green(`\n  conversation at node ${this.app.session.state.node}`));
       this.app.io.say("");
     };
     this.paint();
@@ -2111,16 +2715,90 @@ export class Tui {
     this.attached = true;
     this.rebuildChrome();
     this.screen.start();
+    this.followTheme();
   }
 
   detach(): void {
+    void cancelPendingOAuth(this.app);
+    this.endCredentialInput();
+    this.extensionUi.dispose();
+    if (this.select instanceof SessionBrowser) this.select.dispose();
+    this.stopRetryTimer();
+    this.stopThemeWatch?.(); this.stopColorWatch?.(); this.themeGeneration++;
+    this.progressActive = false;
     this.attached = false;
-    this.screen.stop();
+    const hint = this.screen.mode === "fullscreen" && this.app.ui?.settings.fullscreenExitOutput === "resume-hint";
+    if (this.screen.mode === "fullscreen") this.screen.setLayoutRoot(this.document);
+    this.screen.stop({ preserveScreen: hint });
+    if (hint) this.screen.terminal.write("\r\nxeno --session " + JSON.stringify(this.app.logDir) + "\r\n");
   }
 
   async settle(): Promise<void> {
+    await cancelPendingOAuth(this.app);
     this.abort?.abort();
+    this.approvalResolve?.("deny");
     await this.turn;
+    await Promise.all([...this.extensionWork]);
+    await this.app.extensions?.settle();
+  }
+
+  showDocument(text: string): void {
+    this.chat.addChild(new MarkdownBlock(text, this.style, this.markdownFeatures)); this.paint();
+  }
+
+  runSessionTransition(action: () => Promise<void>): void {
+    if (this.sessionTransition) return;
+    this.sessionTransition = true;
+    this.runExtensionAction(async () => { try { await action(); } finally { this.sessionTransition = false; } });
+  }
+
+  runExtensionAction(action: () => void | Promise<void>): void {
+    const work = Promise.resolve().then(action).catch(error => this.app.io.say(this.app.io.palette.red(describeError(error))))
+      .finally(() => { this.extensionWork.delete(work); void this.syncTranscript().then(() => this.paint()); });
+    this.extensionWork.add(work);
+  }
+  runExtensionCommand(name: string, args: string): void {
+    this.runExtensionAction(async () => { await bindExtensions(this.app, this); await this.app.extensions?.command(name, args); });
+  }
+  deliverExtension(text: string, kind: QueueKind): void {
+    if (this.inflight) this.enqueue({ kind, text });
+    else this.turn = this.runPromptTurn(text).catch(error => this.app.io.say(describeError(error)));
+  }
+
+  requestShutdown(): void {
+    void cancelPendingOAuth(this.app);
+    this.extensionUi.cancelDialogs();
+    this.shutdownRequested = true;
+    this.resumeSuspended?.();
+    this.executionKind = "shutdown";
+    this.abort?.abort();
+    this.approvalResolve?.("deny");
+    this.inputs.push("");
+    this.wake?.();
+  }
+
+  async suspend(): Promise<void> {
+    if (process.platform === "win32" || !this.attached) return;
+    // Pi keeps a live handle while raw input is detached, otherwise fg can return to an exited process.
+    const keepAlive = setInterval(() => {}, 60_000);
+    const ignoreInterrupt = () => {};
+    process.on("SIGINT", ignoreInterrupt);
+    let resume!: () => void;
+    const continued = new Promise<void>(resolve => { resume = resolve; process.once("SIGCONT", resolve); });
+    this.resumeSuspended = resume;
+    try {
+      this.screen.stop({ preserveScreen: true });
+      process.kill(process.pid, "SIGTSTP");
+      await continued;
+    } finally {
+      clearInterval(keepAlive);
+      process.off("SIGINT", ignoreInterrupt);
+      process.off("SIGCONT", resume);
+      this.resumeSuspended = undefined;
+      this.screen.start();
+      this.screen.requestRender(true);
+      this.paint();
+    }
   }
 
   ask(request: PermissionRequest): Promise<ApprovalChoice> {
@@ -2142,14 +2820,14 @@ export class Tui {
 
   private async openExternalEditor(): Promise<void> {
     const attached = this.attached;
-    if (attached) this.screen.stop();
+    if (attached) this.screen.stop({ preserveScreen: true });
     if (attached && process.stdin.isTTY) process.stdin.setRawMode(false);
     try {
-      const result = await editInExternalEditor({ content: this.editor.state.text, command: resolveEditorCommand() });
+      const result = await editInExternalEditor({ content: this.editor.state.text, command: this.app.ui?.settings.externalEditor ?? resolveEditorCommand() });
       if (result.ok) this.editor.applyExternal(result.content);
       else this.app.io.say(result.message);
     } finally {
-      if (attached) this.screen.start();
+      if (attached) { this.screen.start(); this.screen.requestRender(true); }
       this.paint();
     }
   }
@@ -2157,17 +2835,71 @@ export class Tui {
   /** Programmatic compatibility; live stdin always enters as Pi raw input. */
   async applyKey(key: Key): Promise<"continue" | "quit"> { return this.applyInput(encodeKey(key)); }
 
-  async applyInput(data: string): Promise<"continue" | "quit"> {
+  restoreDraft(text: string, images: readonly ImageRef[] = []): void {
+    this.editor.applyExternal([text, this.editor.state.text].filter(Boolean).join("\n"));
+    this.pendingImages = [...images, ...this.pendingImages];
+    this.paint();
+  }
+
+  async pasteClipboard(content?: ClipboardContent): Promise<void> {
+    try {
+      const value = content === undefined ? await this.clipboardReader() : content;
+      if (!value) return;
+      if ("files" in value) {
+        const images: ImageRef[] = [], text: string[] = [];
+        for (const path of value.files) {
+          if (/[\x00-\x1f]/.test(path)) throw new Error("Clipboard file path contains control characters");
+          const absolute = path.startsWith("file://") ? fileURLToPath(path) : resolve(this.app.workspace, path);
+          const image = await attachImageFile(absolute, this.app.blobDir, this.app.ui?.settings.images?.autoResize ?? true);
+          if (image) images.push(image); else text.push("@" + JSON.stringify(path));
+        }
+        this.pendingImages.push(...images);
+        if (text.length) this.editor.acceptInput("\x1b[200~" + text.join(" ") + "\x1b[201~");
+      } else if ("image" in value) {
+        this.pendingImages.push(await attachImageBytes(value.image, "clipboard.png", this.app.blobDir, this.app.ui?.settings.images?.autoResize ?? true));
+      } else this.editor.acceptInput("\x1b[200~" + value.text + "\x1b[201~");
+    } catch (error) { this.app.io.say("  Paste failed: " + describeError(error)); }
+    this.paint();
+  }
+
+  openAttachments(): void {
+    this.select = new SelectList(this.pendingImages.map((image, i) => ({ value: String(i), label: image.name,
+      description: `${image.width}x${image.height} · Enter to remove` })), { title: "Draft images · remove one", style: this.style, emptyMessage: "No draft images" });
+    this.onPick = async item => { this.pendingImages.splice(Number(item.value), 1); };
+    this.paint();
+  }
+
+  async applyInput(data: string, fromTerminal = false): Promise<"continue" | "quit"> {
+    this.editor.bindings = installBindings((this.app.ui?.keymap ?? defaultKeymap()).byAction);
+    if (!fromTerminal) { const filtered = this.extensionUi.filterInput(data); if (filtered === undefined) return "continue"; data = filtered; }
     const action = this.boundAction(data);
+    if (action === "app.suspend") { await this.suspend(); return "continue"; }
+    if (this.extensionUi.acceptInput(data)) return "continue";
     // Modal ownership precedes application shortcuts, including during a turn.
     if (this.settings) {
-      for (const change of this.settings.acceptInput(data)) await commitSetting(this.app, change.id, change.value, this);
-      if (this.settings.cancelled) this.settings = null;
+      const menu = this.settings;
+      for (const change of menu.acceptInput(data)) {
+        if (change.id === "defaultModel" || change.id === "modelThinkingLevels") { this.settings = null; this.openSettings(change.id); }
+        else await commitSetting(this.app, change.id, change.value, this);
+      }
+      if (menu.cancelled && this.settings === menu) this.settings = null;
       this.paint();
       return "continue";
     }
     if (this.tree) {
-      const state = this.tree.acceptInput(data);
+      const bindings = (this.app.ui?.keymap ?? defaultKeymap()).byAction;
+      const ownerAction = Object.entries(bindings).find(([id, chords]) =>
+        (id.startsWith("app.tree.") || id === "app.message.copy") && chords.some(chord => keyMatches(data, chord)))?.[0];
+      const state = this.tree.acceptInput(data, ownerAction);
+      if (this.tree.labelChange) {
+        const change = this.tree.labelChange;
+        await setSessionLabel(this.app.logDir, change.target, change.text, this.app.session.clock.now());
+        this.tree.setNodes(await treeNodesFor(this.app));
+      }
+      if (this.tree.copyText !== undefined) {
+        const copied = await this.clipboardWriter(this.tree.copyText);
+        this.app.io.say(copied ? "  Copied selected message" : "  Clipboard unavailable");
+      }
       if (state.cancelled || state.confirmed) {
         const pick = this.onTreePick;
         this.tree = null;
@@ -2178,26 +2910,60 @@ export class Tui {
       return "continue";
     }
     if (this.select) {
+      if (this.select instanceof ResourceBrowser && await this.select.handleAction(data)) { this.paint(); return "continue"; }
+      if (this.select instanceof SessionBrowser && await this.select.handleAction(data)) { this.paint(); return "continue"; }
+      if (await this.scopedInput(data)) { this.paint(); return "continue"; }
       if (action === "app.saveDefault" && !this.approvalResolve) await this.saveSelectDefault();
       else {
         const state = this.select.acceptInput(data);
+        if (this.previewTheme && !state.confirmed && !state.cancelled) {
+          const item = state.items[state.selected];
+          if (item) { const diagnostics: string[] = []; const theme = await resolveTheme(this.app.resources ? themeResourcePath(this.app.resources, item.value) ?? item.value : item.value, diagnostics); if (!diagnostics.length) this.setTheme(theme); }
+        }
         if (state.cancelled || state.confirmed) {
-          const pick = this.onPick, approval = this.approvalResolve;
+          const pick = this.onPick, approval = this.approvalResolve, cancel = this.onSelectCancel;
+          if (this.select instanceof SessionBrowser) this.select.dispose();
           this.select = null;
           this.onPick = null;
+          this.onSelectCancel = undefined;
           this.approvalResolve = null;
           this.selectKind = "other";
           if (state.confirmed && pick) { await pick(state.confirmed); await this.syncTranscript(); }
-          else approval?.("deny");
+          else { approval?.("deny"); cancel?.(); if (this.previewTheme) { this.setTheme(this.previewTheme); this.previewTheme = undefined; } }
         }
       }
       this.paint();
       return "continue";
     }
+    // A secret editor owns every key; model, file and extension actions cannot consume its input.
+    if (this.awaitingKeyFor !== null) {
+      if (action === "app.interrupt" || action === "app.clear") {
+        await cancelPendingOAuth(this.app);
+        this.endCredentialInput();
+        return "continue";
+      }
+      if (action === "app.exit" && this.editor.state.text.length === 0) { await cancelPendingOAuth(this.app); return "quit"; }
+      const state = this.editor.acceptInput(data);
+      if (state.submitted !== null) return this.submitLine(state.submitted, "steering");
+      this.paint(); return "continue";
+    }
+    for (const [key, shortcut] of this.app.extensions?.shortcuts ?? []) if (keyMatches(data, key)) {
+      this.runExtensionAction(() => shortcut.handler(extensionContext(this.app, this))); return "continue";
+    }
     if (data.includes("\x1b[200~")) this.pasting = true;
     if (this.pasting) {
-      this.editor.acceptInput(data);
-      if (data.includes("\x1b[201~")) this.pasting = false;
+      this.pasteBuffer += data;
+      if (data.includes("\x1b[201~")) {
+        this.pasting = false;
+        const payload = this.pasteBuffer.replace(/^\x1b\[200~/, "").replace(/\x1b\[201~$/, "");
+        const paths = droppedImagePaths(payload);
+        if (paths) {
+          const before = this.pendingImages.length;
+          await this.pasteClipboard({ files: paths });
+          if (this.pendingImages.length === before) this.editor.acceptInput(this.pasteBuffer);
+        } else this.editor.acceptInput(this.pasteBuffer);
+        this.pasteBuffer = "";
+      }
       this.paint();
       return "continue";
     }
@@ -2206,43 +2972,52 @@ export class Tui {
       this.paint();
       return "continue";
     }
-    if (action === "app.exit" || keyMatches(data, "ctrl+c")) {
+    if (action === "app.clear") {
       if (this.inflight) { this.abort?.abort(); this.returnQueueToEditor(); }
-      else if (this.editor.state.text.length > 0) this.editor.applyExternal("");
+      else if (this.editor.state.text.length > 0 || this.pendingImages.length) { this.editor.applyExternal(""); this.pendingImages = []; }
       else if (Date.now() - this.lastInterrupt < 1000) return "quit";
       else this.app.io.say("  Press Ctrl+C again to exit, or Ctrl+D on an empty prompt.");
       this.lastInterrupt = Date.now();
       this.paint();
       return "continue";
     }
-    if (keyMatches(data, "ctrl+d") && this.editor.state.text.length === 0) return "quit";
+    if (action === "app.exit" && this.editor.state.text.length === 0 && this.pendingImages.length === 0) return "quit";
     if (action === "app.interrupt") {
-      if (this.awaitingKeyFor !== null) {
-        if (this.awaitingKeyFor === OAUTH_PASTE) await cancelPendingOAuth();
-        this.awaitingKeyFor = null;
-        this.editor.setSecret(false);
-      } else if (this.inflight) { this.abort?.abort(); this.returnQueueToEditor(); }
-      else if (this.editor.state.text.length === 0 && Date.now() - this.lastEscape < 500) await this.openTreeSelect();
+      if (this.inflight) { this.abort?.abort(); this.returnQueueToEditor(); }
+      else if (this.editor.state.text.length === 0 && Date.now() - this.lastEscape < 500) {
+        const action = this.app.ui?.settings.doubleEscapeAction ?? "tree";
+        if (action === "tree") await this.openTreeSelect(); else if (action === "fork") await this.openForkSelect();
+      }
       this.lastEscape = Date.now();
       this.paint();
       return "continue";
     }
-    if (action === "app.message.dequeue") { this.recallLast(); this.paint(); return "continue"; }
+    if (action === "app.message.dequeue") { this.returnQueueToEditor(); this.paint(); return "continue"; }
     if (action === "app.toggleTools") { this.toolsExpanded = !this.toolsExpanded; this.paint(); return "continue"; }
-    if (action === "app.toggleThinking") { this.thinkingExpanded = !this.thinkingExpanded; this.paint(); return "continue"; }
+    if (action === "app.toggleThinking") { await commitSetting(this.app, "hideThinkingBlock", this.thinkingExpanded ? "on" : "off", this); return "continue"; }
     if (action === "app.externalEditor") { await this.openExternalEditor(); return "continue"; }
+    if (action === "app.clipboard.pasteImage") { await this.pasteClipboard(); return "continue"; }
+    if (action === "app.message.copy") {
+      if (this.screen.mode !== "fullscreen" || !await this.screen.copyActiveSelectionToClipboard()) await copyLastReply(this.app);
+      return "continue";
+    }
     if (!this.inflight) {
+      if (action === "app.session.new") { await openNewSession(this.app, this); return "continue"; }
+      if (action === "app.session.tree") { await this.openTreeSelect(); return "continue"; }
+      if (action === "app.session.fork") { await this.openForkSelect(); return "continue"; }
+      if (action === "app.session.resume") { void this.openResumeSelect(); return "continue"; }
       if (action === "app.model") { this.openModelSelect(); return "continue"; }
       if (action === "app.cycleModel" || action === "app.cycleModelReverse") {
         await cycleScopedModel(this.app, action === "app.cycleModel" ? 1 : -1); this.paint(); return "continue";
       }
-      if (action === "app.cycleThinking") { cycleThinking(this.app, this); return "continue"; }
+      if (action === "app.cycleThinking") { await cycleThinking(this.app, this); return "continue"; }
     }
-    if (this.inflight && action === "app.message.followUp") {
+    if (action === "app.message.followUp") {
       const text = this.editor.state.text;
       this.editor.applyExternal("");
       return this.submitLine(text, "followup");
     }
+    if (keyMatches(data, "enter") && this.pendingImages.length && !this.editor.state.text) return this.submitLine("", "steering");
     const state = this.editor.acceptInput(data);
     if (state.submitted !== null) return this.submitLine(state.submitted, "steering");
     this.paint();
@@ -2252,11 +3027,12 @@ export class Tui {
   private async submitLine(text: string, queueKind: QueueKind): Promise<"continue" | "quit"> {
     const line = text.trim();
     this.paint();
+    if (this.sessionTransition) { this.editor.applyExternal(text); this.app.io.say("  Wait for session import to finish."); return "continue"; }
     if (this.awaitingKeyFor !== null) {
       await handleLine(this.app, line, this);
       return "continue";
     }
-    if (!line) return "continue";
+    if (!line && !this.pendingImages.length) return "continue";
     const command = parseLine(this.app, line);
     if (command.kind !== "prompt") {
       if (this.inflight && commandDefinition(line)?.busy === "idle") {
@@ -2269,20 +3045,23 @@ export class Tui {
       this.paint();
       return result === "quit" ? "quit" : "continue";
     }
-    if (this.inflight) this.enqueue({ kind: queueKind, text: command.text });
-    else this.turn = this.runPromptTurn(command.text).catch((error: unknown) => {
+    const images = command.text.startsWith("!") ? [] : this.pendingImages;
+    if (!command.text.startsWith("!")) this.pendingImages = [];
+    if (this.inflight) this.enqueue({ kind: command.text.startsWith("!") ? "followup" : queueKind, text: command.text, ...(images.length ? { images } : {}) });
+    else this.turn = this.runPromptTurn(command.text, images).catch((error: unknown) => {
       this.app.io.say(this.app.io.palette.red(describeError(error)));
     });
     this.paint();
     return "continue";
   }
 
-  private async runPromptTurn(text: string): Promise<void> {
+  private async runPromptTurn(text: string, images: readonly ImageRef[] = []): Promise<void> {
     this.abort = new AbortController();
     this.inflight = true;
+    this.executionKind = text.startsWith("!") ? "bash" : "model";
     try {
-      await run(this.app, text, this.abort.signal, this);
-      if (!this.abort.signal.aborted) await this.drainFollowUps();
+      const sent = await run(this.app, text, this.abort.signal, this, images);
+      if (sent && !this.abort.signal.aborted) await this.drainFollowUps();
       this.app.io.say("");
     } finally {
       await this.syncTranscript();
@@ -2290,6 +3069,9 @@ export class Tui {
       this.abort = null;
       fileIndexes.delete(this.app.workspace);
       this.inflight = false;
+      this.executionKind = "idle";
+      this.bashOutput = null;
+      this.branch = currentBranch(this.app.workspace);
       this.clearStream();
       this.paint();
     }
@@ -2299,15 +3081,19 @@ export class Tui {
    * send() calls this at after_tools. Expansion is here because the
    * files the user named may have changed while the line waited.
    */
-  async pullQueued(phase: Phase): Promise<string | null> {
-    const item = nextDelivery(this.queue, phase);
-    if (item === null) return null;
-    this.queue = this.queue.filter((m) => m !== item);
+  async pullQueued(phase: Phase): Promise<UserInput | null> {
+    const batch = this.nextBatch(phase);
+    if (!batch.length) return null;
+    const expanded = await Promise.all(batch.map(item => this.expandQueued(item)));
+    this.queue = this.queue.filter((m) => !batch.includes(m));
     this.paintStream();
-    return this.expandQueued(item.text);
+    const present = expanded.filter((input): input is UserInput => input !== null).map(input => userInputData(input));
+    const text = present.map(input => input.text).join("\n\n"), images = present.flatMap(input => input.images ?? []);
+    return images.length ? { text, images } : text || null;
   }
 
-  private async expandQueued(text: string): Promise<string | null> {
+  private async expandQueued(item: QueuedMessage): Promise<UserInput | null> {
+    const text = item.text;
     const needsIndex = fileReferences(text).length > 0;
     const index: FileIndex = needsIndex
       ? await fileIndexFor(this.app)
@@ -2316,36 +3102,49 @@ export class Tui {
       workspace: this.app.workspace,
       index,
       say: (line) => this.app.io.say(line),
+      attachImage: path => attachImageFile(path, this.app.blobDir, this.app.ui?.settings.images?.autoResize ?? true),
     });
-    return expanded.send ? expanded.message : null;
+    const images = [...item.images ?? [], ...expanded.images ?? []];
+    return images.length ? { text: expanded.message, images } : expanded.send ? expanded.message : null;
   }
 
   private async drainFollowUps(): Promise<void> {
     while (this.abort !== null && !this.abort.signal.aborted) {
-      const item = nextDelivery(this.queue, "turn_end");
-      if (item === null) break;
-      this.queue = this.queue.filter((m) => m !== item);
+      const batch = this.nextBatch("turn_end");
+      if (!batch.length) break;
+      this.queue = this.queue.filter((m) => !batch.includes(m));
       this.paintStream();
-      await run(this.app, item.text, this.abort.signal, this);
+      if (!await run(this.app, batch.map(item => item.text).join("\n\n"), this.abort.signal, this, batch.flatMap(item => item.images ?? []))) break;
     }
   }
 
+  private nextBatch(phase: Phase): readonly QueuedMessage[] {
+    const settings = this.app.ui?.settings;
+    return deliveryBatch(this.queue, phase, { steering: settings?.steeringMode ?? "one-at-a-time", followup: settings?.followUpMode ?? "one-at-a-time" });
+  }
+
   private enqueue(item: QueuedMessage): void {
     this.queue.push(item);
   }
 
-  private recallLast(): void {
-    const last = this.queue.pop();
-    if (last === undefined) return;
-    const draft = this.editor.state.text;
-    const text = draft.length > 0 ? `${last.text}\n${draft}` : last.text;
-    this.editor.applyExternal(text);
+  beginBash(command: string): void {
+    this.executionKind = "bash";
+    this.bashDecoder = new TextDecoder();
+    this.bashOutput = `$ ${command}\n`;
+    this.paint();
+  }
+
+  pushBash(chunk: Uint8Array): void {
+    // Only the live preview is bounded; observeCommand archives every byte.
+    this.bashOutput = `${this.bashOutput ?? ""}${this.bashDecoder.decode(chunk, { stream: true })}`.slice(-64 * 1024);
+    this.paint();
   }
 
   private returnQueueToEditor(): void {
     if (this.queue.length === 0) return;
     const draft = this.editor.state.text;
     const parts = this.queue.map((m) => m.text);
+    this.pendingImages = [...this.queue.flatMap(m => m.images ?? []), ...this.pendingImages];
     if (draft.trim().length > 0) parts.push(draft);
     this.queue = [];
     this.editor.applyExternal(parts.join("\n"));