@visual-z/xeno 0.2.1 → 0.3.0

package/src/apps/shell.ts

@@ -1,34 +1,35 @@
 /**
  * Interactive loop and one-shot runner.
  *
- * The live UI is pi's TuiMainScreen (D19): the transcript sits in the
- * activity area and a collapse may clear terminal scrollback. A pipe or
- * CI run never constructs it — `-p` output is parsed by scripts.
+ * The live UI is OpenTUI (D20), driven through the same business hooks as
+ * line mode. A pipe or CI run never constructs it: `-p` output is parsed
+ * by scripts, while the interactive app projects the durable transcript.
  */
 
 import { basename, dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { homedir, tmpdir } from "node:os";
+import { tmpdir } from "node:os";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { assertNever } from "../core/exhaustive.ts";
 import type { LogEvent } from "../core/events.ts";
+import type { Skill } from "../core/skills.ts";
+import { workReadiness } from "../core/work-state.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 { attachImageFile } from "../runtime/images.ts";
+import { writeClipboard } 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";
-import { Transcript } from "../tui/transcript.ts";
 import type { Handoff } from "../core/handoff.ts";
 import { projectContext, type FrozenPrefix } from "../core/project.ts";
-import { shouldCut, DEFAULT_BOUNDARY, type BoundaryConfig, type BoundaryDecision } from "../core/boundary.ts";
+import { contextDetail } from "../core/context-detail.ts";
+import type { BoundaryConfig } from "../core/boundary.ts";
+import {
+  contextLimits, decideContext, DEFAULT_CONTEXT_POLICY, gaugeLevel, nextBoundary,
+  type ContextDecision, type ContextLimits, type ContextPolicy, type GaugeLevel,
+} from "../core/context-policy.ts";
 import { anchoredCount, estimateTokens, type Anchor, type TokenCounter } from "../core/tokens.ts";
-import type { RestorePoint, RewindMode, LoopEvent } from "../runtime/loop.ts";
+import type { RestorePoint, RewindMode } 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";
@@ -46,81 +47,57 @@ import {
 import { writeAuthFile } from "../store/auth-store.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 { buildFileIndex, indexTruncationNote, type FileIndex } from "../store/file-index.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 { 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, readManifest, setSessionLabel } from "../store/log.ts";
 import { registerSessionRoot } from "../store/session-browser.ts";
-import {
-  createSession, findSessionByPrefix, listSessions, truncationNote,
-  sessionsDir,
-} from "../store/sessions.ts";
+import { 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, installBindings, encodeKey, keyMatches } from "../tui/input.ts";
-import { interactiveAutocomplete } from "./completions.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, type TreePoint } from "../tui/tree.ts";
-import { renderStatus, type StatusState } from "../tui/statusline.ts";
-import { deliveryBatch, type Phase, type QueuedMessage, type QueueKind } from "../core/queue.ts";
+import { resolveTuiMode } from "../core/tui-mode.ts";
+import { recordRecent } from "../core/model-picker.ts";
+import { flattenTree, treeFromPoints, LEFT_BRANCH_MARK, EMPTY_TREE_MESSAGE, type TreeNode, type NodeParent, type TreePoint } from "../core/session-tree.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, 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 { defaultKeymap, listBindings } from "../core/keymap.ts";
+import { settingPatch, mergeSettings } from "../core/settings.ts";
+import { writeUserSettings, resolveTheme } from "../store/resources.ts";
 import { colorEnabled } from "./render.ts";
-import { renderToolView } from "../tui/toolview.ts";
+import { createStyle, IDENTITY } from "../tui/style.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 {
-  expandInput,
-} from "./input.ts";
+import { COMMANDS, parseCommand, type Command } from "./commands.ts";
+import { expandInput } from "./input.ts";
 import {
   describeError, firstLine, formatEvent, indent, stdinIsTty, stdoutIsTty, wrap,
 } from "./render.ts";
 import {
-  openSessionFor, sessionDirFor, retryHandler, whyNot, splitModelPatterns, runModelsRefresh, visibleSchemas, type App,
+  openSessionFor, sessionDirFor, retryHandler, whyNot, splitModelPatterns, runModelsRefresh, sessionToolCatalog, type App,
 } from "./startup.ts";
-import { SessionBrowser } from "./session-browser.ts";
+import type { TurnSurface, Ui } from "./ui/surface.ts";
 
-const HINT = `type a prompt, or ${COMMANDS.map((command) => `/${command.name}`).join(" ")}`;
+/**
+ * One line. Listing all ~40 commands here wrapped into a two-line wall that
+ * nobody reads; typing `/` already opens the searchable command menu.
+ */
+const HINT = `type a prompt · / for ${COMMANDS.length} commands · /login connects a provider · /model switches · /help`;
 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 {
+function extensionContext(app: App, tui?: Ui): 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)),
+    ui: tui?.extensionUi ?? 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(); },
+    hasPendingMessages: () => (tui?.queueLength ?? 0) > 0,
+    abort: () => { tui?.interrupt(); 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(),
@@ -133,8 +110,8 @@ function extensionContext(app: App, tui?: Tui): ExtensionContext {
   };
 }
 
-async function bindExtensions(app: App, tui?: Tui): Promise<void> {
-  await tui?.extensionUi.bind(app.extensions, app.resources);
+async function bindExtensions(app: App, tui?: Ui): Promise<void> {
+  tui?.bindExtensionRegistry();
   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));
@@ -148,29 +125,28 @@ async function bindExtensions(app: App, tui?: Tui): Promise<void> {
     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 })),
