@visual-z/xeno 0.8.4 → 0.9.1

package/src/apps/shell.ts

@@ -1,2071 +0,0 @@
-/**
- * Interactive loop and one-shot runner.
- *
- * 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 { criterionSummary, draftGoal, pickCriteria, type PendingGoal } from "./goal-flow.ts";
-import { openImageFile } from "../runtime/open-image.ts";
-import { closeAppSession, switchAppSession } from "./session-lifecycle.ts";
-import { basename, dirname, join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { assertNever } from "../core/exhaustive.ts";
-import type { CounterVerdict } from "../core/acceptance.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 { 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 { fileReferences } from "../core/file-references.ts";
-import { readNodeHistory } from "../store/restore.ts";
-import type { Handoff } from "../core/handoff.ts";
-import { projectContext, type FrozenPrefix } from "../core/project.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, RequestOptions } from "../runtime/loop.ts";
-import { createProvider, providerSessionId, findModelByPattern, groupedModels, loadCatalog } from "../runtime/catalog.ts";
-import { outputTokenBudget, type Effort, type ModelSpec } from "../runtime/model.ts";
-import { scopedModels } from "../runtime/model-scope.ts";
-import { equivalentCost, reportedCost } from "../runtime/usage.ts";
-import type { ProviderConfig } from "../runtime/provider.ts";
-import { describeMissingCredential, envLabel, ensureFreshCredential, storedIsOAuth } from "../runtime/auth.ts";
-import {
-  SUBSCRIPTION_NOTICE, SUBSCRIPTION_OPTIONS, subscriptionById, loginGrok,
-  loginGitHubCopilot, generatePKCE, generateState, anthropicAuthorizeUrl, openaiCodexAuthorizeUrl,
-  startCallbackServer, exchangeAnthropicCode, exchangeOpenAICode, parseAuthorizationInput,
-  ANTHROPIC_CALLBACK_PORT, ANTHROPIC_CALLBACK_PATH, ANTHROPIC_REDIRECT_URI,
-  OPENAI_CALLBACK_PORT, OPENAI_CALLBACK_PATH, OPENAI_REDIRECT_URI,
-  type CallbackServer, type OAuthCredential, type SubscriptionId,
-} from "../runtime/oauth.ts";
-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 { projectTrust, trustPath } from "../store/trust.ts";
-import { discoverResources, themeResourcePath } from "../store/resource-index.ts";
-import { applyTrustChoice, type TrustChoice } from "./project-trust.ts";
-import { reloadAppResources } from "./resources.ts";
-import { publishModelCatalog } from "./model-catalog.ts";
-import { readCursor, writeCursor, listNodes, readNode, readManifest, setSessionLabel } from "../store/log.ts";
-import { registerSessionRoot } from "../store/session-browser.ts";
-import { createSession, findSessionByPrefix, hasConversation, listSessions, truncationNote, sessionsDir } from "../store/sessions.ts";
-import { exportSessionArchive, importSessionArchive } from "../store/session-archive.ts";
-import { resolveTuiMode } from "../core/tui-mode.ts";
-import { modelPreferencePatch, thinkingPreferencePatch } from "../core/model-preferences.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 { modelKey } from "../core/session-position.ts";
-import { defaultKeymap, listBindings } from "../core/keymap.ts";
-import { settingPatch } from "../core/settings.ts";
-import { resolveTheme } from "../store/resources.ts";
-import { commitUserSettings, type PreferenceOrigin } from "./preferences.ts";
-import { colorEnabled } from "./render.ts";
-import { createStyle, IDENTITY } from "../tui/style.ts";
-import { lastAssistantText, toHtml } from "../core/export.ts";
-import { toJsonEvent } from "../core/json-event.ts";
-import { sessionControl } from "../runtime/session-control.ts";
-import { hostExternalOptions, requestExternalEffects } from "../runtime/turn-effects.ts";
-import { formatExternalEffects } from "../core/external-effects.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, sessionToolCatalog, type App,
-} from "./startup.ts";
-import type { TurnSurface, Ui } from "./ui/surface.ts";
-import { runManualUpdate } from "./update-check.ts";
-import { presentQuestions } from "./question-ui.ts";
-import { bindAppWorkflow, setAppWorkflow } from "./workflow.ts";
-import { appReviewSnapshot, startReview, reviewScopeFromText } from "./review.ts";
-import { selectAppAgent, listAppAgents } from "./agent-profiles.ts";
-
-/**
- * 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 · /provider connects a provider · /model switches · /help`;
-const OAUTH_PASTE = "\0oauth";
-
-const initializedExtensions = new WeakSet<ExtensionRegistry>();
-const extensionHistories = new WeakMap<App, LogEvent[]>();
-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 ?? 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?.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(),
-    reload: async () => { if (app.session.running) throw new Error("Reload requires an idle session"); await reloadAppResources(app); await tui?.refreshResources(); },
-    newSession: async () => { await openNewSession(app, tui); await bindExtensions(app, tui); return { cancelled: false }; },
-    switchSession: async (path: string) => { const changed = await adoptLogDir(app, path); if (changed) { await bindExtensions(app, tui); await tui?.refreshResources(); } return { cancelled: !changed }; },
-    fork: async (id: string) => { const changed = await spawnForkedSession(app, id, "forked by extension", "before"); if (changed) await bindExtensions(app, tui); return { cancelled: !changed }; },
-    sessionManager: { getEntries: entries, getBranch: entries, getSessionId: () => basename(app.logDir), getSessionFile: () => app.logDir, getCwd: () => app.workspace },
-    modelRegistry: { getAll: () => [...app.catalog], getAvailable: () => app.catalog.filter(model => app.credentialOf(model).ok), find: (provider: string, id: string) => app.catalog.find(model => model.provider === provider && model.id === id) },
-  };
-}
-
-async function bindExtensions(app: App, tui?: Ui): Promise<void> {
-  bindAppWorkflow(app);
-  if (tui) {
-    const control = sessionControl(app.session);
-    control.questionSlot.current = (request, signal) => control.askQuestion(request, signal, current => presentQuestions(tui.extensionUi, current, signal));
-  }
-  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));
-  registry.bind({
-    context: () => extensionContext(app, tui),
-    append: async (entry, options) => {
-      if (entry.inContext && app.session.running) await app.session.whenIdle();
-      await app.session.appendExtension(entry); await tui?.syncTranscript();
-      if (options?.triggerTurn) { if (tui) tui.deliverExtension("Continue.", "followup"); else await run(app, "Continue."); }
-    },
-    user: async (text, options) => { if (tui) tui.deliverExtension(text, options?.deliverAs === "steer" ? "steering" : "followup"); else await run(app, text); },
-    setName: name => nameSession(app, name, tui),
-    setLabel: async (id, label) => { await setSessionLabel(app.logDir, id, label ?? "", app.session.clock.now()); },
-    getTools: () => 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 { 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.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), "session"); return app.providerConfig.spec.id === model.id && app.providerConfig.spec.provider === model.provider;
-    },
-    setThinking: async level => { await applyThinkingCommand(app, level, tui ?? null, "session"); },
-    exec: (command, args, options) => app.session.runExtensionCommand(command, args, options),
-  });
-  if (!initializedExtensions.has(registry)) {
-    initializedExtensions.add(registry);
-    const start = async () => { await registry.emit("session_start"); await registry.settle(); };
-    if (tui) tui.runExtensionAction(start); else await start();
-  }
-}
-
-function parseLine(app: App, text: string): Command {
-  const match = /^\/([^\s]+)(?:\s+([\s\S]*))?$/.exec(text.trim());
-  if (match && app.extensions?.commands.has(match[1]!)) return { kind: "extension", name: match[1]!, args: match[2] ?? "" };
-  return parseCommand(text, app.slash);
-}
-
-/**
- * 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. 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>;
-  readonly policy: ContextPolicy;
-  readonly contextWindow: number | undefined;
-  readonly outputReserve: number;
-}
-
-export interface ContextBudget {
-  readonly used: 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 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, 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;
-  const projected = projectContext({
-    frozen: input.frozen,
-    handoff: input.handoff,
-    events: input.events,
-    ...(input.logHint ? { logHint: input.logHint } : {}),
-  });
-  const { tokens, exactUpTo } = anchoredCount(
-    projected.messages,
-    projected.system,
-    input.anchor,
-    counter,
-    input.frozen.tools,
-  );
-  const floor = projectContext({
-    frozen: input.frozen,
-    handoff: input.handoff,
-    events: [],
-    ...(input.logHint ? { logHint: input.logHint } : {}),
-  });
-  const inherited = counter.count(floor.messages, floor.system, input.frozen.tools);
-  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: true,
-    ...(input.contextWindow === undefined ? {} : { contextWindow: input.contextWindow }),
-    outputReserve: input.outputReserve,
-    ...(input.boundary ? { config: input.boundary } : {}),
-  });
-  return {
-    used: tokens,
-    estimated: exactUpTo === 0,
-    trigger: nextBoundary(limits),
-    inherited,
-    limits,
-    decision,
-    level: gaugeLevel(tokens, limits, decision),
-  };
-}
-
-export function resolveEditorCommand(
-  env: { readonly [key: string]: string | undefined } = process.env,
-): string {
-  const visual = env["VISUAL"]?.trim();
-  if (visual !== undefined && visual.length > 0) return visual;
-  const editor = env["EDITOR"]?.trim();
-  if (editor !== undefined && editor.length > 0) return editor;
-  return "nano";
-}
-
-export type ExternalEditorResult =
-  | { ok: true; content: string }
-  | { ok: false; message: string };
-
-/**
- * The only I/O in the editor-completion card. applyKey stays pure; this
- * writes a temp file, runs $VISUAL/$EDITOR/nano, and deletes the file
- * whether the editor saved or :cq'd. A non-zero exit is a discard — vim's
- * :cq means "I do not want this" and stuffing the half-written file back
- * would turn a cancel into an edit.
- */
-export async function editInExternalEditor(input: {
-  readonly content: string;
-  readonly command: string;
-}): Promise<ExternalEditorResult> {
-  const dir = await mkdtemp(join(tmpdir(), "xeno-editor-"));
-  const filePath = join(dir, "prompt.md");
-  try {
-    await writeFile(filePath, input.content, "utf8");
-    const parts = input.command.trim().split(/\s+/).filter((p) => p.length > 0);
-    const bin = parts[0];
-    if (bin === undefined) {
-      return { ok: false, message: "external editor: no command; discarding changes" };
-    }
-    const proc = Bun.spawn([...parts, filePath], {
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-    });
-    const code = await proc.exited;
-    if (code !== 0) {
-      return { ok: false, message: `external editor exited ${code}; discarding changes` };
-    }
-    const content = await readFile(filePath, "utf8");
-    return { ok: true, content };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { ok: false, message: `external editor failed (${msg}); discarding changes` };
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
-
-/** Scan once per workspace: a glob on every @ is the stall the card rejected. */
-const fileIndexes = new Map<string, FileIndex>();
-const indexNotes = new Set<string>();
-
-async function fileIndexFor(app: App, refresh = false): Promise<FileIndex> {
-  const hit = fileIndexes.get(app.workspace);
-  if (!refresh && hit !== undefined) return hit;
-  const built = await buildFileIndex(app.workspace);
-  fileIndexes.set(app.workspace, built);
-  const note = indexTruncationNote(built);
-  if (note !== null && !indexNotes.has(app.workspace)) {
-    indexNotes.add(app.workspace);
-    app.io.say(app.io.palette.yellow(`  ${note}`));
-  }
-  return built;
-}
-
-export async function runPrompt(app: App, prompt: string): Promise<void> {
-  await bindExtensions(app);
-  if (app.shutdownRequested) { await closeAppSession(app); return; }
-  let ok: boolean;
-  try { ok = await run(app, prompt); }
-  finally { await closeAppSession(app); }
-  printUsage(app);
-  // One-shot mode is scriptable, so a failed turn has to be a failed exit.
-  if (!ok) process.exit(1);
-}
-
-export async function runRepl(app: App, releaseEarlyTty?: () => void): Promise<void> {
-  if (stdinIsTty() && stdoutIsTty()) {
-    await runTui(app, releaseEarlyTty);
-  } else {
-    await runLines(app);
-  }
-}
-
-async function runLines(app: App): Promise<void> {
-  await bindExtensions(app);
-  const C = app.io.palette;
-  if (app.ui?.settings.quietStartup !== true || app.args.verbose) app.io.say(C.dim(HINT));
-  /** Set by `/provider <provider>`; the next line typed is the key, not a prompt. */
-  let awaitingKeyFor: string | null = null;
-  for await (const line of console) {
-    const text = line.trim();
-    if (awaitingKeyFor !== null) {
-      const provider = awaitingKeyFor;
-      awaitingKeyFor = null;
-      if (text.length === 0) {
-        if (provider === OAUTH_PASTE) await cancelPendingOAuth(app);
-        app.io.say(C.dim("  cancelled\n"));
-        continue;
-      }
-      if (provider === OAUTH_PASTE) {
-        if (!pendingLogins.has(app) || pendingLogins.get(app)?.done) {
-          const outcome = await execute(app, parseLine(app, text), null);
-          if (outcome === "quit") break;
-          if (typeof outcome === "object") awaitingKeyFor = outcome.login;
-          continue;
-        }
-        await completeOAuthPaste(app, text);
-        continue;
-      }
-      await login(app, provider, text);
-      continue;
-    }
-    if (!text) continue;
-    const outcome = await execute(app, parseLine(app, text), null);
-    if (outcome === "quit" || app.shutdownRequested) break;
-    if (typeof outcome === "object") awaitingKeyFor = outcome.login;
-  }
-  await cancelPendingOAuth(app);
-  await closeAppSession(app);
-  printUsage(app);
-}
-
-async function runTui(app: App, releaseEarlyTty?: () => void): Promise<void> {
-  if (!app.args.noSession) await registerSessionRoot({ path: dirname(app.logDir), workspace: app.workspace }).catch(error => app.io.say(String(error)));
-  // 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, options?: RequestOptions) =>
-    run(app, prompt, signal, ui, images, skill, options),
-  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); },
-  /** Show a stored image in the system viewer; resolves to why it could not, or null. */
-  openImage: (app: App, sha256: string) => openImageFile(app.blobDir, sha256),
-};
-
-type Outcome = "continue" | "quit" | { login: string };
-
-async function execute(app: App, command: Command, tui: Ui | null): Promise<Outcome> {
-  switch (command.kind) {
-    case "workflow":
-      await setAppWorkflow(app, command.mode); app.io.say(`  Workflow: ${command.mode}`); await tui?.refreshResources(); return "continue";
-    case "agent":
-      if (command.name) { await selectAppAgent(app, command.name); await bindExtensions(app, tui ?? undefined); await tui?.refreshResources(); }
-      else app.io.say(await listAppAgents(app)); return "continue";
-    case "mcp": {
-      const manager = app.foundation?.mcp; if (!manager) throw Error("MCP resources are unavailable");
-      if (command.action === "status") app.io.say(JSON.stringify(manager.status(), null, 2));
-      else {
-        if (!command.name) throw Error(`Use /mcp ${command.action} <server>`);
-        if (command.action === "login") await manager.login(command.name, url => { app.io.say(`  Complete MCP login: ${url.href}`); }, tui?.signal);
-        else await manager.logout(command.name);
-        await reloadAppResources(app); await bindExtensions(app, tui ?? undefined); await tui?.refreshResources();
-      }
-      return "continue";
-    }
-    case "diff": { const snapshot = await appReviewSnapshot(app, reviewScopeFromText(command.args), tui?.signal); app.io.say(`${snapshot.label}\n${snapshot.diff || "(no captured changes)"}\n${snapshot.limitations.join("\n")}`); return "continue"; }
-    case "review": {
-      // A background branch (feat-review-branch): the parent stays usable; the result joins when it ends.
-      const node = await startReview(app, reviewScopeFromText(command.args));
-      app.io.say(`Review running as branch ${node}. Keep working; its findings join this session when it ends.${tui ? " ↓ from the prompt shows it." : " /branches inspects it."}`);
-      await tui?.syncTranscript(); return "continue";
-    }
-    case "extension":
-      if (tui) tui.runExtensionCommand(command.name, command.args);
-      else { await bindExtensions(app); await app.extensions?.command(command.name, command.args); }
-      return "continue";
-    case "attachments":
-      if (tui) tui.openAttachments();
-      else app.io.say("Attachments are edited in the interactive prompt.");
-      return "continue";
-    case "quit":
-      return "quit";
-    case "usage":
-      printUsage(app);
-      return "continue";
-    case "state":
-      await printState(app);
-      return "continue";
-    case "control":
-      if (tui) await tui.openControl();
-      else app.io.say(JSON.stringify(await sessionControl(app.session).snapshot(), null, 2));
-      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 "goal":
-      await goalCommand(app, command, tui ?? undefined);
-      return "continue";
-    case "help":
-      printHelp(app);
-      return "continue";
-    case "hotkeys":
-      printHotkeys(app);
-      return "continue";
-    case "settings":
-      return applySettingsCommand(app, command.field, command.value, tui);
-    case "reload": {
-      const cut = await reloadAppResources(app);
-      if (tui) await tui.refreshResources(); else await bindExtensions(app);
-      app.io.say(app.io.palette.green(`  Resources reloaded${cut ? " at a context checkpoint" : ""}`));
-      return "continue";
-    }
-    case "config":
-      if (tui) await tui.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}`);
-      }
-      return "continue";
-    case "session":
-      await printSession(app);
-      return "continue";
-    case "model":
-      if (command.pattern !== undefined) {
-        await switchByPattern(app, command.pattern);
-        return "continue";
-      }
-      if (tui) {
-        tui.openModel();
-        return "continue";
-      }
-      printModels(app);
-      return "continue";
-    case "scoped-models":
-      if (tui) tui.openScopedModels();
-      else app.io.say((app.ui?.settings.scopedModels ?? app.catalog.filter(spec => app.credentialOf(spec).ok).map(modelKey)).join("\n"));
-      return "continue";
-    case "thinking":
-      return applyThinkingCommand(app, command.level, tui);
-    case "login": {
-      if (command.provider === undefined) {
-        if (tui) { tui.openLogin(); return "continue"; }
-        const C = app.io.palette;
-        const providers = [...new Set(app.catalog.map((m) => m.provider))].filter(provider => !subscriptionById(provider));
-        app.io.say(C.bold("\nproviders"));
-        app.io.say(C.bold("  API keys"));
-        for (const p of providers) {
-          app.io.say(`  ${p.padEnd(12)}${C.dim(envLabel(p))}`);
-        }
-        app.io.say(C.bold("  Subscriptions"));
-        for (const s of SUBSCRIPTION_OPTIONS) {
-          app.io.say(`  ${s.id.padEnd(16)}${C.dim(s.label)}`);
-        }
-        app.io.say(C.dim("\n  /provider <provider> then paste the key. Empty line cancels."));
-        app.io.say(C.dim(`  /provider ${SUBSCRIPTION_OPTIONS.map(option => option.id).join("|")} starts an account login.\n`));
-        return "continue";
-      }
-      const subscription = subscriptionById(command.provider);
-      if (subscription) {
-        return startSubscriptionLogin(app, subscription.id, tui);
-      }
-      if (!app.catalog.some(model => model.provider === command.provider)) { app.io.say(app.io.palette.red(`  unknown provider: ${command.provider}. Use /provider to choose one.`)); return "continue"; }
-      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;
-      // 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.openLogout(); return "continue"; }
-      await logout(app, command.provider);
-      return "continue";
-    }
-    case "back": {
-      if (command.arg === undefined) { await printBack(app); return "continue"; }
-      const points = await app.session.restorePoints();
-      const i = Number(command.arg);
-      const point = Number.isInteger(i) ? points[i - 1] : undefined;
-      if (!point) {
-        app.io.say(app.io.palette.red(`  no such point: ${command.arg}. /back lists them.`));
-        return "continue";
-      }
-      await printRewind(app, point, command.mode, command.confirm);
-      await tui?.syncTranscript();
-      return "continue";
-    }
-    case "tree":
-      if (tui) {
-        await tui.openTree();
-        return "continue";
-      }
-      await printTree(app);
-      return "continue";
-    case "new":
-      await openNewSession(app, tui ?? undefined);
-      return "continue";
-    case "resume":
-      if (command.id !== undefined) {
-        await resumeSession(app, command.id, tui ?? undefined);
-        return "continue";
-      }
-      if (tui) {
-        void tui.openResume();
-        return "continue";
-      }
-      await printSessionList(app);
-      return "continue";
-    case "name":
-      await nameSession(app, command.name, tui ?? undefined);
-      return "continue";
-    case "export":
-      await exportSession(app, command.file);
-      return "continue";
-    case "import": {
-      if (!command.file) { app.io.say("  Usage: /import <session.jsonl>"); return "continue"; }
-      const importing = async () => {
-        if (tui && !await tui.confirm("Import session", "Open the archive as a separate session? The current session stays saved.")) { app.io.say("  Import cancelled"); return; }
-        try {
-          const path = await importSessionArchive(resolve(app.workspace, command.file!), sessionsDir(app.workspace, sessionDirFor(app.args, app.workspace)), app.workspace);
-          if (await adoptLogDir(app, path)) { await bindExtensions(app, tui ?? undefined); await tui?.refreshResources(); await tui?.syncTranscript(); app.io.say(`  Imported session: ${path}`); }
-        } catch (error) { app.io.say(app.io.palette.red(`  Cannot import: ${describeError(error)}`)); }
-      };
-      if (tui) tui.runSessionTransition(importing); else await importing();
-      return "continue";
-    }
-    case "debug": {
-      const file = resolve(app.workspace, command.file ?? join(configDir(), "debug.log"));
-      const 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}] ${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("Changelog", text); else app.io.say(text);
-      return "continue";
-    }
-    case "update":
-      if (tui) tui.checkForUpdate();
-      else await runManualUpdate({ offline: app.args.offline === true, install: true }, app.io.say);
-      return "continue";
-    case "copy":
-      await copyLastReply(app, tui ?? undefined);
-      return "continue";
-    case "fork":
-      if (tui && command.arg === undefined) { await tui.openFork(); return "continue"; }
-      await forkSession(app, command.arg, tui ?? undefined);
-      return "continue";
-    case "clone":
-      await cloneSession(app);
-      await tui?.syncTranscript();
-      return "continue";
-    case "trust":
-      if (command.target) await trustProject(app, command.target, tui ?? undefined);
-      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":
-      await refreshModels(app);
-      return "continue";
-    case "unknown":
-      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, [], command.skill);
-      app.io.say("");
-      return "continue";
-    default:
-      return assertNever(command, "execute");
-  }
-}
-
-async function handleLine(app: App, text: string, tui: Ui): Promise<Outcome> {
-  return execute(app, parseLine(app, text), tui);
-}
-
-/**
- * S.2 / S.5. Line mode keeps a drafted goal until `/goal accept` names the
- * criteria to keep; the TUI asks with a checklist instead.
- */
-const pendingGoals = new WeakMap<App, PendingGoal>();
-
-async function goalCommand(app: App, command: Extract<Command, { kind: "goal" }>, tui?: Ui): Promise<void> {
-  const C = app.io.palette;
-  switch (command.action) {
-    case "status": await printGoal(app); return;
-    case "clear": app.io.say(await app.session.clearGoal() ? C.green("  goal cleared") : C.dim("  no active goal")); return;
-    case "set": {
-      if (tui) { tui.startGoal(command.objective); return; }
-      const drafted = await draftGoal(app, command.objective, (prompt, options) => run(app, prompt, undefined, undefined, [], undefined, options));
-      if (!drafted) return;
-      pendingGoals.set(app, drafted);
-      app.io.say(C.bold("\ndrafted criteria") + C.dim("  (accept with /goal accept all, or /goal accept 1,3)"));
-      drafted.criteria.forEach((item, index) => app.io.say(`  ${index + 1}. ${item.id} · ${criterionSummary(item)}`));
-      return;
-    }
-    case "accept": {
-      const drafted = pendingGoals.get(app);
-      if (!drafted) { app.io.say(C.yellow("  no drafted goal; run /goal <objective> first")); return; }
-      const picked = pickCriteria(drafted.criteria, command.pick);
-      if (!picked.ok) { app.io.say(C.yellow(`  ${picked.error}`)); return; }
-      pendingGoals.delete(app);
-      await app.session.setGoal({ ...drafted, accepted: picked.ids });
-      app.io.say(C.green(`  goal set with ${picked.ids.length} accepted criteria`));
-      await run(app, drafted.objective);
-      await printGoal(app);
-      return;
-    }
-    default: return assertNever(command, "goal command");
-  }
-}
-
-async function printGoal(app: App): Promise<void> {
-  const C = app.io.palette, goal = await app.session.goal();
-  if (!goal) { app.io.say(C.dim("  no active goal; /goal <objective> drafts one")); return; }
-  const request = await app.session.requestState();
-  const current = request?.acceptance?.contract_id === goal.contract.id ? request : undefined;
-  app.io.say(C.bold("\ngoal") + `  ${goal.objective}`);
-  for (const item of goal.contract.criteria) {
-    const criterion = current?.criteria.find(entry => entry.id === item.id), status = criterion?.status ?? "not_run";
-    const guard = item.kind === "command" && item.guard === true;
-    app.io.say(`  ${status === "pass" || status === "accepted" ? C.green("✓") : C.yellow("○")} ${item.id}${guard ? " (guard)" : ""} · ${status} · ${item.description}` +
-      (criterion?.counter ? counterSuffix(C, criterion.counter) : ""));
-  }
-  for (const blocker of current?.reported_blockers ?? []) app.io.say(C.yellow(`  reported blocker: ${blocker.reason}`));
-  if (current && current.evidence.independent !== "not_applicable") app.io.say(`  blind checks      ${current.evidence.independent}`);
-}
-
-/** One counter-check verdict after a criterion, in the words of its role (S.7). */
-function counterSuffix(C: App["io"]["palette"], verdict: CounterVerdict): string {
-  switch (verdict) {
-    case "vacuous": return C.yellow(" · also passes without the changes; it does not test them");
-    case "discriminating": return C.green(" · fails without the changes");
-    case "held": return C.green(" · held before the changes too");
-    case "not_held": return C.dim(" · did not hold before the changes; it tests them rather than guarding");
-    case "unavailable": return C.dim(" · counter-check unavailable");
-    default: return assertNever(verdict, "counter verdict");
-  }
-}
-
-function printUsage(app: App): void {
-  const C = app.io.palette;
-  const t = app.session.totals;
-  const spec = app.session.provider.config.spec;
-  const rates = spec.rates;
-  app.io.say(C.bold("\nusage"));
-  app.io.say(`  requests          ${t.requests}`);
-  app.io.say(`  prompt tokens     ${t.prompt_tokens.toLocaleString()}`);
-  app.io.say(`    uncached        ${t.input_tokens.toLocaleString()}`);
-  if (rates === undefined) {
-    app.io.say(`    cache write     ${t.cache_creation_input_tokens.toLocaleString()}  (unknown)`);
-    app.io.say(`    cache read      ${t.cache_read_input_tokens.toLocaleString()}  (unknown)`);
-  } else {
-    // The multiples come from the model that actually ran. They used to be
-    // Anthropic's, printed verbatim beside a DeepSeek total, where the write
-    // rate is 0 and the read rate is a third of what the label claimed.
-    app.io.say(
-      `    cache write     ${t.cache_creation_input_tokens.toLocaleString()}  ` +
-        `(${rates.write}x${rates.write === 0 ? ", not billed" : ""})`,
-    );
-    app.io.say(`    cache read      ${t.cache_read_input_tokens.toLocaleString()}  (${rates.read.toFixed(3)}x)`);
-  }
-  app.io.say(`  output tokens     ${t.output_tokens.toLocaleString()}`);
-  const rate = (t.cache_hit_rate * 100).toFixed(1);
-  const rateColour = t.cache_hit_rate > 0.7 ? C.green : t.cache_hit_rate > 0.3 ? C.yellow : C.red;
-  app.io.say(`  cache hit rate    ${rateColour(rate + "%")}`);
-  if (rates !== undefined) {
-    const cost = equivalentCost(t, rates);
-    app.io.say(
-      `  input equivalent  ${Math.round(cost.input_equivalent).toLocaleString()} ` +
-        C.dim(`(vs ${Math.round(cost.uncached_equivalent).toLocaleString()} uncached, ` +
-          `${cost.savings_ratio.toFixed(2)}x saved)`),
-    );
-  }
-  const dollars = reportedCost(t, spec.price);
-  if (dollars.kind === "unknown") {
-    app.io.say(`  cost              unknown`);
-  } else if (dollars.kind === "usd") {
-    app.io.say(`  cost              $${dollars.amount.toFixed(4)}`);
-  } else if (dollars.kind === "partial") {
-    // `known` is not a complete bill. Printing it on the usd path would
-    // look like cache had been free.
-    app.io.say(`  cost              $${dollars.known.toFixed(4)}  (cache not counted)`);
-  } else {
-    return assertNever(dollars, "printUsage");
-  }
-  app.io.say(`  model time        ${(t.ms / 1000).toFixed(1)}s`);
-  app.io.say("");
-}
-
-async function printState(app: App): Promise<void> {
-  const C = app.io.palette;
-  const s = app.session.state;
-  app.io.say(C.bold("\nstate"));
-  app.io.say(`  node              ${s.node}  (depth ${s.depth})`);
-  app.io.say(`  events in node    ${s.events.length}`);
-  const request = await app.session.requestState();
-  if (request) {
-    app.io.say(`  request           ${request.request.event} · ${request.status}`);
-    app.io.say(`  execution         ${request.execution?.reason ?? "in progress or unknown"}`);
-    app.io.say(`  command evidence  ${request.commands.filter(command => command.status === "pass").length} current passes / ${request.commands.length} receipts`);
-    app.io.say(`  observations      ${request.progress.observations.length} new; artifact changes ${request.progress.artifact_changes.length}; acceptance advances ${request.progress.acceptance_advances.length}`);
-    app.io.say(`  diagnostics       ${request.progress.new_diagnostics.length} new; unchanged retries ${request.progress.unchanged_retries.length}; unknown ${request.progress.unknown_diagnostics.length}`);
-    app.io.say(`  evidence          ran ${request.evidence.ran} · discriminating ${request.evidence.discriminating} · independent ${request.evidence.independent} · human ${request.evidence.human}`);
-    for (const gap of request.unmet) app.io.say(`  unmet             ${gap}`);
-    for (const blocker of request.reported_blockers) app.io.say(`  reported blocker  ${blocker.reason}`);
-    if (!request.acceptance) app.io.say("  task verification no declared contract; a fresh check shows only that the changes ran, not that the request was met");
-  }
-  if (s.handoff) {
-    const h = s.handoff;
-    app.io.say(`  completed         ${h.state.completed.length}`);
-    app.io.say(`  unverified        ${h.state.unverified_claims.length}`);
-    app.io.say(`  in flight         ${h.state.in_flight.length}`);
-    app.io.say(`  blocked           ${h.state.blocked.length}`);
-    app.io.say(
-      `  gates             ${h.verification.map((v) => `${v.gate}=${v.status}`).join(" ") || "none"}`,
-    );
-    app.io.say(`  no progress for   ${h.budget.nodes_without_progress} node(s)`);
-  } else {
-    app.io.say(C.dim("  no handoff yet (still in the first node)"));
-  }
-  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.kind === "command" && item.guard ? " (guard)" : ""}: ${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();
-  const enabled = app.session.config.frozen.tools.length;
-  app.io.say(C.bold("\nhotkeys"));
-  app.io.say(`  tools enabled               ${enabled}`);
-  for (const row of listBindings(map)) {
-    app.io.say(`  ${row.action.padEnd(28)}${row.keys.join(", ")}`);
-  }
-  app.io.say("");
-}
-
-async function applySettingsCommand(
-  app: App,
-  field: string | undefined,
-  value: string | undefined,
-  tui: Ui | null,
-): Promise<Outcome> {
-  if (field !== undefined && value !== undefined) {
-    await commitSetting(app, field, value, tui);
-    return "continue";
-  }
-  if (tui) {
-    tui.openSettings(field);
-    return "continue";
-  }
-  const s = app.ui?.settings;
-  app.io.say(app.io.palette.bold("\nsettings"));
-  app.io.say(`  theme             ${s?.theme ?? "dark"}`);
-  app.io.say(`  thinking          ${s?.thinking ?? app.providerConfig.effort}`);
-  app.io.say(app.io.palette.dim("  /settings <theme|thinking> <value> to change; /settings alone opens every option.\n"));
-  return "continue";
-}
-
-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) {
-    app.io.say(C.yellow("  settings are not available in this session"));
-    return;
-  }
-  if (key === "thinking") {
-    const effort = asEffort(value);
-    if (effort) await applyThinking(app, effort, tui);
-    return;
-  }
-  const parsed = settingPatch(field, value);
-  if (parsed.diagnostics.length) { app.io.say(C.yellow(parsed.diagnostics.join("\n"))); return; }
-  if (key === "theme") {
-    const diagnostics: string[] = [];
-    const theme = await resolveTheme(app.resources ? themeResourcePath(app.resources, value) ?? value : value, diagnostics);
-    if (diagnostics.length) { app.io.say(C.yellow(diagnostics.join("\n"))); return; }
-    app.ui.theme = theme;
-    app.ui.style = colorEnabled() ? createStyle(theme.colors) : IDENTITY;
-  }
-  const saved = await commitUserSettings(app, parsed.settings);
-  if (saved && key === "enableskillcommands") { await reloadAppResources(app); await tui?.refreshResources(); }
-  if (saved) {
-    if (tui) tui.toast(`${field} · ${value}`, "success");
-    else app.io.say(C.dim(`  ${field} ${value}`));
-  }
-  tui?.applyConfiguration();
-  if (key === "theme") tui?.followTheme();
-  tui?.redraw();
-}
-
-const EFFORTS = THINKING_LEVELS;
-
-/** Explicit user choices are refused; automatic model changes use the pure clamp policy. */
-function effortSupported(spec: ModelSpec, level: Effort): boolean {
-  return supportedThinkingLevels(spec).includes(level);
-}
-
-/**
- * Effort is a request parameter on the current provider. Switching it
- * 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: Ui | null, origin: PreferenceOrigin = "user"): Promise<boolean> {
-  const C = app.io.palette;
-  if (!effortSupported(app.providerConfig.spec, level)) {
-    app.io.say(
-      C.yellow(
-        `  ${level} is not supported by ${app.providerConfig.spec.id}; thinking unchanged`,
-      ),
-    );
-    return false;
-  }
-  app.providerConfig = { ...app.providerConfig, effort: level };
-  if (app.credential.ok) {
-    app.session.provider = makeProvider(app, app.providerConfig, app.credential.key);
-  }
-  await app.session.setThinking(level);
-  if (app.ui !== undefined) {
-    app.ui.settings = { ...app.ui.settings, thinking: level };
-  }
-  if (origin === "user") await commitUserSettings(app, thinkingPreferencePatch(app.providerConfig.spec, level));
-  app.io.say(C.dim(`  thinking ${level}`));
-  tui?.redraw();
-  return true;
-}
-
-async function applyThinkingCommand(app: App, level: string | undefined, tui: Ui | null, origin: PreferenceOrigin = "user"): Promise<Outcome> {
-  if (level !== undefined) {
-    const effort = asEffort(level);
-    if (effort === undefined) {
-      app.io.say(app.io.palette.yellow("  thinking must be " + THINKING_LEVELS.join("|")));
-      return "continue";
-    }
-    await applyThinking(app, effort, tui, origin);
-    return "continue";
-  }
-  if (tui) {
-    tui.openThinking();
-    return "continue";
-  }
-  printThinking(app);
-  return "continue";
-}
-
-function printThinking(app: App): void {
-  const C = app.io.palette;
-  const spec = app.providerConfig.spec;
-  app.io.say(C.bold("\nthinking"));
-  for (const level of EFFORTS) {
-    const supported = effortSupported(spec, level);
-    const here = level === app.providerConfig.effort;
-    const mark = !supported ? C.dim("  -- ") : here ? C.cyan(" now ") : C.green("    ");
-    const note = supported ? "" : C.dim("  unsupported");
-    app.io.say(`  ${mark}  ${level}${note}`);
-  }
-  app.io.say(C.dim("\n  /thinking <level> to switch. Shift+Tab cycles supported levels.\n"));
-}
-
-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;
-  await applyThinking(app, next, tui);
-}
-
-async function cycleScopedModel(app: App, dir: 1 | -1): Promise<void> {
-  const C = app.io.palette;
-  const fromFlag = splitModelPatterns(app.args.models);
-  const names = app.args.modelsExplicit || fromFlag.length > 0 ? fromFlag : app.ui?.settings.scopedModels ?? app.catalog.filter(spec => app.credentialOf(spec).ok).map(modelKey);
-  if (names.length === 0) {
-    app.io.say(C.dim("  no scoped models. Pass --models a,b or set scopedModels."));
-    return;
-  }
-  const scope = scopedModels(names, app.catalog.filter(spec => app.credentialOf(spec).ok));
-  for (const message of scope.diagnostics) app.io.say(C.yellow(`  ${message}`));
-  const ids = scope.entries.map(entry => modelKey(entry.model));
-  if (ids.length === 0) {
-    app.io.say(C.yellow("  --models matched nothing"));
-    return;
-  }
-  const next = cycle(ids, modelKey(app.providerConfig.spec), dir);
-  if (next === undefined) return;
-  const selected = scope.entries.find(entry => modelKey(entry.model) === next)!;
-  await switchToModel(app, selected.model, selected.thinking);
-}
-
-function printHelp(app: App): void {
-  const C = app.io.palette;
-  app.io.say(C.bold("\ncommands"));
-  for (const command of COMMANDS) {
-    const hint = "argumentHint" in command ? ` ${command.argumentHint}` : "";
-    app.io.say(`  /${(command.name + hint).padEnd(34)} ${command.description}`);
-  }
-  for (const [name, command] of app.extensions?.commands ?? []) app.io.say(`  /${name.padEnd(34)} ${command.description ?? "Extension command"}`);
-  app.io.say('  @file or @"file name"  attach a project file anywhere in the prompt');
-  app.io.say("  !cmd              run in the workspace and send stdout/stderr/exit to the model");
-  app.io.say("  !!cmd             run without sending output");
-  app.io.say("");
-}
-
-async function printSession(app: App): Promise<void> {
-  const C = app.io.palette;
-  const cursor = await readCursor(app.logDir);
-  app.io.say(C.bold("\nsession"));
-  app.io.say(`  id                ${basename(app.logDir)}`);
-  app.io.say(`  name              ${cursor?.name ?? "(unnamed)"}`);
-  app.io.say(`  path              ${app.logDir}`);
-  app.io.say(`  node              ${app.session.state.node}`);
-  app.io.say(`  events            ${app.session.state.events.length}`);
-  app.io.say(`  model             ${app.providerConfig.spec.id}`);
-  printUsage(app);
-}
-
-async function printSessionList(app: App): Promise<void> {
-  const C = app.io.palette;
-  const { sessions, truncated } = await listSessions(app.workspace, sessionDirOf(app), Infinity);
-  const note = truncationNote(truncated);
-  app.io.say(C.bold("\nsessions"));
-  if (note) app.io.say(C.yellow(`  ${note}`));
-  if (sessions.length === 0) {
-    app.io.say(C.dim("  none yet -- /new starts one"));
-    app.io.say("");
-    return;
-  }
-  for (const s of sessions) {
-    if (!s.ok) {
-      app.io.say(C.red(`  ${s.id}  unreadable  ${s.error}`));
-      continue;
-    }
-    // A session left without a word is noise here; the current one stays (fix-skip-empty-sessions).
-    if (s.path !== app.logDir && !await hasConversation(s.path)) continue;
-    const here = s.path === app.logDir ? C.cyan(" now ") : "     ";
-    const label = (s.name ?? s.id).padEnd(24);
-    app.io.say(`  ${here} ${label}${C.dim(`${s.events} events  ${s.model ?? ""}`)}`);
-  }
-  app.io.say(C.dim("\n  /resume <id> to switch\n"));
-}
-
-/**
- * Lists somewhere to go back to, newest last, numbered for typing.
- *
- * Numbered rather than addressed by node and event id: the address is an
- * implementation detail and nobody can type `e00017`. The numbering is of
- * the list as printed, so it is re-read on every command rather than
- * remembered -- a rewind changes the ancestry and with it the list.
- */
-async function printBack(app: App): Promise<void> {
-  const C = app.io.palette;
-  const points = await app.session.restorePoints();
-  app.io.say(C.bold("\nsomewhere to go back to") + C.dim("  (newest last)"));
-  if (points.length === 0) {
-    app.io.say(C.dim("  nothing yet -- no exchange has changed a file"));
-  }
-  points.forEach((p, i) => {
-    const n = String(i + 1).padStart(2);
-    const files = `${p.changed} file${p.changed === 1 ? "" : "s"}`;
-    // Off-path entries are branches this session has left, usually by
-    // rewinding. Listed, because a node that survives on disk and cannot be
-    // found again is lost in every sense that matters to a person.
-    const mark = p.onPath ? "  " : C.yellow("↩ ");
-    app.io.say(`  ${C.bold(n)} ${mark} ${C.dim(files.padEnd(9))}${firstLine(p.prompt, 60)}`);
-  });
-  if (points.some((p) => !p.onPath)) {
-    app.io.say(C.dim(`\n  ${C.yellow("↩")} left behind by an earlier /back -- still reachable`));
-  }
-  app.io.say(C.dim("\n  /back <n>            move the files and the conversation"));
-  app.io.say(C.dim("  /back <n> files      move the files, keep what was learned"));
-  app.io.say(C.dim("  /back <n> context    move the conversation, keep the code"));
-  // Restated from the write-ups rather than left for the person to work
-  // out, because picking wrong is how a rewind makes things worse: the
-  // documented trap is keeping bad code with no memory of writing it.
-  app.io.say(C.dim("\n  code broken + model confused -> plain /back"));
-  app.io.say(C.dim("  code broken, model was right -> files"));
-  app.io.say(C.dim("  code fine, model went wrong   -> context\n"));
-}
-
-/**
- * Non-tty /tree: the same layout as the live view, committed to scrollback.
- * Jumping still needs the TUI; this is so a pipe can see the structure.
- */
-async function printTree(app: App): Promise<void> {
-  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));
-  }
-}
-
-async function treeNodesFor(app: App): Promise<TreeNode[]> {
-  const parents = await loadNodeParents(app.logDir);
-  const manifest = await readManifest(app.logDir);
-  const history = await readNodeHistory(app.logDir, app.session.state.node);
-  if (!history.ok) throw new Error(history.error);
-  const onPath = new Set(history.nodes.flatMap(n => n.events.map(e => `${n.node}:${e.id}`)));
-  const points: TreePoint[] = [];
-  for (const node of parents.keys()) {
-    const { events, corrupt } = await readNode(app.logDir, node);
-    if (corrupt.length) throw new Error("Cannot display corrupt session events");
-    for (const event of events) {
-      const content = event.t === "user" ? [event.text, ...(event.images ?? []).map(i => `[Image: ${i.name}]`)].filter(Boolean).join("\n") :
-        event.t === "assistant" ? event.blocks.map(b => b.type === "tool_use" ? `tool · ${b.name} ${JSON.stringify(b.input)}` : `${b.type === "thinking" ? "thinking · " : ""}${b.text}`).join("\n") :
-        event.t === "tool_result" ? event.content : event.t === "user_bash" ? `$ ${event.command}\n${event.content}` :
-        event.t === "cut" ? `context boundary · ${event.reason}` : JSON.stringify(event);
-      const tool = event.t === "tool_result" || event.t === "user_bash" || event.t === "assistant" && event.blocks.every(b => b.type === "tool_use");
-      const category = tool ? "tool" : event.t === "user" || event.t === "assistant" ? "message" : "metadata";
-      const label = manifest.labels?.[event.id];
-      points.push({ node, atEvent: event.id, target: event.id, prompt: `${event.t === "user" ? "" : event.t === "assistant" ? "assistant · " : `${event.t} · `}${firstLine(content, 160)}`,
-        onPath: onPath.has(`${node}:${event.id}`), kind: event.t === "user" ? "user" : "other", category, content, at: event.at,
-        ...(label ? { label: label.text, labelAt: label.at } : {}) });
-    }
-  }
-  return treeFromPoints(points, parents, app.session.state.node);
-}
-
-async function loadNodeParents(logDir: string): Promise<Map<number, NodeParent>> {
-  const map = new Map<number, NodeParent>();
-  for (const id of await listNodes(logDir)) {
-    const { header } = await readNode(logDir, id);
-    if (header === null) continue;
-    if (header.parent === null) {
-      map.set(id, null);
-      continue;
-    }
-    map.set(
-      id,
-      header.parent.at_event === undefined
-        ? { node: header.parent.node }
-        : { node: header.parent.node, at_event: header.parent.at_event },
-    );
-  }
-  return map;
-}
-
-/**
- * Goes back: the files and the conversation move together.
- *
- * Preview first, always. The half of this that nobody asked for is the
- * deletion of everything the target did not have -- including a file a
- * person wrote by hand while the session sat idle -- and that half is
- * invisible in the request.
- */
-async function printRewind(
-  app: App,
-  point: RestorePoint,
-  mode: RewindMode,
-  confirmed: boolean,
-): Promise<void> {
-  const C = app.io.palette;
-  const label = firstLine(point.prompt, 60);
-  const plan = await app.session.previewRewind(point, mode);
-  if (!plan.ok) {
-    app.io.say(C.red(`\n  cannot go back: ${plan.error}\n`));
-    return;
-  }
-
-  const what =
-    mode === "both" ? "the files and the conversation"
-    : mode === "files" ? "the files only"
-    : "the conversation only";
-  app.io.say(C.bold("\ngo back to") + `  ${label}` + C.dim(`  (${what})`));
-
-  if (mode === "context") {
-    // Nothing on disk changes, so listing what the target HAD would read
-    // like a plan to write it. What matters is the gap the model is about
-    // to be told about.
-    const extra = plan.willDelete;
-    app.io.say(C.dim(`    no file is touched`));
-    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(`    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`));
-  }
-
-  if (!confirmed) {
-    app.io.say(C.yellow('\n  nothing changed. add "confirm" to go back.'));
-    if (mode === "both") {
-      app.io.say(C.dim("  the turns after this point stop being what the model sees."));
-      app.io.say(C.dim("  They are not deleted -- this list will still offer them."));
-    } else {
-      app.io.say(C.dim("  the two will disagree afterwards. The model is told which"));
-      app.io.say(C.dim("  paths, and to re-read before editing -- it is not left to"));
-      app.io.say(C.dim("  work it out from a context that no longer matches disk."));
-    }
-    app.io.say("");
-    return;
-  }
-
-  const done = await app.session.rewind(point, mode);
-  if (!done.ok) {
-    app.io.say(C.red(`\n  could not go back: ${done.error}\n`));
-    return;
-  }
-  if (done.unrecoverable.length > 0) {
-    app.io.say(C.red(`\n  restore not applied: missing content for ${done.unrecoverable.join(", ")}`));
-    app.io.say(C.dim(`  ${done.note}\n`));
-    return;
-  }
-  app.io.say(
-    C.green(`\n  back at node ${done.node}`) +
-      C.dim(
-        mode === "context"
-          ? "  no file touched"
-          : `  ${done.restored.length} restored, ${done.removed.length} removed`,
-      ),
-  );
-  if (done.unrecoverable.length > 0) {
-    app.io.say(C.red(`  content no longer stored: ${done.unrecoverable.join(", ")}`));
-  }
-  app.io.say(C.dim(indent(wrap(done.note, 72), "  ")));
-  app.io.say("");
-}
-
-function printModels(app: App): void {
-  const C = app.io.palette;
-  app.io.say(C.bold("\nmodels"));
-  for (const group of groupedModels(app.catalog)) {
-    app.io.say(C.bold(`  ${group.provider}`));
-    for (const spec of group.models) {
-      const got = app.credentialOf(spec);
-      const here = modelKey(spec) === modelKey(app.providerConfig.spec);
-      const mark = here ? C.cyan(" now ") : got.ok ? C.green("ready") : C.dim("  -- ");
-      app.io.say(`    ${mark}  ${spec.id.padEnd(28)}${C.dim(spec.name.padEnd(28))}${whyNot(spec, got, app.auth, C)}`);
-    }
-  }
-  app.io.say(C.dim("\n  /model <id> to switch. Switching cuts this node so the next"));
-  app.io.say(C.dim("  model starts from a handoff, not from this model's thinking blocks.\n"));
-}
-
-async function refreshModels(app: App): Promise<void> {
-  const C = app.io.palette;
-  const result = await runModelsRefresh({
-    fetch: globalThis.fetch,
-    write: writeCatalogCache,
-  });
-  if (!result.ok) {
-    app.io.say(C.yellow(`  ${result.reason}`));
-    app.io.say(C.dim("  existing models.json left unchanged\n"));
-    return;
-  }
-  const loaded = loadCatalog(await readModelSources());
-  await publishModelCatalog(app, loaded.models);
-  for (const warning of loaded.warnings) app.io.say(C.yellow(`  ${warning}`));
-  app.io.say(
-    C.green(`  added ${result.added}, changed ${result.changed} (${result.count} total) → ${catalogCachePath()}`),
-  );
-  app.io.say(C.dim(`  ${app.catalog.length} reachable after overlay\n`));
-}
-
-/** Stores a key under a provider, 0600, after saying what is about to happen. */
-async function login(app: App, provider: string, key: string): Promise<void> {
-  const C = app.io.palette;
-  if (!app.catalog.some((m) => m.provider === provider)) {
-    app.io.say(C.red(`  unknown provider: ${provider}`));
-    app.io.say(C.dim(`  known: ${[...new Set(app.catalog.map((m) => m.provider))].join(", ")}\n`));
-    return;
-  }
-  const next = { ...app.auth, [provider]: { type: "api_key" as const, key } };
-  await writeAuthFile(next);
-  app.auth[provider] = next[provider]!;
-  // The editor masked the paste. Printing `key` here would be the only
-  // remaining way it reaches scrollback.
-  app.io.say(C.green(`  stored ${provider} in ${authPath()}`) + C.dim("  (mode 0600)"));
-  const ready = app.catalog.filter((m) => m.provider === provider && app.credentialOf(m).ok);
-  if (ready.length === 0) {
-    app.io.say(C.yellow("  stored, but it still does not resolve -- check the value.\n"));
-    return;
-  }
-  app.io.say(C.dim(`  now ready: ${ready.map((m) => m.id).join(", ")}`));
-  await adoptCredential(app, ready);
-  app.io.say(C.dim("  this session can send now.\n"));
-}
-
-async function logout(app: App, provider: string | undefined): Promise<void> {
-  const C = app.io.palette;
-  if (provider === undefined) {
-    const names = Object.keys(app.auth);
-    if (names.length === 0) {
-      app.io.say(C.dim("  nothing stored\n"));
-      return;
-    }
-    app.io.say(C.bold("\nlogout"));
-    for (const name of names) app.io.say(`  ${name}`);
-    app.io.say(C.dim("\n  /logout <provider>\n"));
-    return;
-  }
-  if (app.auth[provider] === undefined) {
-    app.io.say(C.dim(`  no stored credential for ${provider}\n`));
-    return;
-  }
-  const next = { ...app.auth };
-  delete next[provider];
-  await writeAuthFile(next);
-  delete app.auth[provider];
-  const resolved = app.credentialOf(app.providerConfig.spec);
-  app.credential = resolved;
-  app.session.provider = makeProvider(app, app.providerConfig, resolved.ok ? resolved.key : "");
-  app.io.say(C.green(`  removed ${provider} from ${authPath()}\n`));
-}
-
-function providerOAuthOpts(app: App, spec: ModelSpec): { oauth: true } | undefined {
-  if (app.args.apiKey.length > 0) return undefined;
-  return storedIsOAuth(app.auth, spec.provider) ? { oauth: true } : undefined;
-}
-
-function makeProvider(app: App, config: ProviderConfig, key: string) {
-  return createProvider(config, key, retryHandler(app.io), { sessionId: providerSessionId(app.session.config.logDir), ...providerOAuthOpts(app, config.spec), effects: app.effects });
-}
-
-interface PendingOAuth {
-  id: SubscriptionId;
-  provider: string;
-  state: string;
-  verifier: string;
-  redirectUri: string;
-  exchange: "anthropic" | "openai";
-  server: CallbackServer;
-  done: boolean;
-  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: Ui | null; close?: () => void }>();
-const loginEffects = { fetch: ((input, init) => globalThis.fetch(input, init)) as typeof globalThis.fetch,
-  openBrowser: tryOpenBrowser, callback: startCallbackServer, device: loginGitHubCopilot };
-
-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();
-  pending?.close?.(); device?.close?.();
-  if (pending) { pending.done = true; await pending.server.close(); }
-}
-
-async function storeOAuth(app: App, provider: string, credential: OAuthCredential): Promise<void> {
-  const C = app.io.palette;
-  await writeAuthFile({ ...app.auth, [provider]: credential });
-  app.auth[provider] = credential;
-  app.io.say(C.green(`  stored ${provider} in ${authPath()}`) + C.dim("  (mode 0600)"));
-  const ready = app.catalog.filter((m) => m.provider === provider && app.credentialOf(m).ok);
-  if (ready.length === 0) {
-    app.io.say(C.dim("  stored. No catalog model uses this provider yet.\n"));
-    return;
-  }
-  app.io.say(C.dim(`  now ready: ${ready.map((m) => m.id).join(", ")}`));
-  await adoptCredential(app, ready);
-  app.io.say(C.dim("  this session can send now.\n"));
-}
-
-async function finishOAuthCode(app: App, pending: PendingOAuth, code: string): Promise<void> {
-  if (pending.done) return;
-  pending.done = true;
-  const effects = pending.tui?.oauthEffects ?? loginEffects;
-  try {
-    const credential =
-      pending.exchange === "anthropic"
-        ? await exchangeAnthropicCode({
-            code,
-            state: pending.state,
-            verifier: pending.verifier,
-            redirectUri: pending.redirectUri,
-            fetch: effects.fetch,
-            signal: pending.abort.signal,
-          })
-        : await exchangeOpenAICode({
-            code,
-            verifier: pending.verifier,
-            redirectUri: pending.redirectUri,
-            fetch: effects.fetch,
-            signal: pending.abort.signal,
-          });
-    if (pending.abort.signal.aborted || pendingLogins.get(app) !== pending) return;
-    await storeOAuth(app, pending.provider, credential);
-  } catch (err) {
-    if (pending.abort.signal.aborted || pendingLogins.get(app) !== pending) return;
-    const message = err instanceof Error ? err.message : "token exchange failed";
-    app.io.say(app.io.palette.red(`  ${message}`));
-    app.io.say(app.io.palette.dim("  nothing was stored.\n"));
-  } finally {
-    if (pendingLogins.get(app) === pending) {
-      pendingLogins.delete(app);
-      pending.close?.();
-    }
-    await pending.server.close();
-  }
-}
-
-async function completeOAuthPaste(app: App, input: string): Promise<void> {
-  const pending = pendingLogins.get(app);
-  if (!pending || pending.done) return;
-  const parsed = parseAuthorizationInput(input);
-  if (parsed.state !== undefined && parsed.state !== pending.state) {
-    app.io.say(app.io.palette.red("  OAuth state mismatch"));
-    await cancelPendingOAuth(app);
-    return;
-  }
-  if (!parsed.code) {
-    app.io.say(app.io.palette.red("  Missing authorization code"));
-    await cancelPendingOAuth(app);
-    return;
-  }
-  await finishOAuthCode(app, pending, parsed.code);
-}
-
-function tryOpenBrowser(url: string): void {
-  try {
-    Bun.spawn(["open", url], { stdout: "ignore", stderr: "ignore", stdin: "ignore" });
-  } catch {
-    // Printed URL is the fallback.
-  }
-}
-
-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";
-  await cancelPendingOAuth(app);
-  const effects = tui?.oauthEffects ?? loginEffects;
-  app.io.say(C.yellow(`  ${SUBSCRIPTION_NOTICE}`));
-  if (sub.id === "github-copilot" || sub.id === "grok") {
-    const pending: { abort: AbortController; tui: Ui | null; close?: () => void } = { abort: new AbortController(), tui };
-    pendingDevices.set(app, pending);
-    const work = async () => { try {
-      const credential = await (sub.id === "grok" ? loginGrok : effects.device)({
-        notify: (message) => {
-          if (pendingDevices.get(app) !== pending) return;
-          if (tui) { pending.close?.(); pending.close = tui.waiting(sub.label, message.split("\n"), () => { void cancelPendingOAuth(app); }); }
-          else app.io.say(`  ${message}`);
-        },
-        prompt: async () => "",
-        fetch: effects.fetch,
-        signal: pending.abort.signal,
-        openBrowser: effects.openBrowser,
-      });
-      if (pending.abort.signal.aborted || pendingDevices.get(app) !== pending) return;
-      await storeOAuth(app, sub.provider, credential);
-    } catch (err) {
-      if (pending.abort.signal.aborted || pendingDevices.get(app) !== pending) return;
-      const message = err instanceof Error ? err.message : "login failed";
-      app.io.say(C.red(`  ${message}\n`));
-    } finally {
-      if (pendingDevices.get(app) === pending) {
-        pendingDevices.delete(app);
-        pending.close?.();
-      }
-    } };
-    if (tui) { pending.close = tui.waiting(sub.label, ["Requesting a device code…"], () => { void cancelPendingOAuth(app); }); tui.runExtensionAction(work); return "continue"; }
-    await work();
-    return "continue";
-  }
-  const pkce = await generatePKCE();
-  const state = generateState();
-  const anthropic = sub.id === "claude-pro";
-  const url = anthropic
-    ? anthropicAuthorizeUrl({ challenge: pkce.challenge, state })
-    : openaiCodexAuthorizeUrl({ challenge: pkce.challenge, state });
-  let server: CallbackServer;
-  try {
-    server = await effects.callback({
-      expectedState: state,
-      host: "127.0.0.1",
-      port: anthropic ? ANTHROPIC_CALLBACK_PORT : OPENAI_CALLBACK_PORT,
-      path: anthropic ? ANTHROPIC_CALLBACK_PATH : OPENAI_CALLBACK_PATH,
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "could not bind callback port";
-    app.io.say(C.yellow(`  ${message}`));
-    app.io.say(C.dim("  paste the redirect URL after signing in.\n"));
-    // Still allow paste without a server: we just won't get a browser callback.
-    server = {
-      host: "127.0.0.1",
-      port: 0,
-      waitForCode: () => new Promise(() => {}),
-      close: async () => {},
-    };
-  }
-  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,
-    provider: sub.provider,
-    state,
-    verifier: pkce.verifier,
-    redirectUri: anthropic ? ANTHROPIC_REDIRECT_URI : OPENAI_REDIRECT_URI,
-    exchange: anthropic ? "anthropic" : "openai",
-    server,
-    done: false,
-    tui,
-    abort: new AbortController(),
-  };
-  pendingLogins.set(app, pending);
-  void pending.server.waitForCode().then(async (got) => {
-    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 };
-}
-
-/**
- * Make the just-stored key the one the next prompt uses, without a restart.
- *
- * Same model: swap the adapter in place (no thinking blocks to isolate).
- * Placeholder session that never sent: swap onto an unlocked model in place
- * so the first prompt is the first event, not a cut of an empty node.
- * Already talking to a different live model: /model is the cut.
- */
-async function adoptCredential(app: App, ready: readonly ModelSpec[]): Promise<void> {
-  const C = app.io.palette;
-  const currentGot = app.credentialOf(app.providerConfig.spec);
-  if (currentGot.ok) {
-    app.session.provider = makeProvider(app, app.providerConfig, currentGot.key);
-    app.credential = currentGot;
-    return;
-  }
-  const spec = ready[0];
-  if (spec === undefined) return;
-  const got = app.credentialOf(spec);
-  if (!got.ok) return;
-  if (app.credential.ok || app.session.state.handoff !== null || app.session.state.events.some((e) => e.t === "assistant")) {
-    await switchToModel(app, spec, undefined, "session");
-    return;
-  }
-  const nextConfig: ProviderConfig = {
-    spec,
-    maxTokens: outputTokenBudget(spec),
-    effort: clampThinkingLevel(spec, app.ui?.settings.modelThinkingLevels?.[modelKey(spec)] ?? app.providerConfig.effort),
-    thinkingDisplay: app.providerConfig.thinkingDisplay,
-  };
-  app.session.provider = makeProvider(app, nextConfig, got.key);
-  app.providerConfig = nextConfig;
-  app.credential = got;
-  const cursor = await readCursor(app.logDir);
-  if (cursor !== null) {
-    await writeCursor(app.logDir, {
-      ...cursor,
-      model: spec.id,
-      provider: spec.provider,
-      thinking: nextConfig.effort,
-      updated_at: app.session.clock.now(),
-    });
-  }
-  app.io.say(C.green(`  now ${spec.name}`) + C.dim(`  ${spec.id}`));
-}
-
-async function switchByPattern(app: App, pattern: string, origin: PreferenceOrigin = "user"): Promise<void> {
-  const C = app.io.palette;
-  const found = scopedModels([pattern], app.catalog, true), selected = found.entries[0];
-  if (!selected) {
-    const diagnostic = findModelByPattern(pattern, app.catalog);
-    app.io.say(C.red(`  ${diagnostic.ok ? found.diagnostics.join("; ") : diagnostic.reason}`));
-    return;
-  }
-  await switchToModel(app, selected.model, selected.thinking, origin);
-}
-
-export async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort, origin: PreferenceOrigin = "user"): Promise<void> {
-  const C = app.io.palette;
-  const got = app.credentialOf(spec);
-  if (!got.ok) {
-    app.io.say(C.red(`\n  ${got.reason}\n`));
-    if (!got.reason.includes("/provider")) {
-      app.io.say(C.dim(`  ${describeMissingCredential(spec.provider)}\n`));
-    }
-    return;
-  }
-  if (spec.id === app.providerConfig.spec.id && spec.provider === app.providerConfig.spec.provider) {
-    if (thinking) await applyThinking(app, clampThinkingLevel(spec, thinking), null, "session");
-    if (origin === "user") await rememberModelSelection(app, spec, thinking);
-    app.io.say(C.dim(`  already on ${spec.id}`));
-    return;
-  }
-  const nextConfig: ProviderConfig = {
-    spec,
-    maxTokens: outputTokenBudget(spec),
-    effort: clampThinkingLevel(spec, thinking ?? app.ui?.settings.modelThinkingLevels?.[modelKey(spec)] ?? app.providerConfig.effort),
-    thinkingDisplay: app.providerConfig.thinkingDisplay,
-  };
-  const next = makeProvider(app, nextConfig, got.key);
-  try {
-    if (await app.session.switchModel(next)) app.io.say(C.dim("  new segment: the next model starts from a handoff, not this model's thinking"));
-  } catch (err) {
-    app.io.say(C.red(`  cannot switch: ${describeError(err)}`));
-    return;
-  }
-  app.providerConfig = nextConfig;
-  app.credential = got;
-  app.io.say(C.green(`  now ${spec.name}`) + C.dim(`  ${spec.id}`));
-  if (origin === "user") await rememberModelSelection(app, spec, thinking);
-}
-
-/** N.8 must accept the checkpoint before a user choice can own the next startup. */
-async function rememberModelSelection(app: App, spec: ModelSpec, explicitThinking: Effort | undefined): Promise<void> {
-  if (!app.ui) return;
-  const effort = app.providerConfig.effort;
-  const patch = modelPreferencePatch(spec, app.ui.settings.recentModels ?? [], effort);
-  await commitUserSettings(app, explicitThinking === undefined ? patch : { ...patch, ...thinkingPreferencePatch(spec, effort) });
-}
-
-function sessionDirOf(app: App): string | undefined {
-  return sessionDirFor(app.args, app.workspace);
-}
-
-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);
-  if (!switched) {
-    app.io.say(C.red(`  cannot start a new session`));
-    return;
-  }
-  if (tui) { tui.sessionName = null; await tui.syncTranscript(); }
-  app.io.say(C.green(`  new session ${created.id}`) + C.dim(`  ${created.path}`));
-}
-
-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) {
-    app.io.say(C.red(`  ${found.reason}. /resume lists them.`));
-    return;
-  }
-  if (found.session.path === app.logDir) {
-    app.io.say(C.dim("  already in this session"));
-    return;
-  }
-  const switched = await adoptLogDir(app, found.session.path);
-  if (!switched) {
-    app.io.say(C.red(`  cannot resume`));
-    return;
-  }
-  if (tui) { tui.sessionName = found.session.name ?? null; await tui.syncTranscript(); }
-  app.io.say(C.green(`  resumed ${found.session.name ?? found.session.id}`) + C.dim(`  ${found.session.path}`));
-}
-
-async function adoptLogDir(app: App, logDir: string): Promise<boolean> {
-  try {
-    await switchAppSession(app, logDir, (current, target) => openSessionFor({ ...current, logDir: target, fallback: current.providerConfig, interactive: true }));
-  } catch (err) {
-    app.io.say(app.io.palette.red(`  ${describeError(err)}`));
-    return false;
-  }
-  return true;
-}
-
-async function transcriptEvents(app: App): Promise<LogEvent[]> {
-  const history = await readNodeHistory(app.logDir, app.session.state.node);
-  if (!history.ok) throw new Error(history.error);
-  return history.nodes.flatMap((node) => node.events);
-}
-
-async function exportSession(app: App, file?: string): Promise<void> {
-  const C = app.io.palette;
-  const events = await transcriptEvents(app);
-  const defaultPath = join(app.workspace, `${basename(app.logDir)}.html`);
-  const dest = file !== undefined && file.length > 0 ? file : defaultPath;
-  const abs = dest.startsWith("/") ? dest : join(app.workspace, dest);
-  const html = abs.toLowerCase().endsWith(".jsonl") === false;
-  try {
-    if (html) await writeFile(abs, toHtml(events, {
-        title: basename(app.logDir),
-        exportedAt: app.session.clock.now(),
-        sessionId: basename(app.logDir),
-      }), "utf8");
-    else await exportSessionArchive(app.logDir, abs, app.blobDir);
-  } catch (err) {
-    app.io.say(C.red(`  cannot write ${abs}: ${describeError(err)}`));
-    return;
-  }
-  app.io.say(C.green(`  exported ${abs}`));
-}
-
-async function copyLastReply(app: App, tui?: Ui): Promise<void> {
-  const C = app.io.palette;
-  const text = lastAssistantText(await transcriptEvents(app));
-  if (text === null) {
-    app.io.say(C.dim("  no assistant reply to copy yet"));
-    return;
-  }
-  const copied = await (tui?.clipboardWriter ?? writeClipboard)(text);
-  if (copied) {
-    app.io.say(C.green("  copied last assistant reply"));
-    return;
-  }
-  app.io.say(C.yellow("  Clipboard unavailable. Printing the reply instead:"));
-  app.io.say(text);
-}
-
-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) {
-    app.io.say(C.bold("\nfork from a user turn") + C.dim("  (newest last)"));
-    if (points.length === 0) {
-      app.io.say(C.dim("  nothing yet -- send a prompt first"));
-      app.io.say("");
-      return;
-    }
-    points.forEach((p, i) => {
-      const n = String(i + 1).padStart(2);
-      app.io.say(`  ${C.bold(n)}  ${firstLine(p.text, 60)}`);
-    });
-    app.io.say(C.dim("\n  /fork <n>  resumes before that user message and restores its draft\n"));
-    return;
-  }
-  const i = Number(arg);
-  const point = Number.isInteger(i) ? points[i - 1] : undefined;
-  if (!point) {
-    app.io.say(C.red(`  no such turn: ${arg}. /fork lists them.`));
-    return;
-  }
-  if (await spawnForkedSession(app, point.id, `forked before ${firstLine(point.text, 40)}`, "before")) {
-    await tui?.syncTranscript();
-    tui?.restoreDraft(point.text, point.images ?? []);
-    tui?.redraw();
-  }
-}
-
-async function cloneSession(app: App): Promise<void> {
-  await spawnForkedSession(app, undefined, "cloned");
-}
-
-async function spawnForkedSession(app: App, untilEvent: string | undefined, label: string, position: "at" | "before" = "at"): Promise<boolean> {
-  const C = app.io.palette;
-  const created = await createSession(app.workspace, undefined, sessionDirOf(app));
-  try {
-    await app.session.fork(created.path, untilEvent, position);
-  } catch (err) {
-    app.io.say(C.red(`  cannot fork: ${describeError(err)}`));
-    return false;
-  }
-  const switched = await adoptLogDir(app, created.path);
-  if (!switched) return false;
-  app.io.say(C.green(`  ${label} → ${created.id}`) + C.dim(`  ${created.path}`));
-  return true;
-}
-
-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);
-  app.projectTrusted = trusted;
-  app.io.say(
-    C.green(`  ${trusted ? "trusted" : "will not trust"} ${dir}`) +
-      C.dim(target === "once" ? "  for this session" : `  saved in ${trustPath()}`),
-  );
-  app.io.say(
-    C.dim("  Project resources reloaded. Tool permissions remain separate."),
-  );
-  await reloadAppResources(app);
-  await tui?.refreshResources();
-}
-
-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>"));
-    return;
-  }
-  // Name lives on the cursor. sessions.ts has no setter -- writeCursor is
-  // the store function that actually holds it, and it keeps a name across
-  // the loop's own cursor rewrites.
-  const cursor = await readCursor(app.logDir);
-  if (cursor === null) {
-    app.io.say(C.red("  no cursor to name yet"));
-    return;
-  }
-  await writeCursor(app.logDir, { ...cursor, name });
-  if (tui) tui.sessionName = name;
-  app.io.say(C.green(`  named ${name}`));
-}
-
-/** Runs a prompt. Returns false if the turn failed, having already said why. */
-async function run(app: App, prompt: string, signal?: AbortSignal, tui?: Ui, images: readonly ImageRef[] = [], skill?: Skill, options?: RequestOptions): Promise<boolean> {
-  if (app.extensions && !initializedExtensions.has(app.extensions)) await bindExtensions(app, tui);
-  for (const result of await app.extensions?.emit("input", { text: prompt, images, source: "interactive" }) ?? []) {
-    if (result["action"] === "handled") return true;
-    if (result["action"] === "transform" && typeof result["text"] === "string") prompt = result["text"];
-  }
-  if (prompt.startsWith("!")) {
-    const excluded = prompt.startsWith("!!");
-    if (tui) tui.beginBash(prompt.slice(excluded ? 2 : 1));
-    const result = await app.session.runUserBash(prompt.slice(excluded ? 2 : 1), excluded, signal,
-      tui ? chunk => tui.pushBash(chunk) : undefined);
-    tui?.observeEvent?.({ kind: "done", outcome: result.outcome });
-    if (tui) { await tui.syncTranscript(); tui.commitStream(); }
-    else app.io.say(`$ ${result.command}\n${result.content}`);
-    return true;
-  }
-  if (!app.credential.ok) {
-    // Must not call session.send: that records a user event before the
-    // request, and a refused prompt is not a turn.
-    const C = app.io.palette;
-    app.io.say(C.yellow("  no credential yet -- this prompt was not sent."));
-    app.io.say(C.dim(`  ${app.credential.reason}`));
-    app.io.say(C.dim("  export an API key, or /provider <provider>.\n"));
-    tui?.restoreDraft(prompt, images);
-    return false;
-  }
-
-  const fresh = await ensureFreshCredential(
-    app.providerConfig.spec,
-    app.auth,
-    app.args.apiKey.length > 0 ? app.args.apiKey : undefined,
-    app.effects,
-    {
-      fetch: globalThis.fetch,
-      now: () => Date.now(),
-      persist: async (next) => {
-        const entry = next[app.providerConfig.spec.provider];
-        if (entry !== undefined) app.auth[app.providerConfig.spec.provider] = entry;
-        await writeAuthFile(app.auth);
-      },
-    },
-  );
-  if (!fresh.ok) {
-    const C = app.io.palette;
-    app.io.say(C.red(`  ${fresh.reason}`));
-    app.io.say(C.dim("  this prompt was not sent.\n"));
-    tui?.restoreDraft(prompt, images);
-    return false;
-  }
-  if (!app.credential.ok || fresh.key !== app.credential.key) {
-    app.credential = fresh;
-    app.session.provider = makeProvider(app, app.providerConfig, fresh.key);
-  }
-
-  let input: UserInput;
-  try {
-  const needsIndex = fileReferences(prompt).length > 0;
-  const index: FileIndex = needsIndex
-    ? await fileIndexFor(app)
-    : { paths: [], truncated: false };
-  const expanded = await expandInput(prompt, {
-    workspace: app.workspace,
-    index,
-    say: (text) => app.io.say(text),
-    attachImage: path => attachImageFile(path, app.blobDir, app.ui?.settings.images?.autoResize ?? true),
-  });
-  if (!expanded.send && !images.length) return true;
-  const attached = [...images, ...expanded.images ?? []];
-  input = attached.length ? { text: expanded.message, images: attached } : expanded.message;
-  app.session.config.imageOptions = app.ui?.settings.images ?? {};
-  if (attached.length && (app.ui?.settings.images?.blockImages || !app.providerConfig.spec.input?.includes("image"))) {
-    app.io.say("  Images are kept in this session; this request uses text placeholders because " +
-      (app.ui?.settings.images?.blockImages ? "image transmission is disabled." : "the selected model does not support image input."));
-  }
-  } catch (error) {
-    app.io.say("  Attachment failed: " + describeError(error));
-    tui?.restoreDraft(prompt, images);
-    return false;
-  }
-  try {
-    await runTurn(app, input, signal, tui, skill, options);
-    return true;
-  } catch (error) {
-    tui?.discardStream();
-    // The session survives. Everything up to this turn is on disk, the next
-    // prompt starts from it, and killing the process over one failed request
-    // would throw away work that is still perfectly good.
-    const C = app.io.palette;
-    app.io.say(C.red(`\n  request failed: ${describeError(error)}`));
-    app.io.say(C.dim("  nothing was lost -- the log is intact. Try again, or /usage.\n"));
-    return false;
-  }
-}
-
-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,
-  options?: RequestOptions,
-): 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.
-  let live = false;
-  let skipFinal = false;
-  const json = app.args?.mode === "json";
-  const checkedOutput = app.session.config.validateOutput !== undefined;
-  let finalText: string[] = [];
-  let completed = false;
-  let failure: string | undefined;
-  const pull = tui?.pullQueued?.bind(tui);
-  const registry = app.extensions;
-  const before = await registry?.emit("before_agent_start", { prompt: userInputData(prompt).text, systemPrompt: app.session.config.frozen.system }) ?? [];
-  for (const result of before) {
-    if (typeof result["systemPrompt"] === "string" && result["systemPrompt"] !== app.session.config.frozen.system)
-      await app.session.reloadResources({ ...app.session.config.frozen, system: result["systemPrompt"] });
-  }
-  await registry?.emit("agent_start");
-  await registry?.emit("turn_start", { turnIndex: 0 });
-  try { for await (const e of skill ? app.session.sendSkill(skill, prompt, signal) : sessionControl(app.session).send(prompt, signal, pull, options)) {
-    // The log retains every response, but a script's final answer must be the
-    // accepted last response. A rejected JSON document cannot be unwritten.
-    if (e.kind === "turn_start" || e.kind === "discard") finalText = [];
-    if (e.kind === "assistant_text") finalText.push(e.text ?? "");
-    if (e.kind === "done") {
-      completed = e.outcome?.status === "completed";
-      if (checkedOutput && !completed) failure = e.reason ?? "output schema validation did not complete";
-    }
-    tui?.observeEvent?.(e);
-    if (e.kind === "text_delta" || e.kind === "thinking_delta") await registry?.emit("message_update", { assistantMessageEvent: { type: e.kind, delta: e.text } });
-    if (e.kind === "assistant_text") await registry?.emit("message_end", { message: { role: "assistant", content: [{ type: "text", text: e.text }] } });
-    if (e.kind === "done") await registry?.emit("turn_end", { reason: e.reason });
-    if (json) {
-      const payload = toJsonEvent(e, app.session.clock.now());
-      if (payload !== null) process.stdout.write(`${JSON.stringify(payload)}\n`);
-      continue;
-    }
-    if (checkedOutput && !tui && e.kind === "assistant_text") continue;
-    if (e.kind === "progress") { if (e.progress) tui?.pushProgress?.(e.progress); continue; }
-    if (tui?.syncTranscript) {
-      if (e.kind === "usage" && e.ok === false && e.prefix && app.ui?.settings.showCacheMissNotices === true)
-        app.io.say(app.io.palette.yellow(`  Cache: ${e.prefix}`));
-      if (e.kind === "text_delta" || e.kind === "thinking_delta") {
-        tui.pushDelta(e.kind === "text_delta" ? "text" : "thinking", e.text ?? "");
-      } else {
-        if (e.kind === "discard") tui.discardStream();
-        await tui.syncTranscript();
-        if (["assistant_text", "thinking", "tool_call", "tool_result", "done", "cut"].includes(e.kind)) tui.commitStream();
-        if (e.kind === "stop_and_ask") {
-          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;
-    }
-    if (e.kind === "text_delta" || e.kind === "thinking_delta") {
-      if (tui !== undefined) {
-        live = true;
-        tui.pushDelta(e.kind === "thinking_delta" ? "thinking" : "text", e.text ?? "");
-      }
-      continue;
-    }
-    if (e.kind === "discard") {
-      live = false;
-      skipFinal = false;
-      tui?.discardStream();
-      continue;
-    }
-    // Per-round, not per-turn: a tool-using turn streams again after each
-    // tool_result. A latch that stays set would skip commitStream on later
-    // rounds and dropLive would then erase the only copy.
-    if (live && tui !== undefined) {
-      tui.commitStream();
-      live = false;
-      skipFinal = true;
-    }
-    if (skipFinal && (e.kind === "assistant_text" || e.kind === "thinking")) continue;
-    if (skipFinal && e.kind !== "usage") skipFinal = false;
-    if (e.kind === "assistant_text" && app.io.answer !== undefined) {
-      app.io.answer(e.text ?? "");
-      continue;
-    }
-    for (const line of formatEvent(
-      e,
-      app.io.palette,
-      Math.max(20, (process.stdout.columns ?? 80) - 1),
-      {},
-      app.ui?.style,
-    )) {
-      app.io.say(line);
-    }
-  } } finally { await registry?.emit("agent_end", { messages: structuredClone(app.session.state.events) }); }
-  // feat-external-effects-summary: one line, in every mode (print and json send it to stderr).
-  const host = hostExternalOptions();
-  const outside = formatExternalEffects(skill ? requestExternalEffects(app.session, host) : sessionControl(app.session).lastExternalEffects, host);
-  if (outside) { if (tui?.notice) tui.notice(outside, "warning"); else app.io.say(app.io.palette.yellow(`  ${outside}`)); }
-  if (failure) throw Error(failure);
-  if (completed) {
-    const text = finalText.join("\n");
-    if (checkedOutput && !tui && !json) {
-      if (app.io.answer) app.io.answer(text); else app.io.say(text);
-    }
-    if (app.args?.outputLastMessage) await writeFile(resolve(app.args.outputLastMessage), text.endsWith("\n") ? text : text + "\n", "utf8");
-  }
-}
-
-// ---------------------------------------------------------------------------
-// TUI
-// ---------------------------------------------------------------------------