+    getTools: () => app.session.config.frozen.tools.flatMap(tool => tool !== null && typeof tool === "object" &&
+      "name" in tool && typeof tool.name === "string" && "description" in tool && typeof tool.description === "string" && "input_schema" in tool
+      ? [{ name: tool.name, description: tool.description, parameters: JSON.parse(JSON.stringify(tool.input_schema)) as unknown }] : []),
+    getAllTools: () => {
+      const { schemas, deferred } = sessionToolCatalog(app.args, registry, app.session.config.frozen.tools);
+      return [...new Map([...schemas, ...deferred].map(tool => [tool.name, tool])).values()]
+        .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);
+      const { schemas: tools, deferred } = sessionToolCatalog(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;
+      await app.session.reloadResources({ ...app.session.config.frozen, tools });
+      app.session.config.tools.deferredTools = deferred; 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); }
-    },
+    exec: (command, args, options) => app.session.runExtensionCommand(command, args, options),
   });
   if (!initializedExtensions.has(registry)) {
     initializedExtensions.add(registry);
@@ -187,31 +163,40 @@ function parseLine(app: App, text: string): Command {
 
 /**
  * Inputs maybeCut reads when it decides whether to cut. The gauge must use
- * this same set -- a second estimate would disagree with the actual cut.
+ * this same set -- a second estimate would disagree with the actual cut. Policy,
+ * window and reserve have no defaults: a default is how the footer came to
+ * measure against a boundary the active policy never consults.
  */
 export interface BudgetInput {
+  readonly logHint?: { manifestPath: string; segmentPath: string };
   readonly frozen: FrozenPrefix;
   readonly handoff: Handoff | null;
   readonly events: readonly LogEvent[];
   readonly anchor: Anchor | null;
   readonly counter?: TokenCounter;
   readonly boundary?: Partial<BoundaryConfig>;
-  /** maybeCut only runs at a turn boundary; the prompt is that boundary. */
-  readonly atTurnBoundary?: boolean;
+  readonly policy: ContextPolicy;
+  readonly contextWindow: number | undefined;
+  readonly outputReserve: number;
 }
 
 export interface ContextBudget {
   readonly used: number;
-  readonly trigger: number;
+  /** Nothing the provider reported backs the count: before the first response, after a cut. */
+  readonly estimated: boolean;
+  /** Where the active policy next acts; null when it names no boundary. */
+  readonly trigger: number | null;
   readonly inherited: number;
-  readonly decision: BoundaryDecision;
+  readonly limits: ContextLimits;
+  readonly decision: ContextDecision;
+  readonly level: GaugeLevel;
 }
 
 /**
  * The numbers the status gauge shows, computed the same way maybeCut does:
  * anchoredCount for the current projection, inheritedTokens from the empty
- * node, shouldCut for whether a cut is actually possible. The TUI must not
- * recompute the work floor.
+ * node, contextLimits and decideContext for what the next turn boundary does.
+ * The TUI must not recompute the work floor.
  */
 export function contextBudget(input: BudgetInput): ContextBudget {
   const counter = input.counter ?? estimateTokens;
@@ -219,8 +204,9 @@ export function contextBudget(input: BudgetInput): ContextBudget {
     frozen: input.frozen,
     handoff: input.handoff,
     events: input.events,
+    ...(input.logHint ? { logHint: input.logHint } : {}),
   });
-  const { tokens } = anchoredCount(
+  const { tokens, exactUpTo } = anchoredCount(
     projected.messages,
     projected.system,
     input.anchor,
@@ -231,16 +217,38 @@ export function contextBudget(input: BudgetInput): ContextBudget {
     frozen: input.frozen,
     handoff: input.handoff,
     events: [],
+    ...(input.logHint ? { logHint: input.logHint } : {}),
   });
   const inherited = counter.count(floor.messages, floor.system, input.frozen.tools);
-  const cfg = { ...DEFAULT_BOUNDARY, ...input.boundary };
-  const decision = shouldCut({
+  const limits = contextLimits({
+    policy: input.policy,
+    contextWindow: input.contextWindow,
+    outputReserve: input.outputReserve,
+    ...(input.boundary ? { boundary: input.boundary } : {}),
+  });
+  // The footer asks what the next turn boundary does, even mid-turn. Readiness
+  // and price are not known here, so adaptive reads as deferrable at its soft
+  // trigger and certain only at the hard limit.
+  const decision = decideContext({
+    policy: input.policy,
+    continuationReady: false,
+    cost: null,
     tokens,
     inheritedTokens: inherited,
-    atTurnBoundary: input.atTurnBoundary ?? true,
+    atTurnBoundary: true,
+    ...(input.contextWindow === undefined ? {} : { contextWindow: input.contextWindow }),
+    outputReserve: input.outputReserve,
     ...(input.boundary ? { config: input.boundary } : {}),
   });
-  return { used: tokens, trigger: cfg.triggerTokens, inherited, decision };
+  return {
+    used: tokens,
+    estimated: exactUpTo === 0,
+    trigger: nextBoundary(limits),
+    inherited,
+    limits,
+    decision,
+    level: gaugeLevel(tokens, limits, decision),
+  };
 }
 
 export function resolveEditorCommand(
@@ -315,9 +323,10 @@ 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();
+  if (app.shutdownRequested) { await app.session.dispose(); await app.extensions?.dispose(); return; }
+  let ok: boolean;
+  try { ok = await run(app, prompt); }
+  finally { await app.session.dispose(); 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);
@@ -366,72 +375,54 @@ async function runLines(app: App): Promise<void> {
     if (typeof outcome === "object") awaitingKeyFor = outcome.login;
   }
   await cancelPendingOAuth(app);
+  await app.session.dispose();
   await app.extensions?.dispose();
   printUsage(app);
 }
 
 async function runTui(app: App, releaseEarlyTty?: () => void): Promise<void> {
-  const C = app.io.palette;
   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();
-      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 {
-    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);
-  }
+  // Process start is the one place `auto` meets the real terminal (core/tui-mode.ts).
+  if (app.ui) app.ui.settings = { ...app.ui.settings, tuiMode: resolveTuiMode({ flag: app.args.tuiMode, setting: app.ui.settings.tuiMode, env: process.env }).mode };
+  const { runInteractive } = await import("./ui/app.ts");
+  await runInteractive(app, interactiveHooks, releaseEarlyTty);
+  printUsage(app);
 }
 
+/**
+ * The business operations the interactive controller drives. Exported as one
+ * object so apps/ui/app.ts depends on shell.ts in one direction only and the
+ * set of things the UI can do is visible in one place.
+ */
+export const interactiveHooks = {
+  handleLine: (app: App, text: string, ui: Ui) => handleLine(app, text, ui),
+  run: (app: App, prompt: string, signal: AbortSignal | undefined, ui: Ui | undefined, images: readonly ImageRef[] = [], skill?: Skill) => run(app, prompt, signal, ui, images, skill),
+  parseLine: (app: App, text: string) => parseLine(app, text),
+  bindExtensions: (app: App, ui?: Ui) => bindExtensions(app, ui),
+  extensionContext: (app: App, ui?: Ui) => extensionContext(app, ui),
+  cancelPendingOAuth: (app: App) => cancelPendingOAuth(app),
+  switchToModel: (app: App, spec: ModelSpec) => switchToModel(app, spec),
+  applyThinking: (app: App, effort: Effort, ui: Ui | null) => applyThinking(app, effort, ui),
+  cycleThinking: (app: App, ui: Ui | null) => cycleThinking(app, ui),
+  cycleScopedModel: (app: App, direction: 1 | -1) => cycleScopedModel(app, direction),
+  commitSetting: (app: App, field: string, value: string, ui: Ui | null) => commitSetting(app, field, value, ui),
+  startSubscriptionLogin: (app: App, id: string, ui: Ui | null) => startSubscriptionLogin(app, id, ui),
+  login: (app: App, provider: string, key: string) => login(app, provider, key),
+  logout: (app: App, provider: string) => logout(app, provider),
+  resumeSession: (app: App, path: string, ui: Ui) => resumeSession(app, path, ui),
+  openNewSession: (app: App, ui: Ui) => openNewSession(app, ui),
+  forkSession: (app: App, arg: string, ui: Ui) => forkSession(app, arg, ui),
+  trustProject: (app: App, choice: TrustChoice, ui: Ui) => trustProject(app, choice, ui),
+  treeNodesFor: (app: App) => treeNodesFor(app),
+  copyLastReply: (app: App) => copyLastReply(app),
+  effortSupported: (spec: ModelSpec, level: Effort) => effortSupported(spec, level),
+  fileIndexFor: (app: App, refresh?: boolean) => fileIndexFor(app, refresh),
+  dropFileIndex: (workspace: string) => { fileIndexes.delete(workspace); },
+};
+
 type Outcome = "continue" | "quit" | { login: string };
 
-async function execute(app: App, command: Command, tui: Tui | null): Promise<Outcome> {
+async function execute(app: App, command: Command, tui: Ui | null): Promise<Outcome> {
   switch (command.kind) {
     case "extension":
       if (tui) tui.runExtensionCommand(command.name, command.args);
@@ -449,6 +440,35 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
     case "state":
       printState(app);
       return "continue";
+    case "context":
+      printContext(app);
+      return "continue";
+    case "acceptance":
+      await printAcceptance(app);
+      return "continue";
+    case "tasks": {
+      const items = await app.session.workItems();
+      app.io.say(`\nwork tasks: ${items.length}`);
+      for (const item of items) {
+        const ready = workReadiness(items, item.id);
+        app.io.say(`  ${item.id}: ${ready.reason} · ${item.what} · verification=${item.verification}${item.owner ? ` · owner=${item.owner}` : ""}`);
+        if (ready.waiting_for.length) app.io.say(`    waiting for: ${ready.waiting_for.join(", ")}`);
+      }
+      return "continue";
+    }
+    case "branches": {
+      if (command.action !== undefined && command.node !== undefined) app.io.say((await app.session.resolveBranch(command.node, command.action)).content);
+      for (const item of await app.session.branchStatuses()) app.io.say(`  branch ${item.node}: ${item.status} · ${item.purpose}${item.receipt_ref ? ` · receipt ${item.receipt_ref}` : ""}`);
+      return "continue";
+    }
+    case "processes": {
+      for (const item of await app.session.processStatuses()) app.io.say(`  process ${item.session}: ${item.status} · last observation=${item.observed}${item.exit !== undefined ? ` · exit=${item.exit}` : ""}${item.output ? ` · output ${item.output.sha256}` : ""}`);
+      return "continue";
+    }
+    case "accept":
+      await app.session.acceptCriterion(command.criterion);
+      await printAcceptance(app);
+      return "continue";
     case "help":
       printHelp(app);
       return "continue";
@@ -464,7 +484,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
       return "continue";
     }
     case "config":
-      if (tui) await tui.openResourceSelect();
+      if (tui) await tui.openResources();
       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}`);
@@ -479,7 +499,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
         return "continue";
       }
       if (tui) {
-        tui.openModelSelect();
+        tui.openModel();
         return "continue";
       }
       printModels(app);
@@ -492,7 +512,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
       return applyThinkingCommand(app, command.level, tui);
     case "login": {
       if (command.provider === undefined) {
-        if (tui) { tui.openLoginSelect(); return "continue"; }
+        if (tui) { tui.openLogin(); return "continue"; }
         const C = app.io.palette;
         const providers = [...new Set(app.catalog.map((m) => m.provider))];
         app.io.say(C.bold("\nlogin"));
@@ -511,16 +531,22 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
       if (isSubscriptionLogin(command.provider)) {
         return startSubscriptionLogin(app, command.provider, tui);
       }
+      if (tui) {
+        const provider = command.provider;
+        const key = await tui.askSecret(`API key · ${provider}`, "Key", "paste the key · $VAR reads the environment · !cmd runs a command · enter save · esc cancel");
+        if (key) await login(app, provider, key); else if (key !== undefined) tui.notice("  cancelled");
+        return "continue";
+      }
       const C = app.io.palette;
-      // The editor paints a mask; this sentence has to match that, because
-      // "it will be visible here" is how a secret ends up in a screenshot.
+      // Line mode echoes nothing for this line; the sentence must say so,
+      // because "it will be visible here" is how a secret ends up in a screenshot.
       app.io.say(C.yellow(`  paste the ${command.provider} key and press enter. It is not shown.`));
       app.io.say(C.dim("  a value starting with ! runs as a command; $VAR reads the environment."));
       app.io.say(C.dim("  empty line cancels."));
       return { login: command.provider };
     }
     case "logout": {
-      if (tui && command.provider === undefined) { tui.openLogoutSelect(); return "continue"; }
+      if (tui && command.provider === undefined) { tui.openLogout(); return "continue"; }
       await logout(app, command.provider);
       return "continue";
     }
@@ -539,7 +565,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
     }
     case "tree":
       if (tui) {
-        await tui.openTreeSelect();
+        await tui.openTree();
         return "continue";
       }
       await printTree(app);
@@ -553,7 +579,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
         return "continue";
       }
       if (tui) {
-        void tui.openResumeSelect();
+        void tui.openResume();
         return "continue";
       }
       await printSessionList(app);
@@ -567,7 +593,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
     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; }
+        if (tui && !await tui.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}`); }
@@ -578,25 +604,25 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
     }
     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 frame = tui?.snapshot() ?? { width: 80, height: 0, lines: [] };
+      const { width, height, lines } = frame;
       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");
+        ...lines.map((line, i) => `[${i}] ${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);
+      if (tui) tui.showDocument("Changelog", text); else app.io.say(text);
       return "continue";
     }
     case "copy":
       await copyLastReply(app, tui ?? undefined);
       return "continue";
     case "fork":
-      if (tui && command.arg === undefined) { await tui.openForkSelect(); return "continue"; }
+      if (tui && command.arg === undefined) { await tui.openFork(); return "continue"; }
       await forkSession(app, command.arg, tui ?? undefined);
       return "continue";
     case "clone":
@@ -605,7 +631,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
       return "continue";
     case "trust":
       if (command.target) await trustProject(app, command.target, tui ?? undefined);
-      else if (tui) await tui.openTrustSelect();
+      else if (tui) await tui.openTrust();
       else app.io.say("  /trust once|here|parent|never controls project resources; tool permissions are separate.");
       return "continue";
     case "models-refresh":
@@ -615,7 +641,7 @@ async function execute(app: App, command: Command, tui: Tui | null): Promise<Out
       app.io.say(app.io.palette.yellow(`  unknown command: ${command.input}. /help lists them.`));
       return "continue";
     case "prompt":
-      await run(app, command.text, tui?.signal, tui ?? undefined);
+      await run(app, command.text, tui?.signal, tui ?? undefined, [], command.skill);
       app.io.say("");
       return "continue";
     default:
@@ -623,33 +649,8 @@ 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;
-    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(app);
-      tui.endCredentialInput();
-      app.io.say(app.io.palette.dim("  cancelled\n"));
-      return "continue";
-    }
-    if (provider === OAUTH_PASTE) {
-      tui.editor.applyExternal("");
-      tui.runExtensionAction(() => completeOAuthPaste(app, text));
-      return "continue";
-    }
-    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.beginCredentialInput(outcome.login);
-  }
-  return outcome;
+async function handleLine(app: App, text: string, tui: Ui): Promise<Outcome> {
+  return execute(app, parseLine(app, text), tui);
 }
 
 function printUsage(app: App): void {
@@ -724,6 +725,43 @@ function printState(app: App): void {
   app.io.say("");
 }
 
+function printContext(app: App): void {
+  const session = app.session;
+  const detail = contextDetail({ ...session.contextInput(), anchor: session.state.anchor,
+    policy: session.config.contextPolicy ?? DEFAULT_CONTEXT_POLICY,
+    contextWindow: session.provider.config.spec.contextWindow, outputReserve: session.provider.config.maxTokens,
+    ...(session.config.counter ? { counter: session.config.counter } : {}),
+    ...(session.config.boundary ? { boundary: session.config.boundary } : {}),
+  });
+  app.io.say(app.io.palette.bold(`\ncontext v${detail.version} · node ${session.state.node} · ${detail.policy}`));
+  for (const [name, tokens] of Object.entries(detail.components)) app.io.say(`  ${name.padEnd(18)} ~${tokens} tokens`);
+  app.io.say(`  total             ${detail.used} (${detail.countKind}; anchor correction ${detail.anchorCorrection}; measured through ${detail.measuredThrough} messages)`);
+  app.io.say(`  limits            ${JSON.stringify(detail.limits)}`);
+  const sources = detail.sources.flat();
+  app.io.say(`  sources           ${sources.length} references: ${sources.slice(-12).join(", ") || "none"}`);
+  if (sources.length > 12) app.io.say(`  earlier sources   ${sources.length - 12}; use history(recent=true) or history(event=ID)`);
+  for (const section of detail.sections.filter(s => s.omitted > 0)) {
+    app.io.say(`  ${section.section} retained ${section.retained}/${section.total}; omitted ${section.omitted}; history(${JSON.stringify(section.recovery)})`);
+  }
+  app.io.say(`  metadata          ${detail.omittedEvents.length} events do not replay as messages; available in the log`);
+  if (detail.violations.length) app.io.say(`  violations        ${JSON.stringify(detail.violations)}`);
+  app.io.say("");
+}
+
+async function printAcceptance(app: App): Promise<void> {
+  const state = await app.session.acceptanceState();
+  app.io.say(state ? `\nacceptance ${state.contract_id}: ${state.status}` : "\nacceptance: no declared task contract");
+  for (const target of state?.targets ?? []) {
+    app.io.say(`  target ${target.id}: ${target.status} · entry ${target.entry ?? "unobserved"} · pid ${target.pid ?? "unknown"} · session ${target.session ?? "none"} · port ${target.port ?? "not declared"}`);
+    app.io.say(`    build ${target.build_event ?? "none"}; instance ${target.binding ?? "unknown"}; observation ${target.observation ?? "none"}; ${target.reason ?? "start the declared target after its build"}`);
+  }
+  for (const item of state?.criteria ?? []) {
+    app.io.say(`  ${item.id}: ${item.status} · ${item.description}`);
+    if (item.kind === "command") app.io.say(`    command: ${item.command}; evidence: ${item.evidence?.event_id ?? "none"}`);
+    else if (item.status !== "accepted") app.io.say(`    /accept ${item.id} records your acceptance${item.target ? ` of the observed target ${item.target}` : ""}`);
+  }
+}
+
 function printHotkeys(app: App): void {
   const C = app.io.palette;
   const map = app.ui?.keymap ?? defaultKeymap();
@@ -740,7 +778,7 @@ async function applySettingsCommand(
   app: App,
   field: string | undefined,
   value: string | undefined,
-  tui: Tui | null,
+  tui: Ui | null,
 ): Promise<Outcome> {
   if (field !== undefined && value !== undefined) {
     await commitSetting(app, field, value, tui);
@@ -759,7 +797,7 @@ async function applySettingsCommand(
   return "continue";
 }
 
-async function commitSetting(app: App, field: string, value: string, tui: Tui | null): Promise<void> {
+async function commitSetting(app: App, field: string, value: string, tui: Ui | null): Promise<void> {
   const C = app.io.palette;
   const key = field.toLowerCase();
   if (app.ui === undefined) {
@@ -783,10 +821,11 @@ async function commitSetting(app: App, field: string, value: string, tui: Tui |
   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}`));
+  if (tui) tui.toast(`${field} · ${value}`, "success");
+  else app.io.say(C.dim(`  ${field} ${value}`));
   tui?.applyConfiguration();
   if (key === "theme") tui?.followTheme();
-  tui?.paint();
+  tui?.redraw();
 }
 
 const EFFORTS = THINKING_LEVELS;
@@ -801,7 +840,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.
  */
-async function applyThinking(app: App, level: Effort, tui: Tui | null): Promise<boolean> {
+async function applyThinking(app: App, level: Effort, tui: Ui | null): Promise<boolean> {
   const C = app.io.palette;
   if (!effortSupported(app.providerConfig.spec, level)) {
     app.io.say(
@@ -820,11 +859,11 @@ async function applyThinking(app: App, level: Effort, tui: Tui | null): Promise<
     app.ui.settings = { ...app.ui.settings, thinking: level };
   }
   app.io.say(C.dim(`  thinking ${level}`));
-  tui?.paint();
+  tui?.redraw();
   return true;
 }
 
-async function applyThinkingCommand(app: App, level: string | undefined, tui: Tui | null): Promise<Outcome> {
+async function applyThinkingCommand(app: App, level: string | undefined, tui: Ui | null): Promise<Outcome> {
   if (level !== undefined) {
     const effort = asEffort(level);
     if (effort === undefined) {
@@ -835,7 +874,7 @@ async function applyThinkingCommand(app: App, level: string | undefined, tui: Tu
     return "continue";
   }
   if (tui) {
-    tui.openThinkingSelect();
+    tui.openThinking();
     return "continue";
   }
   printThinking(app);
@@ -856,7 +895,7 @@ function printThinking(app: App): void {
   app.io.say(C.dim("\n  /thinking <level> to switch. Shift+Tab cycles supported levels.\n"));
 }
 
-async function cycleThinking(app: App, tui: Tui | null): Promise<void> {
+async function cycleThinking(app: App, tui: Ui | 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;
@@ -977,10 +1016,11 @@ async function printBack(app: App): Promise<void> {
  * Jumping still needs the TUI; this is so a pipe can see the structure.
  */
 async function printTree(app: App): Promise<void> {
-  const nodes = await treeNodesFor(app);
-  const style = app.ui?.style ?? IDENTITY;
-  for (const line of renderTree(nodes, { index: 0, filter: "all" }, 80, style)) {
-    app.io.say(line);
+  const rows = flattenTree(await treeNodesFor(app));
+  if (!rows.length) { app.io.say(EMPTY_TREE_MESSAGE); return; }
+  for (const row of rows) {
+    const mark = row.node.current ? "● " : row.node.onPath ? "  " : `${LEFT_BRANCH_MARK} `;
+    app.io.say(row.branch + mark + (row.node.label ? `[${row.node.label}] ` : "") + firstLine(row.node.prompt, 72));
   }
 }
 
@@ -1045,7 +1085,7 @@ async function printRewind(
 ): Promise<void> {
   const C = app.io.palette;
   const label = firstLine(point.prompt, 60);
-  const plan = await app.session.previewRewind(point);
+  const plan = await app.session.previewRewind(point, mode);
   if (!plan.ok) {
     app.io.say(C.red(`\n  cannot go back: ${plan.error}\n`));
     return;
@@ -1066,7 +1106,7 @@ async function printRewind(
     for (const p of extra.slice(0, 20)) app.io.say(C.yellow(`    stays   ${p}  (not in that context)`));
     if (extra.length > 20) app.io.say(C.yellow(`    ... ${extra.length - 20} more`));
   } else {
-    for (const p of plan.willWrite.slice(0, 20)) app.io.say(C.dim(`    keep    ${p}`));
+    for (const p of plan.willWrite.slice(0, 20)) app.io.say(C.dim(`    restore ${p}`));
     if (plan.willWrite.length > 20) app.io.say(C.dim(`    ... ${plan.willWrite.length - 20} more`));
     for (const p of plan.willDelete.slice(0, 20)) app.io.say(C.red(`    delete  ${p}`));
     if (plan.willDelete.length > 20) app.io.say(C.red(`    ... ${plan.willDelete.length - 20} more`));
@@ -1216,13 +1256,15 @@ interface PendingOAuth {
   exchange: "anthropic" | "openai";
   server: CallbackServer;
   done: boolean;
-  tui: Tui | null;
+  tui: Ui | null;
   abort: AbortController;
+  /** Closes the UI's waiting dialog, if any. */
+  close?: () => void;
 }
 
 // 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 pendingDevices = new WeakMap<App, { abort: AbortController; tui: Ui | null; close?: () => void }>();
 const loginEffects = { fetch: ((input, init) => globalThis.fetch(input, init)) as typeof globalThis.fetch,
   openBrowser: tryOpenBrowser, callback: startCallbackServer, device: loginGitHubCopilot };
 
@@ -1230,8 +1272,7 @@ 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();
+  pending?.close?.(); device?.close?.();
   if (pending) { pending.done = true; await pending.server.close(); }
 }
 
@@ -1282,7 +1323,7 @@ async function finishOAuthCode(app: App, pending: PendingOAuth, code: string): P
   } finally {
     if (pendingLogins.get(app) === pending) {
       pendingLogins.delete(app);
-      pending.tui?.endCredentialInput();
+      pending.close?.();
     }
     await pending.server.close();
   }
@@ -1313,7 +1354,7 @@ function tryOpenBrowser(url: string): void {
   }
 }
 
-async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Promise<Outcome> {
+async function startSubscriptionLogin(app: App, id: string, tui: Ui | null): Promise<Outcome> {
   const C = app.io.palette;
   const sub = subscriptionById(id);
   if (sub === undefined) return "continue";
@@ -1321,11 +1362,15 @@ async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Pr
   const effects = tui?.oauthEffects ?? loginEffects;
   app.io.say(C.yellow(`  ${SUBSCRIPTION_NOTICE}`));
   if (sub.id === "github-copilot") {
-    const pending = { abort: new AbortController(), tui };
+    const pending: { abort: AbortController; tui: Ui | null; close?: () => void } = { 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}`); },
+        notify: (message) => {
+          if (pendingDevices.get(app) !== pending) return;
+          if (tui) { pending.close?.(); pending.close = tui.waiting("GitHub Copilot", message.split("\n"), () => { void cancelPendingOAuth(app); }); }
+          else app.io.say(`  ${message}`);
+        },
         prompt: async () => "",
         fetch: effects.fetch,
         signal: pending.abort.signal,
@@ -1339,10 +1384,10 @@ async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Pr
     } finally {
       if (pendingDevices.get(app) === pending) {
         pendingDevices.delete(app);
-        tui?.endCredentialInput();
+        pending.close?.();
       }
     } };
-    if (tui) { tui.beginCredentialInput(OAUTH_DEVICE); tui.runExtensionAction(work); return "continue"; }
+    if (tui) { pending.close = tui.waiting("GitHub Copilot", ["Requesting a device code…"], () => { void cancelPendingOAuth(app); }); tui.runExtensionAction(work); return "continue"; }
     await work();
     return "continue";
   }
@@ -1372,8 +1417,10 @@ async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Pr
       close: async () => {},
     };
   }
-  app.io.say(`  ${url}`);
-  app.io.say(C.dim("  complete login in the browser, or paste the redirect URL. It is not shown."));
+  if (!tui) {
+    app.io.say(`  ${url}`);
+    app.io.say(C.dim("  complete login in the browser, or paste the redirect URL. It is not shown."));
+  }
   effects.openBrowser(url);
   const pending: PendingOAuth = {
     id: sub.id,
@@ -1392,6 +1439,12 @@ async function startSubscriptionLogin(app: App, id: string, tui: Tui | null): Pr
     if (!got.ok || pending.done) return;
     await finishOAuthCode(app, pending, got.code);
   });
+  if (tui) {
+    // The URL is shown (it is not a secret); the pasted redirect is, so it goes through a masked field.
+    pending.close = tui.waiting(sub.label, ["Finish signing in in your browser.", "", url, "", "Or paste the redirect URL here if the browser cannot reach this machine."],
+      () => { void cancelPendingOAuth(app); }, "Redirect URL", value => tui.runExtensionAction(() => completeOAuthPaste(app, value)));
+    return "continue";
+  }
   return { login: OAUTH_PASTE };
 }
 
@@ -1452,7 +1505,7 @@ async function switchByPattern(app: App, pattern: string): Promise<void> {
   await switchToModel(app, selected.model, selected.thinking);
 }
 
-async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort): Promise<void> {
+export async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort): Promise<void> {
   const C = app.io.palette;
   if (spec.id === app.providerConfig.spec.id && spec.provider === app.providerConfig.spec.provider) {
     if (thinking) await applyThinking(app, clampThinkingLevel(spec, thinking), null);
@@ -1474,8 +1527,7 @@ async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort): Prom
     thinkingDisplay: app.providerConfig.thinkingDisplay,
   };
   const next = makeProvider(app, nextConfig, got.key);
-  app.io.say(C.yellow("  switching cuts this node so the next model starts from a handoff,"));
-  app.io.say(C.yellow("  not from this model's thinking blocks."));
+  app.io.say(C.dim("  new segment: the next model starts from a handoff, not this model's thinking"));
   try {
     await app.session.switchModel(next);
   } catch (err) {
@@ -1485,13 +1537,22 @@ async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort): Prom
   app.providerConfig = nextConfig;
   app.credential = got;
   app.io.say(C.green(`  now ${spec.name}`) + C.dim(`  ${spec.id}`));
+  await rememberRecentModel(app, spec);
+}
+
+/** Recency feeds the picker's first section; a write failure only costs ordering. */
+async function rememberRecentModel(app: App, spec: ModelSpec): Promise<void> {
+  if (!app.ui) return;
+  const recentModels = recordRecent(app.ui.settings.recentModels ?? [], modelKey(spec));
+  app.ui.settings = { ...app.ui.settings, recentModels };
+  try { await writeUserSettings({ recentModels }); } catch { /* ordering only */ }
 }
 
 function sessionDirOf(app: App): string | undefined {
   return sessionDirFor(app.args, app.workspace);
 }
 
-async function openNewSession(app: App, tui?: Tui): Promise<void> {
+async function openNewSession(app: App, tui?: Ui): Promise<void> {
   const C = app.io.palette;
   const created = await createSession(app.workspace, undefined, sessionDirOf(app));
   const switched = await adoptLogDir(app, created.path);
@@ -1503,7 +1564,7 @@ async function openNewSession(app: App, tui?: Tui): Promise<void> {
   app.io.say(C.green(`  new session ${created.id}`) + C.dim(`  ${created.path}`));
 }
 
-async function resumeSession(app: App, idOrPath: string, tui?: Tui): Promise<void> {
+async function resumeSession(app: App, idOrPath: string, tui?: Ui): Promise<void> {
   const C = app.io.palette;
   const found = await findSessionByPrefix(app.workspace, idOrPath, sessionDirOf(app));
   if (!found.ok) {
@@ -1525,7 +1586,10 @@ async function resumeSession(app: App, idOrPath: string, tui?: Tui): Promise<voi
 
 async function adoptLogDir(app: App, logDir: string): Promise<boolean> {
   try {
+    app.session.cancel(); await app.session.whenIdle();
+    if (app.extensions && !await app.extensions.releaseIntegrations()) throw Error("An integration still owns unfinished work or unconfirmed cleanup. Wait for it to settle before switching sessions.");
     const opened = await openSessionFor({ ...app, logDir, fallback: app.providerConfig, interactive: true });
+    await app.session.dispose();
     await app.extensions?.dispose();
     app.session = opened.session;
     app.providerConfig = opened.providerConfig;
@@ -1574,7 +1638,7 @@ async function exportSession(app: App, file?: string): Promise<void> {
   app.io.say(C.green(`  exported ${abs}`));
 }
 
-async function copyLastReply(app: App, tui?: Tui): Promise<void> {
+async function copyLastReply(app: App, tui?: Ui): Promise<void> {
   const C = app.io.palette;
   const text = lastAssistantText(await transcriptEvents(app));
   if (text === null) {
@@ -1590,7 +1654,7 @@ async function copyLastReply(app: App, tui?: Tui): Promise<void> {
   app.io.say(text);
 }
 
-async function forkSession(app: App, arg?: string, tui?: Tui): Promise<void> {
+async function forkSession(app: App, arg?: string, tui?: Ui): Promise<void> {
   const C = app.io.palette;
   const points = await app.session.userMessages();
   if (arg === undefined) {
@@ -1616,7 +1680,7 @@ async function forkSession(app: App, arg?: string, tui?: Tui): Promise<void> {
   if (await spawnForkedSession(app, point.id, `forked before ${firstLine(point.text, 40)}`, "before")) {
     await tui?.syncTranscript();
     tui?.restoreDraft(point.text, point.images ?? []);
-    tui?.paint();
+    tui?.redraw();
   }
 }
 
@@ -1639,7 +1703,7 @@ async function spawnForkedSession(app: App, untilEvent: string | undefined, labe
   return true;
 }
 
-async function trustProject(app: App, target: TrustChoice, tui?: Tui): Promise<void> {
+async function trustProject(app: App, target: TrustChoice, tui?: Ui): Promise<void> {
   const C = app.io.palette;
   const dir = target === "parent" ? dirname(app.workspace) : app.workspace;
   const trusted = await applyTrustChoice(app.workspace, target);
@@ -1655,7 +1719,7 @@ async function trustProject(app: App, target: TrustChoice, tui?: Tui): Promise<v
   await tui?.refreshResources();
 }
 
-async function nameSession(app: App, name: string, tui?: Tui): Promise<void> {
+async function nameSession(app: App, name: string, tui?: Ui): Promise<void> {
   const C = app.io.palette;
   if (name.length === 0) {
     app.io.say(C.dim("  /name <name>"));
@@ -1675,7 +1739,7 @@ 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, images: readonly ImageRef[] = []): Promise<boolean> {
+async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Ui, images: readonly ImageRef[] = [], skill?: Skill): 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;
@@ -1754,7 +1818,7 @@ async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Tui, im
     return false;
   }
   try {
-    await runTurn(app, input, signal, tui);
+    await runTurn(app, input, signal, tui, skill);
     return true;
   } catch (error) {
     tui?.discardStream();
@@ -1768,28 +1832,14 @@ async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Tui, im
   }
 }
 
-export interface TurnSurface {
-  /** Interactive UI projects committed log events; stream-only consumers omit this. */
-  syncTranscript?(): Promise<void>;
-  pushDelta(kind: "text" | "thinking", text: string): void;
-  commitStream(): void;
-  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<UserInput | null>;
-}
+export type { TurnSurface };
 
 export async function runTurn(
   app: Pick<App, "session" | "io"> & { readonly ui?: App["ui"]; readonly args?: App["args"]; readonly extensions?: App["extensions"] },
   prompt: UserInput,
   signal?: AbortSignal,
   tui?: TurnSurface,
+  skill?: Skill,
 ): Promise<void> {
   // A pipe cannot unwrite bytes. Non-tty / -p therefore does not stream:
   // deltas and discard are ignored, and the final block prints once.
@@ -1805,7 +1855,7 @@ export async function runTurn(
   }
   await registry?.emit("agent_start");
   await registry?.emit("turn_start", { turnIndex: 0 });
-  try { for await (const e of app.session.send(prompt, signal, pull)) {
+  try { for await (const e of skill ? app.session.sendSkill(skill, prompt, signal) : 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 });
@@ -1825,7 +1875,7 @@ export async function runTurn(
         await tui.syncTranscript();
         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);
+          for (const line of formatEvent(e, app.io.palette, Math.max(20, (process.stdout.columns ?? 80) - 1), {}, app.ui?.style)) app.io.say(line);
         }
       }
       continue;
@@ -1853,14 +1903,6 @@ export async function runTurn(
     }
     if (skipFinal && (e.kind === "assistant_text" || e.kind === "thinking")) continue;
     if (skipFinal && e.kind !== "usage") skipFinal = false;
-    if (
-      tui !== undefined &&
-      tui.pushEvent !== undefined &&
-      (e.kind === "tool_call" || e.kind === "tool_result" || e.kind === "thinking")
-    ) {
-      tui.pushEvent(e);
-      continue;
-    }
     if (e.kind === "assistant_text" && app.io.answer !== undefined) {
       app.io.answer(e.text ?? "");
       continue;
@@ -1868,7 +1910,7 @@ export async function runTurn(
     for (const line of formatEvent(
       e,
       app.io.palette,
-      usableColumns(process.stdout.columns),
+      Math.max(20, (process.stdout.columns ?? 80) - 1),
       {},
       app.ui?.style,
     )) {
@@ -1880,1273 +1922,3 @@ export async function runTurn(
 // ---------------------------------------------------------------------------
 // TUI
 // ---------------------------------------------------------------------------
-
-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: 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();
-  private transcriptItems: TranscriptItem[] = [];
-  private historyNode = -1;
-  private historyDir = "";
-  private ancestors: LogEvent[] = [];
-  private historyLength = -1;
-  private liveMarkdown: MarkdownBlock | null = null;
-  private liveStyle: Style | null = null;
-  private readonly live: Container;
-  private readonly editorBox: Container;
-  private readonly footerBox: Container;
-  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;
-  toolsExpanded = false;
-  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" | "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 branch: string | null;
-
-  constructor(app: App, term?: Terminal) {
-    this.app = app;
-    this.historyDir = app.logDir;
-    this.noticeDir = app.logDir;
-    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.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.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 {
-    return this.app.ui?.style ?? ANSI;
-  }
-
-  get signal(): AbortSignal | undefined {
-    return this.abort?.signal;
-  }
-
-  writeLine(line: string): void {
-    if (this.noticeDir !== this.app.logDir) { this.chat.clear(); this.noticeDir = this.app.logDir; }
-    this.chat.addChild(new PiText(line, 0, 0));
-    this.paint();
-  }
-
-  dropLive(): void {
-    this.live.clear();
-    this.liveRows = 0;
-  }
-
-  private markdownStyle(): Style {
-    return this.app.io.palette.bold("\0") === "\0" ? IDENTITY : this.style;
-  }
-
-  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();
-    if (this.inflight) this.paintStream();
-    else this.paint();
-  }
-
-  commitStream(): void {
-    // A stream is never durable history. syncTranscript replaces it from the log.
-    this.clearStream();
-    this.paint();
-  }
-
-  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;
-    if (dir !== this.historyDir || node !== this.historyNode) {
-      const history = await readNodeHistory(dir, node);
-      if (!history.ok) {
-        this.chat.clear();
-        this.chat.addChild(new PiText("Cannot load complete session history: " + history.error, 0, 0));
-        this.paint();
-        return;
-      }
-      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);
-      this.historyDir = dir;
-      this.historyNode = node;
-      this.historyLength = -1;
-    }
-    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();
-  }
-
-  paintStream(): void {
-    this.rebuildLive();
-    this.rebuildChrome();
-    this.renderScreen();
-  }
-
-  paint(): void {
-    const colored = this.markdownStyle() !== IDENTITY;
-    this.editor.borderColor = thinkingBorderColor(this.app.providerConfig.effort, colored, this.style);
-    this.rebuildLive();
-    this.rebuildChrome();
-    this.renderScreen();
-  }
-
-  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();
-  }
-
-  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(
-        !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.markdownFeatures, true);
-      }
-      this.liveMarkdown.setText(this.streamText);
-      this.live.addChild(this.liveMarkdown);
-    }
-  }
-
-  private rebuildChrome(): void {
-    const inner = this.tree ?? this.select ?? this.settings ?? this.editor;
-    inner.setStyle(this.style);
-    inner.onInput = this.editor.onInput;
-    this.editorBox.clear();
-    this.editorBox.addChild(this.extensionUi.modal ?? inner);
-    if (!this.extensionUi.overlayFocused) this.screen.setFocus(this.extensionUi.modal ?? inner);
-    this.footerBox.clear();
-    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[] {
-    if (this.app.ui?.settings.statusBar === false) return [];
-    const attrs = { ...PLAIN_ATTRS, status: true };
-    return renderStatus(this.statusState(), width).map((line) => paint(line, attrs, this.style));
-  }
-
-  private statusState(): StatusState {
-    const s = this.app.session;
-    const budget = contextBudget({
-      frozen: s.config.frozen,
-      handoff: s.state.handoff,
-      events: s.state.events,
-      anchor: s.state.anchor,
-      atTurnBoundary: !this.inflight,
-      ...(s.config.counter ? { counter: s.config.counter } : {}),
-      ...(s.config.boundary ? { boundary: s.config.boundary } : {}),
-    });
-    const t = s.totals;
-    const cost = reportedCost(t, this.app.providerConfig.spec.price);
-    return {
-      cwd: this.app.workspace,
-      branch: this.branch,
-      tokens: budget.used,
-      triggerTokens: budget.trigger,
-      model: this.app.providerConfig.spec.id,
-      thinking: this.app.providerConfig.effort,
-      cut: budget.decision.cut,
-      reason: budget.decision.reason,
-      ...(this.sessionName ? { sessionName: this.sessionName } : {}),
-      home: homedir(),
-      inputTokens: t.input_tokens,
-      outputTokens: t.output_tokens,
-      cacheRead: t.cache_read_input_tokens,
-      cacheWrite: t.cache_creation_input_tokens,
-      ...(t.prompt_tokens > 0 ? { cacheHitRate: t.cache_hit_rate * 100 } : {}),
-      ...(cost.kind === "usd" ? { cost: cost.amount } : cost.kind === "partial" ? { cost: cost.known } : {}),
-      ...(this.queue.length > 0 ? { queued: this.queue.length } : {}),
-    };
-  }
-
-  openSettings(field?: string): void {
-    if (field !== undefined) { this.openSettingValues(field); return; }
-    const settings = this.app.ui?.settings;
-    this.settings = new Settings([
-      { 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(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([
-      ...(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.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.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 = 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();
-      return;
-    }
-    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 = modelKey(spec) === modelKey(this.app.providerConfig.spec);
-      items.push({
-        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: 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) => 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"));
-    this.paint();
-  }
-
-  openThinkingSelect(): void {
-    const spec = this.app.providerConfig.spec;
-    const current = this.app.providerConfig.effort;
-    const items: SelectItem[] = EFFORTS.map((level) => {
-      const supported = effortSupported(spec, level);
-      const here = level === current;
-      return {
-        value: level,
-        label: level,
-        description: !supported ? "unsupported" : here ? "now" : "",
-      };
-    });
-    this.select = new SelectList(items, { style: this.style, title: "Thinking", selectedValue: current, hint: "↑↓ select · Enter apply · Ctrl+S save default · Esc cancel" });
-    this.selectKind = "thinking";
-    this.onPick = async (item) => {
-      const effort = asEffort(item.value);
-      if (effort === undefined) return;
-      await applyThinking(this.app, effort, this);
-    };
-    this.paint();
-  }
-
-  private async saveSelectDefault(): Promise<void> {
-    if (this.select === null) return;
-    const item = this.select.state.items[this.select.state.selected];
-    if (item === undefined) return;
-    const C = this.app.io.palette;
-    if (this.selectKind === "model") {
-      // Patch only this key: dumping merged settings would freeze today's defaults.
-      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: 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;
-    }
-    if (this.selectKind === "thinking") {
-      const effort = asEffort(item.value);
-      if (!effort || !effortSupported(this.app.providerConfig.spec, effort)) {
-        this.app.io.say(C.yellow("  Cannot save an unsupported thinking level."));
-        return;
-      }
-      const patch = { modelThinkingLevels: { [modelKey(this.app.providerConfig.spec)]: effort } };
-      await writeUserSettings(patch);
-      if (this.app.ui !== undefined) {
-        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> {
-    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();
-  }
-
-  /**
-   * 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 nodes = await treeNodesFor(this.app);
-    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) => {
-      if (node.target === undefined) return;
-      if (this.inflight) { await this.settle(); this.returnQueueToEditor(); }
-      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;
-      this.app.io.say(C.green(`\n  conversation at node ${this.app.session.state.node}`));
-      this.app.io.say("");
-    };
-    this.paint();
-  }
-
-  async nextInput(): Promise<string> {
-    while (this.inputs.length === 0) {
-      await new Promise<void>((resolve) => { this.wake = resolve; });
-      this.wake = null;
-    }
-    return this.inputs.shift()!;
-  }
-
-  attach(): void {
-    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;
-    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> {
-    return new Promise((resolve) => {
-      this.app.io.say(approvalHeading(request));
-      this.select = new SelectList(approvalItems(request), { style: this.style, title: "Tool approval", search: false });
-      this.approvalResolve = resolve;
-      this.onPick = async (item) => {
-        resolve(choiceFromValue(item.value));
-      };
-      this.paint();
-    });
-  }
-
-  private boundAction(data: string): ActionId | undefined {
-    return Object.entries((this.app.ui?.keymap ?? defaultKeymap()).byKey)
-      .find(([chord]) => keyMatches(data, chord))?.[1];
-  }
-
-  private async openExternalEditor(): Promise<void> {
-    const attached = this.attached;
-    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: 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(); this.screen.requestRender(true); }
-      this.paint();
-    }
-  }
-
-  /** Programmatic compatibility; live stdin always enters as Pi raw input. */
-  async applyKey(key: Key): Promise<"continue" | "quit"> { return this.applyInput(encodeKey(key)); }
-
-  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) {
-      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 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;
-        this.onTreePick = null;
-        if (state.confirmed && pick) await pick(state.confirmed);
-      }
-      this.paint();
-      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, 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"); 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.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";
-    }
-    if (this.editor.autocompleteVisible && (keyMatches(data, "escape") || keyMatches(data, "up") || keyMatches(data, "down") || keyMatches(data, "tab"))) {
-      this.editor.acceptInput(data);
-      this.paint();
-      return "continue";
-    }
-    if (action === "app.clear") {
-      if (this.inflight) { this.abort?.abort(); this.returnQueueToEditor(); }
-      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 (action === "app.exit" && this.editor.state.text.length === 0 && this.pendingImages.length === 0) return "quit";
-    if (action === "app.interrupt") {
-      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.returnQueueToEditor(); this.paint(); return "continue"; }
-    if (action === "app.toggleTools") { this.toolsExpanded = !this.toolsExpanded; 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") { await cycleThinking(this.app, this); return "continue"; }
-    }
-    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();
-    return "continue";
-  }
-
-  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 && !this.pendingImages.length) return "continue";
-    const command = parseLine(this.app, line);
-    if (command.kind !== "prompt") {
-      if (this.inflight && commandDefinition(line)?.busy === "idle") {
-        this.app.io.say("  This command needs an idle session. Press Esc to interrupt the current turn first.");
-        this.editor.applyExternal(line);
-        return "continue";
-      }
-      const result = await handleLine(this.app, line, this);
-      await this.syncTranscript();
-      this.paint();
-      return result === "quit" ? "quit" : "continue";
-    }
-    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, images: readonly ImageRef[] = []): Promise<void> {
-    this.abort = new AbortController();
-    this.inflight = true;
-    this.executionKind = text.startsWith("!") ? "bash" : "model";
-    try {
-      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();
-      this.commitStream();
-      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();
-    }
-  }
-
-  /**
-   * 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<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();
-    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(item: QueuedMessage): Promise<UserInput | null> {
-    const text = item.text;
-    const needsIndex = fileReferences(text).length > 0;
-    const index: FileIndex = needsIndex
-      ? await fileIndexFor(this.app)
-      : { paths: [], truncated: false };
-    const expanded = await expandInput(text, {
-      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),
-    });
-    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 batch = this.nextBatch("turn_end");
-      if (!batch.length) break;
-      this.queue = this.queue.filter((m) => !batch.includes(m));
-      this.paintStream();
-      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);
-  }
-
-  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"));
-  }
-}