@datalabrotterdam/nova-ai-cli 1.2.0-alpha.1 → 1.2.0-alpha.10

package/dist/{tui-XOKXPXN2.js → tui-TJFV6NC6.js}

@@ -1,52 +1,140 @@
 import {
-  TuiAcpClient,
-  createStore,
-  readWorkspaceMcpConfiguration,
-  startInProcessAgent,
-  workspaceNeedsTrust
-} from "./chunk-ZKRZIF3S.js";
-import {
-  INTERACTION_MODES,
-  NovaAgent,
-  OTHER_OPTION_ID,
-  discoverSkills,
-  isInteractionMode,
-  listStoredSessions,
-  loadStoredSession,
-  replayHistory,
-  resolveModelContextWindow,
-  savePermissionMode,
-  savedPermissionMode
-} from "./chunk-GZZ7PY3S.js";
+  checkForUpdate,
+  rememberUpdateAnswer,
+  shouldAskAboutUpdate
+} from "./chunk-L77KQRGZ.js";
 import {
-  readPackageVersion
-} from "./chunk-Q7WL3DXP.js";
+  CLI_PACKAGE_NAME,
+  cliVersion
+} from "./chunk-FMHWW3E6.js";
 import {
-  chatModels,
-  createNovaClient,
-  readCredentials,
-  resolveDefaultModel,
-  resolveModelSupportsImageInput,
-  saveDefaultModel,
-  setWorkspaceTrusted
-} from "./chunk-JAEXUFAS.js";
+  TuiAcpClient,
+  createStore
+} from "./chunk-KDAUUQBE.js";
 
 // src/tui/index.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { readCredentials } from "@datalabrotterdam/nova-ai-agent/core/credentials.js";
+import { listStoredSessions as listStoredSessions2, loadStoredSession as loadStoredSession2 } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
+import { setWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
+
+// src/update-install.ts
+import { spawnSync } from "child_process";
+import { existsSync, realpathSync } from "fs";
+import { dirname, join, sep } from "path";
 import { createInterface } from "readline/promises";
+var START_WAIT_MS = 1500;
+var UPDATED_FROM_ENV = "NOVA_UPDATED_FROM";
+function globalNpmPrefix(options = {}) {
+  const script = options.scriptPath ?? process.argv[1];
+  if (!script) return null;
+  const windows = (options.platform ?? process.platform) === "win32";
+  const marker = `${sep}node_modules${sep}${CLI_PACKAGE_NAME.split("/").join(sep)}${sep}`;
+  const resolved = realPath(script);
+  const at = resolved.lastIndexOf(marker);
+  if (at < 0) return null;
+  const nodeModulesParent = resolved.slice(0, at);
+  const prefix = windows ? nodeModulesParent : dirname(nodeModulesParent);
+  if (!windows && nodeModulesParent !== join(prefix, "lib")) return null;
+  return existsSync(join(prefix, windows ? "nova-ai.cmd" : join("bin", "nova-ai"))) ? prefix : null;
+}
+async function withInstallability(update, options = {}) {
+  if (!update) return null;
+  return { ...update, installable: globalNpmPrefix(options) !== null };
+}
+function npmInvocation(args) {
+  return process.platform === "win32" ? [`npm ${args.map((arg) => /\s/.test(arg) ? `"${arg}"` : arg).join(" ")}`, [], true] : ["npm", args, false];
+}
+function realPath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function parseUpdateAnswer(answer) {
+  const value = answer.trim().toLowerCase();
+  if (value === "" || value === "y" || value === "yes") return "update";
+  if (value === "s" || value === "skip") return "skip";
+  return "later";
+}
+async function askToUpdate(update) {
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log(`
+Update available: nova-ai ${update.currentVersion} \u2192 ${update.latestVersion}`);
+    return parseUpdateAnswer(
+      await prompt.question("Update now? [Y/n/s] (n: not today, s: skip this version) ")
+    );
+  } finally {
+    prompt.close();
+  }
+}
+async function offerUpdateAtStart(check, restartArgs) {
+  let timer;
+  const update = await Promise.race([
+    check,
+    new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2(null), START_WAIT_MS);
+    })
+  ]);
+  clearTimeout(timer);
+  if (!update?.installable || !shouldAskAboutUpdate(update)) return null;
+  const answer = await askToUpdate(update);
+  if (answer !== "update") {
+    rememberUpdateAnswer(answer, update);
+    console.log(
+      answer === "skip" ? `Skipping ${update.latestVersion}; you'll be asked again for a newer version.` : "Not now. /update installs it any time."
+    );
+    return null;
+  }
+  return installAndRestart(update, restartArgs);
+}
+function installAndRestart(update, restartArgs) {
+  const prefix = globalNpmPrefix();
+  if (!prefix) return null;
+  console.log(`
+Installing nova-ai ${update.latestVersion}\u2026`);
+  const [file, args, shell] = npmInvocation(["install", "-g", "--prefix", prefix, `${CLI_PACKAGE_NAME}@${update.tag}`]);
+  const install = spawnSync(file, args, { stdio: "inherit", shell });
+  if (install.status !== 0) {
+    console.error(`
+The update did not install. Run it yourself: ${update.command}
+`);
+    return null;
+  }
+  const script = process.argv[1];
+  if (!script) return null;
+  const restarted = spawnSync(process.execPath, [...process.execArgv, script, ...restartArgs], {
+    stdio: "inherit",
+    env: { ...process.env, [UPDATED_FROM_ENV]: update.currentVersion }
+  });
+  return restarted.status ?? 1;
+}
 
 // src/tui/ink/app.tsx
-import { Box as Box6, render, Static, Text as Text6, useBoxMetrics, useWindowSize } from "ink";
-import { useEffect, useRef, useState as useState2, useSyncExternalStore as useSyncExternalStore2 } from "react";
+import { Box as Box6, render, Text as Text6, useBoxMetrics, useInput as useInput3, useWindowSize } from "ink";
+import { memo, useEffect, useRef, useState as useState2, useSyncExternalStore as useSyncExternalStore2 } from "react";
+import { savedPermissionMode } from "@datalabrotterdam/nova-ai-agent/core/policy/settings.js";
 
 // src/tui/session/session-runner.ts
 import * as acp from "@agentclientprotocol/sdk";
+import { NovaAgent } from "@datalabrotterdam/nova-ai-agent/acp/agent.js";
+import { startInProcessAgent } from "@datalabrotterdam/nova-ai-agent/client/in-process.js";
+import { replayHistory } from "@datalabrotterdam/nova-ai-agent/core/history.js";
+import {
+  saveDefaultEffort,
+  saveDefaultModel
+} from "@datalabrotterdam/nova-ai-agent/core/credentials.js";
 import {
-  NovaAIError
-} from "@datalabrotterdam/nova-sdk";
+  savePermissionMode
+} from "@datalabrotterdam/nova-ai-agent/core/policy/settings.js";
+import { loadStoredSession } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
+import { resolveEffort } from "@datalabrotterdam/nova-ai-agent/core/model-capabilities.js";
 
 // src/tui/files/file-mentions.ts
 import { statSync } from "fs";
-import { isAbsolute, relative, resolve, sep } from "path";
+import { isAbsolute, relative, resolve, sep as sep2 } from "path";
 var MENTION_RE = /@(?:"([^"]+)"|'([^']+)'|([^\s]+))/g;
 var TRAILING_PUNCTUATION = /[.,;:!?\)\]\}]+$/;
 function findWorkspaceFileMentions(text, cwd) {
@@ -56,10 +144,10 @@ function findWorkspaceFileMentions(text, cwd) {
     const raw = match[1] ?? match[2] ?? match[3] ?? "";
     const candidates = [raw, raw.replace(TRAILING_PUNCTUATION, "")].filter((value, index, all) => value && all.indexOf(value) === index);
     for (const candidate of candidates) {
-      const normalized = candidate.replace(/[\\/]/g, sep);
+      const normalized = candidate.replace(/[\\/]/g, sep2);
       const absolutePath = resolve(workspaceRoot, normalized);
       const relativePath = relative(workspaceRoot, absolutePath);
-      if (relativePath.startsWith(`..${sep}`) || relativePath === ".." || isAbsolute(relativePath)) continue;
+      if (relativePath.startsWith(`..${sep2}`) || relativePath === ".." || isAbsolute(relativePath)) continue;
       try {
         if (!statSync(absolutePath).isFile()) continue;
       } catch {
@@ -67,7 +155,7 @@ function findWorkspaceFileMentions(text, cwd) {
       }
       mentions.set(absolutePath.toLowerCase(), {
         absolutePath,
-        relativePath: relativePath.split(sep).join("/")
+        relativePath: relativePath.split(sep2).join("/")
       });
       break;
     }
@@ -187,15 +275,6 @@ var SessionRunner = class {
   constructor(store, credentials, cwd) {
     this.store = store;
     this.credentials = credentials;
-    this.loadMcpConfiguration(cwd);
-    this.skills = discoverSkills(cwd).map(
-      ({ name, description, source, path }) => ({
-        name,
-        description,
-        source,
-        path
-      })
-    );
     this.cwd = cwd;
     this.acpClient = new TuiAcpClient(
       store,
@@ -210,13 +289,8 @@ var SessionRunner = class {
       clientCapabilities: this.acpClient.capabilities,
       clientInfo: { name: "nova-ai-cli-tui", version: "1" }
     });
-    this.novaClient = createNovaClient(credentials.apiKey);
-    const model = credentials.defaultModel ?? process.env.NOVA_MODEL;
-    if (!model)
-      throw new Error(
-        "No Nova model configured. Re-run authentication or set NOVA_MODEL."
-      );
-    this.model = model;
+    this.model = credentials.defaultModel ?? process.env.NOVA_MODEL ?? "";
+    this.effort = credentials.defaultEffort ?? null;
     this.sessionId = crypto.randomUUID();
     this.sessionReady = Promise.resolve();
   }
@@ -227,21 +301,26 @@ var SessionRunner = class {
   title = null;
   model;
   interactionMode = "agent";
+  /** The modes the agent offers: the built-in ones, then the user's agent files. */
+  get modeIds() {
+    return this.acpClient.modeIds;
+  }
+  /** The agent's slash commands (the user's command files); sent as a prompt. */
+  get agentCommands() {
+    return this.acpClient.agentCommands;
+  }
   /** The agent, served in-process over a real ACP connection (tests may stub it). */
   agent = new NovaAgent();
   acpClient;
   connection;
   nova;
   initialized;
-  novaClient;
-  mcpServers = [];
-  mcpConfigurationFailures = [];
   mcpStatus = {
     configured: [],
     connected: [],
     failures: []
   };
-  skills;
+  skills = [];
   sessionReady;
   agentSessionLoaded = false;
   promptActive = false;
@@ -249,10 +328,10 @@ var SessionRunner = class {
   handoffActive = false;
   queuedAttachments = /* @__PURE__ */ new Map();
   editingQueuedMessageId = null;
-  imageSupportByModel = /* @__PURE__ */ new Map();
-  contextWindow = null;
-  contextWindowModel = null;
-  contextWindowRequest = 0;
+  /** From the agent's model list: image input, thinking levels. */
+  modelInfo = /* @__PURE__ */ new Map();
+  /** The thinking level the user chose (saved); null: each model's default. */
+  effort;
   contextUsageRequest = 0;
   modelCheck = null;
   resumeFrom(storedSessionId) {
@@ -265,15 +344,7 @@ var SessionRunner = class {
     this.sessionId = stored.sessionId;
     this.cwd = stored.cwd;
     this.title = stored.title;
-    this.loadMcpConfiguration(stored.cwd);
-    this.skills = discoverSkills(stored.cwd).map(
-      ({ name, description, source, path }) => ({
-        name,
-        description,
-        source,
-        path
-      })
-    );
+    this.skills = [];
     const messages = restoreSessionMessages(stored.messages);
     this.store.setState({
       messages,
@@ -292,12 +363,13 @@ var SessionRunner = class {
         return await this.nova.loadSession({
           sessionId: stored.sessionId,
           cwd: stored.cwd,
-          mcpServers: this.mcpServers
+          mcpServers: []
         });
       } finally {
         this.acpClient.muteSessionUpdates = false;
       }
     }).then((response) => {
+      this.applyModes(response.modes);
       this.applyMcpStatus(response._meta);
       this.applySkillStatus(response._meta);
       this.agentSessionLoaded = true;
@@ -305,6 +377,7 @@ var SessionRunner = class {
       void this.nova.setSessionMode({ sessionId: this.sessionId, modeId: this.interactionMode }).catch(() => {
       });
       this.applyPermissionMode(this.sessionId);
+      this.applyEffort(this.sessionId);
       void this.updateContextUsage();
       void this.refreshContextUsage().catch(() => {
       });
@@ -417,9 +490,6 @@ var SessionRunner = class {
     void this.enqueueQueuedPrompt(value, [], [], "steer", true);
     return true;
   }
-  configuredMcpServers() {
-    return [...this.mcpServers];
-  }
   mcpSessionStatus() {
     return {
       configured: this.mcpStatus.configured.map((server) => ({ ...server })),
@@ -430,27 +500,37 @@ var SessionRunner = class {
   skillSessionStatus() {
     return this.skills.map((skill) => ({ ...skill }));
   }
+  /** Signs in to (or out of) an HTTP MCP server; the agent reconnects it and reports the new status. */
+  async mcpSignIn(serverName, signIn) {
+    await this.ensureSession();
+    const params = { sessionId: this.sessionId, serverName };
+    const meta = signIn ? await this.nova.mcpLogin(params) : await this.nova.mcpLogout(params);
+    this.applyMcpStatus(meta);
+    return this.mcpSessionStatus();
+  }
+  async trustWorkspace() {
+    await this.initialized;
+    await this.nova.workspaceTrust({ cwd: this.cwd, trusted: true });
+  }
+  /** Every skill of the workspace with its on/off state, from the agent. */
+  async listSkills() {
+    await this.initialized;
+    return (await this.nova.skillsList({ cwd: this.cwd })).skills;
+  }
+  async setSkillEnabled(name, enabled, global) {
+    await this.initialized;
+    return (await this.nova.skillsSetEnabled({
+      cwd: this.cwd,
+      name,
+      enabled,
+      scope: global ? "global" : "project"
+    })).skills;
+  }
   contextUsageSnapshot() {
     return this.store.getState().contextUsage;
   }
   async refreshContextUsage() {
     await this.ensureSession();
-    const sessionId = this.sessionId;
-    const model = this.model;
-    if (this.contextWindowModel !== model) {
-      const request = ++this.contextWindowRequest;
-      const contextWindow = await resolveModelContextWindow(
-        this.novaClient,
-        model
-      );
-      if (request === this.contextWindowRequest && model === this.model) {
-        this.contextWindow = contextWindow;
-        this.contextWindowModel = model;
-      }
-    }
-    if (sessionId !== this.sessionId || !this.agentSessionLoaded) {
-      return this.refreshContextUsage();
-    }
     const usage = await this.updateContextUsage();
     if (!usage)
       throw new Error(
@@ -466,13 +546,8 @@ var SessionRunner = class {
   }
   setModel(model) {
     this.model = model;
-    this.contextWindow = null;
-    this.contextWindowModel = null;
-    this.contextWindowRequest++;
     saveDefaultModel(model);
     if (this.agentSessionLoaded) void this.updateContextUsage();
-    void this.refreshContextUsage().catch(() => {
-    });
   }
   /**
    * Hands the mode to the agent's permission policy (which decides) and
@@ -530,27 +605,34 @@ var SessionRunner = class {
   }
   /** Chat models only: embedding, speech and transcription models can't run a session. */
   async listModels() {
-    const { data } = await this.novaClient.models.list({ limit: 100 });
-    return chatModels(data).map((model) => ({
-      id: model.id,
-      name: model.name ?? null
-    }));
+    await this.initialized;
+    const { models } = await this.nova.modelsList();
+    for (const model of models) this.modelInfo.set(model.id, model);
+    return models.map((model) => ({ id: model.id, name: model.name, thinking: model.thinking }));
+  }
+  /** Sync, from the loaded model list: false until it has loaded. */
+  hasThinkingLevels(model = this.model) {
+    return (this.modelInfo.get(model)?.efforts.length ?? 0) > 0;
   }
   /**
-   * Replaces a saved model that cannot chat (older logins saved the first
-   * model of the list, e.g. an embedding model) and saves the replacement.
+   * Takes the account's default model when none is set, and replaces a saved
+   * one that cannot chat (older logins saved the first model of the list,
+   * e.g. an embedding model); the agent decides, the choice is saved.
    * Runs once; a failed lookup keeps the model and the prompt reports errors.
    */
   ensureUsableModel() {
     this.modelCheck ??= (async () => {
       try {
-        const { data } = await this.novaClient.models.list({ limit: 100 });
-        const model = resolveDefaultModel(data, this.model);
-        if (!model || model === this.model) return;
+        await this.initialized;
+        const { models, defaultModel } = await this.nova.modelsList(
+          this.model ? { preferred: this.model } : {}
+        );
+        for (const model of models) this.modelInfo.set(model.id, model);
+        if (!defaultModel || defaultModel === this.model) return;
         const previous = this.model;
-        this.setModel(model);
+        this.setModel(defaultModel);
         this.store.setState({
-          statusLine: `${previous} is not a chat model; switched to ${model} (Ctrl+P to pick another).`
+          statusLine: previous ? `${previous} is not a chat model; switched to ${defaultModel} (Ctrl+P to pick another).` : `Using model ${defaultModel} (Ctrl+P switches).`
         });
       } catch {
       }
@@ -558,14 +640,41 @@ var SessionRunner = class {
     return this.modelCheck;
   }
   async supportsImageInput(model = this.model) {
-    const cached = this.imageSupportByModel.get(model);
-    if (cached !== void 0) return cached;
-    const supported = await resolveModelSupportsImageInput(
-      this.novaClient,
-      model
-    );
-    this.imageSupportByModel.set(model, supported);
-    return supported;
+    return (await this.modelDetails(model))?.imageInput ?? false;
+  }
+  /** What the agent's model list says about `model`; undefined when it isn't listed. */
+  async modelDetails(model = this.model) {
+    if (!this.modelInfo.has(model)) await this.listModels();
+    return this.modelInfo.get(model);
+  }
+  /**
+   * The level the current model thinks at, as the agent picks it (the
+   * chosen one when the model has it); null for a model without levels
+   * or before the model list has loaded.
+   */
+  currentEffort() {
+    const info = this.modelInfo.get(this.model);
+    if (!info?.efforts.length) return null;
+    return resolveEffort(
+      { reasoning_efforts: info.efforts, reasoning_default: info.reasoningDefault },
+      this.effort
+    ) ?? null;
+  }
+  /** The current model's levels from the loaded list; empty when it has none. */
+  modelEffortLevels() {
+    return this.modelInfo.get(this.model)?.efforts ?? [];
+  }
+  /** Saved and kept across models and sessions; a model without the level uses its default. */
+  setEffort(level) {
+    this.effort = level;
+    saveDefaultEffort(level);
+    if (this.agentSessionLoaded) this.applyEffort(this.sessionId);
+  }
+  applyEffort(sessionId) {
+    if (!this.effort) return;
+    void this.nova.setSessionConfigOption({ sessionId, configId: "thought_level", value: this.effort }).catch(() => {
+      this.acpClient.appendError("Could not change the thinking level.");
+    });
   }
   async compactContext() {
     if (this.store.getState().busy || this.promptActive) {
@@ -689,7 +798,7 @@ var SessionRunner = class {
         });
       }
     } catch (err) {
-      const message = err instanceof NovaAIError ? `Nova AI request failed (status ${err.status}, requestId ${err.requestId}): ${err.message}` : err instanceof Error ? err.message : "Unknown error.";
+      const message = err instanceof Error ? err.message : "Unknown error.";
       pendingToolFailure = `Request failed: ${message}`;
       this.acpClient.appendError(message);
       this.store.setState({ statusLine: "Request failed." });
@@ -843,13 +952,13 @@ var SessionRunner = class {
     ];
   }
   async createSession() {
-    this.loadMcpConfiguration(this.cwd);
     await this.initialized;
-    const { sessionId, _meta } = await this.nova.newSession({
+    const { sessionId, _meta, modes } = await this.nova.newSession({
       cwd: this.cwd,
-      mcpServers: this.mcpServers
+      mcpServers: []
     });
     this.sessionId = sessionId;
+    this.applyModes(modes);
     this.applyMcpStatus(_meta);
     this.applySkillStatus(_meta);
     this.agentSessionLoaded = true;
@@ -857,6 +966,7 @@ var SessionRunner = class {
     void this.nova.setSessionMode({ sessionId, modeId: this.interactionMode }).catch(() => {
     });
     this.applyPermissionMode(sessionId);
+    this.applyEffort(sessionId);
     void this.updateContextUsage();
     void this.refreshContextUsage().catch(() => {
     });
@@ -871,10 +981,20 @@ var SessionRunner = class {
     const value = meta?.["nova-ai-cli/mcp"];
     if (!value || typeof value !== "object") return;
     const record = value;
+    const strings = (value2) => Array.isArray(value2) ? value2.filter((entry) => typeof entry === "string") : void 0;
     const configured = Array.isArray(record.configured) ? record.configured.flatMap((entry) => {
       if (!entry || typeof entry !== "object") return [];
       const item = entry;
-      return typeof item.name === "string" && typeof item.transport === "string" ? [{ name: item.name, transport: item.transport }] : [];
+      return typeof item.name === "string" && typeof item.transport === "string" ? [
+        {
+          name: item.name,
+          transport: item.transport,
+          ...typeof item.url === "string" ? { url: item.url } : {},
+          ...typeof item.command === "string" ? { command: item.command } : {},
+          ...strings(item.args) ? { args: strings(item.args) } : {},
+          ...strings(item.env) ? { env: strings(item.env) } : {}
+        }
+      ] : [];
     }) : [];
     const connected = Array.isArray(record.connected) ? record.connected.filter(
       (entry) => typeof entry === "string"
@@ -882,26 +1002,15 @@ var SessionRunner = class {
     const failures = Array.isArray(record.failures) ? record.failures.flatMap((entry) => {
       if (!entry || typeof entry !== "object") return [];
       const item = entry;
-      return typeof item.serverName === "string" && typeof item.message === "string" ? [{ serverName: item.serverName, message: item.message }] : [];
+      return typeof item.serverName === "string" && typeof item.message === "string" ? [
+        {
+          serverName: item.serverName,
+          message: item.message,
+          ...item.needsAuth === true ? { needsAuth: true } : {}
+        }
+      ] : [];
     }) : [];
-    this.mcpStatus = {
-      configured,
-      connected,
-      failures: [...this.mcpConfigurationFailures, ...failures]
-    };
-  }
-  loadMcpConfiguration(cwd) {
-    const configuration = readWorkspaceMcpConfiguration(cwd);
-    this.mcpServers = configuration.servers;
-    this.mcpConfigurationFailures = configuration.failures;
-    this.mcpStatus = {
-      configured: this.mcpServers.map((server) => ({
-        name: server.name,
-        transport: "type" in server ? server.type : "stdio"
-      })),
-      connected: [],
-      failures: [...this.mcpConfigurationFailures]
-    };
+    this.mcpStatus = { configured, connected, failures };
   }
   applySkillStatus(meta) {
     const value = meta?.["nova-ai-cli/skills"];
@@ -919,14 +1028,34 @@ var SessionRunner = class {
       ] : [];
     });
   }
+  /**
+   * Starts the session ahead of the first prompt, so the agent's MCP and
+   * skill status is there for /mcp and the status line. A failure is left to
+   * the first prompt, which tries again and reports it.
+   */
+  async prepareSession() {
+    try {
+      await this.ensureSession();
+    } catch {
+      this.sessionReady = Promise.resolve();
+    }
+  }
+  get sessionLoaded() {
+    return this.agentSessionLoaded;
+  }
   async ensureSession() {
     await this.ensureUsableModel();
-    await this.sessionReady;
-    if (!this.agentSessionLoaded) {
-      this.sessionReady = this.createSession();
-      await this.sessionReady;
+    for (; ; ) {
+      const ready = this.sessionReady;
+      await ready;
+      if (this.agentSessionLoaded) return;
+      if (this.sessionReady === ready) this.sessionReady = this.createSession();
     }
   }
+  applyModes(modes) {
+    if (modes?.availableModes.length) this.acpClient.modeIds = modes.availableModes.map((mode) => mode.id);
+    if (!this.modeIds.includes(this.interactionMode)) this.applyInteractionMode("agent", "Mode: agent");
+  }
   applyInteractionMode(mode, statusLine) {
     this.interactionMode = mode;
     this.store.setState({ interactionMode: mode, statusLine });
@@ -940,7 +1069,7 @@ var SessionRunner = class {
     try {
       const usage = await this.nova.sessionContextUsage({
         sessionId,
-        contextWindow: this.contextWindow,
+        ...this.model ? { model: this.model } : {},
         mode: this.interactionMode
       });
       if (request === this.contextUsageRequest && sessionId === this.sessionId) {
@@ -1013,82 +1142,6 @@ function fromAgentPermissionMode(mode) {
   return mode === "bypassPermissions" ? "bypassAll" : mode === "acceptEdits" ? "acceptEdits" : "ask";
 }
 
-// src/tui/update-check.ts
-var PACKAGE_NAME = "@datalabrotterdam/nova-ai-cli";
-var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME.replace("/", "%2F")}/latest`;
-var DEFAULT_TIMEOUT_MS = 3e3;
-var UPDATE_COMMAND = "npm install -g @datalabrotterdam/nova-ai-cli@latest";
-async function checkForUpdate(options = {}) {
-  try {
-    const currentVersion = options.currentVersion ?? readInstalledVersion();
-    if (!currentVersion) return null;
-    const response = await (options.fetchImpl ?? fetch)(REGISTRY_URL, {
-      headers: { accept: "application/json" },
-      signal: AbortSignal.timeout(options.timeoutMs ?? DEFAULT_TIMEOUT_MS)
-    });
-    if (!response.ok) return null;
-    const payload = await response.json();
-    if (!isVersionPayload(payload)) return null;
-    if (!isNewerVersion(payload.version, currentVersion)) return null;
-    return {
-      currentVersion,
-      latestVersion: payload.version,
-      command: UPDATE_COMMAND
-    };
-  } catch {
-    return null;
-  }
-}
-function readInstalledVersion() {
-  return readPackageVersion();
-}
-function isNewerVersion(candidate, current) {
-  const next = parseVersion(candidate);
-  const installed = parseVersion(current);
-  if (!next || !installed) return false;
-  for (let index = 0; index < 3; index++) {
-    const difference = next.core[index] - installed.core[index];
-    if (difference !== 0) return difference > 0;
-  }
-  return comparePrerelease(next.prerelease, installed.prerelease) > 0;
-}
-function isVersionPayload(value) {
-  return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
-}
-function parseVersion(value) {
-  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(
-    value
-  );
-  if (!match) return null;
-  return {
-    core: [Number(match[1]), Number(match[2]), Number(match[3])],
-    prerelease: match[4]?.split(".") ?? []
-  };
-}
-function comparePrerelease(left, right) {
-  if (left.length === 0 || right.length === 0) {
-    if (left.length === right.length) return 0;
-    return left.length === 0 ? 1 : -1;
-  }
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index++) {
-    const leftPart = left[index];
-    const rightPart = right[index];
-    if (leftPart === void 0 || rightPart === void 0) {
-      return leftPart === rightPart ? 0 : leftPart === void 0 ? -1 : 1;
-    }
-    if (leftPart === rightPart) continue;
-    const leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : null;
-    const rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : null;
-    if (leftNumber !== null && rightNumber !== null)
-      return leftNumber - rightNumber;
-    if (leftNumber !== null || rightNumber !== null)
-      return leftNumber !== null ? -1 : 1;
-    return leftPart < rightPart ? -1 : 1;
-  }
-  return 0;
-}
-
 // src/tui/ink/terminal-keyboard.ts
 var KITTY_QUERY = "\x1B[?u";
 var DEVICE_ATTRIBUTES_QUERY = "\x1B[c";
@@ -1130,6 +1183,17 @@ function kittyKeyboardOverride(env = process.env) {
 function isLateTerminalReply(input) {
   return /^\u001b?\[\?[\d;]*[uc]$/.test(input);
 }
+var MOUSE_REPORTING_ON = "\x1B[?1000h\x1B[?1006h";
+var MOUSE_REPORTING_OFF = "\x1B[?1000l\x1B[?1006l";
+var MOUSE_INPUT = /^\u001b?\[<(\d+);\d+;\d+[Mm]$/;
+function isMouseInput(input) {
+  return MOUSE_INPUT.test(input);
+}
+function wheelRows(input) {
+  const button = Number(MOUSE_INPUT.exec(input)?.[1] ?? -1);
+  if (button < 0 || (button & 64) === 0) return 0;
+  return button & 1 ? -3 : 3;
+}
 
 // src/tui/ink/components/prompt-input.tsx
 import { Box, Text, useInput, usePaste } from "ink";
@@ -1147,7 +1211,8 @@ var palette = {
   faint: "#64748b",
   code: "#fcd34d",
   diffAddBg: "#1b3a24",
-  diffRemoveBg: "#3d1f1f"
+  diffRemoveBg: "#3d1f1f",
+  stickyBackground: "#1e293b"
 };
 var colors = {
   primary: chalk.hex(palette.primary),
@@ -1174,7 +1239,7 @@ function PromptInput({
 }) {
   useSyncExternalStore(editor.subscribe, editor.getVersion);
   useInput((input, key) => {
-    if (onKey(input, key)) return;
+    if (isMouseInput(input) || onKey(input, key)) return;
     editor.handleKey(input, key);
   });
   usePaste((text) => editor.paste(text));
@@ -1460,15 +1525,18 @@ import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-run
 function StatusLine({
   ui,
   model,
-  mcp
+  effort = null,
+  mcp,
+  scroll = 0
 }) {
   const separator = /* @__PURE__ */ jsx2(Text2, { color: palette.faint, children: " | " });
   const usage = ui.contextUsage ? `ctx:${formatTokenCount(ui.contextUsage.totalTokens)}${ui.contextUsage.contextWindow ? `/${formatTokenCount(ui.contextUsage.contextWindow)}` : ""}` : null;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-    ui.updateAvailable ? /* @__PURE__ */ jsx2(Text2, { color: palette.warning, children: `Update ${ui.updateAvailable.latestVersion} available (current ${ui.updateAvailable.currentVersion}). Run: ${ui.updateAvailable.command}` }) : null,
+    ui.updateAvailable ? /* @__PURE__ */ jsx2(Text2, { color: palette.warning, children: `Update ${ui.updateAvailable.latestVersion} available (current ${ui.updateAvailable.currentVersion}). ${ui.updateAvailable.installable ? "Type /update to install it." : `Run: ${ui.updateAvailable.command}`}` }) : null,
     ui.statusLine ? /* @__PURE__ */ jsx2(Text2, { color: palette.muted, children: ui.statusLine }) : null,
     /* @__PURE__ */ jsxs2(Text2, { wrap: "truncate-end", children: [
       /* @__PURE__ */ jsx2(Text2, { color: palette.muted, children: model }),
+      effort ? /* @__PURE__ */ jsx2(Text2, { color: palette.muted, children: ` \xB7 thinking ${effort.toLowerCase()}` }) : null,
       separator,
       ui.interactionMode,
       separator,
@@ -1488,6 +1556,10 @@ function StatusLine({
         `mcp:${mcp.connected}/${mcp.configured}`,
         mcp.failed ? /* @__PURE__ */ jsx2(Text2, { color: palette.danger, children: ` !${mcp.failed}` }) : null
       ] }) : null,
+      scroll ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        separator,
+        /* @__PURE__ */ jsx2(Text2, { color: palette.warning, children: `\u2191${scroll} lines \xB7 PgDn/Esc` })
+      ] }) : null,
       mcp.skills ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
         separator,
         `skills:${mcp.skills}`
@@ -1814,7 +1886,7 @@ var builtinCommands = [
     name: "help",
     description: "Show available commands",
     run(ctx) {
-      const lines = builtinCommands.map((c) => `/${c.name} \u2014 ${c.description}`);
+      const lines = [...builtinCommands.filter((c) => c.available?.(ctx) ?? true), ...ctx.agentCommands()].map((c) => `/${c.name} \u2014 ${c.description}`);
       ctx.print(lines.join("\n"));
     }
   },
@@ -1880,22 +1952,30 @@ var builtinCommands = [
   },
   {
     name: "exit",
-    description: "Exit nova-ai-cli",
+    description: "Exit nova-ai",
     run(ctx) {
       ctx.exit();
     }
   },
+  {
+    name: "update",
+    description: "Install the newer nova-ai from npm and restart in this session",
+    run(ctx) {
+      const message = ctx.requestUpdate();
+      if (message) ctx.print(message);
+    }
+  },
   {
     name: "mode",
-    description: "Switch interaction mode (/mode agent|ask|plan)",
+    description: "Switch interaction mode (/mode agent|ask|plan|<agent file>)",
     run(ctx, args) {
       const mode = args.trim();
       if (!mode) {
-        ctx.print(`Current mode: ${ctx.getInteractionMode()}`);
+        ctx.print(`Current mode: ${ctx.getInteractionMode()} (available: ${ctx.getInteractionModes().join(", ")})`);
         return;
       }
-      if (!isInteractionMode(mode)) {
-        ctx.print("Usage: /mode agent|ask|plan");
+      if (!ctx.getInteractionModes().includes(mode)) {
+        ctx.print(`Usage: /mode ${ctx.getInteractionModes().join("|")}`);
         return;
       }
       ctx.setInteractionMode(mode);
@@ -1920,8 +2000,8 @@ var builtinCommands = [
   {
     name: "trust",
     description: "Trust this workspace: start the MCP servers it declares and apply its .nova-ai allow rules",
-    run(ctx) {
-      ctx.print(ctx.trustWorkspace());
+    async run(ctx) {
+      ctx.print(await ctx.trustWorkspace());
     }
   },
   {
@@ -1937,6 +2017,16 @@ var builtinCommands = [
       ctx.openModelPicker();
     }
   },
+  {
+    name: "effort",
+    description: "Set how hard the model thinks (/effort <level>, or no args for a slider)",
+    available: (ctx) => ctx.hasThinkingLevels(),
+    async run(ctx, args) {
+      const level = args.trim();
+      if (level) ctx.print(await ctx.setEffort(level));
+      else await ctx.openEffortPicker();
+    }
+  },
   {
     name: "tools",
     description: "Inspect tool calls from this session",
@@ -1946,16 +2036,38 @@ var builtinCommands = [
   },
   {
     name: "mcp",
-    description: "Inspect configured MCP servers",
-    run(ctx) {
-      ctx.openMcpInspector();
+    description: "Inspect MCP servers, or sign in to one: /mcp login|logout <server>",
+    async run(ctx, args) {
+      const [action, ...rest] = args.trim().split(/\s+/).filter(Boolean);
+      const name = rest.join(" ");
+      if (!action) {
+        await ctx.openMcpInspector();
+        return;
+      }
+      if (action !== "login" && action !== "logout" || !name) {
+        ctx.print("Usage: /mcp, or /mcp login|logout <server>");
+        return;
+      }
+      if (action === "login") ctx.print(`Signing in to "${name}"\u2026 (waits up to 5 minutes for the browser)`);
+      ctx.print(await ctx.mcpSignIn(name, action === "login"));
     }
   },
   {
     name: "skills",
-    description: "Inspect discovered user and workspace skills",
-    run(ctx) {
-      ctx.openSkillInspector();
+    description: "List skills, or switch one: /skills on|off <name> [--global]",
+    async run(ctx, args) {
+      const words = args.trim().split(/\s+/).filter(Boolean);
+      if (!words.length) {
+        await ctx.openSkillInspector();
+        return;
+      }
+      const global = words.includes("--global");
+      const [action, name] = words.filter((word) => word !== "--global");
+      if (action !== "on" && action !== "off" || !name) {
+        ctx.print("Usage: /skills, or /skills on|off <name> [--global]");
+        return;
+      }
+      ctx.print(await ctx.switchSkill(name, action === "on", global));
     }
   },
   {
@@ -2124,8 +2236,8 @@ function formatJob(job) {
 
 // src/tui/commands/index.ts
 var COMMANDS = [...builtinCommands];
-function allCommands() {
-  return COMMANDS;
+function allCommands(ctx) {
+  return ctx ? COMMANDS.filter((c) => c.available?.(ctx) ?? true) : COMMANDS;
 }
 function findCommand(name) {
   return COMMANDS.find((c) => c.name === name);
@@ -2253,10 +2365,10 @@ console.log(ObjC.unwrap(png.base64EncodedStringWithOptions(0)));
 `;
 
 // src/tui/files/find-fd.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 var FD_CANDIDATES = ["fd", "fdfind"];
 var cachedPath;
-function resolveFdPath(run = (command, args) => spawnSync(command, args, { stdio: "ignore" })) {
+function resolveFdPath(run = (command, args) => spawnSync2(command, args, { stdio: "ignore" })) {
   if (cachedPath !== void 0) return cachedPath;
   for (const candidate of FD_CANDIDATES) {
     const result = run(candidate, ["--version"]);
@@ -2271,7 +2383,7 @@ function resolveFdPath(run = (command, args) => spawnSync(command, args, { stdio
 
 // src/tui/files/list-workspace-files.ts
 import { readdirSync } from "fs";
-import { join, relative as relative2, sep as sep2 } from "path";
+import { join as join2, relative as relative2, sep as sep3 } from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".nova-ai", "out", "coverage", ".next", ".turbo"]);
 function listWorkspaceFiles(cwd, max = 2e3) {
   const results = [];
@@ -2287,12 +2399,12 @@ function listWorkspaceFiles(cwd, max = 2e3) {
     for (const entry of entries) {
       if (results.length >= max) break;
       if (entry.isSymbolicLink()) continue;
-      const full = join(dir, entry.name);
+      const full = join2(dir, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         stack.push(full);
       } else if (entry.isFile()) {
-        results.push(relative2(cwd, full).split(sep2).join("/"));
+        results.push(relative2(cwd, full).split(sep3).join("/"));
       }
     }
   }
@@ -2323,7 +2435,7 @@ var DraftImageAttachments = class {
 import { spawn } from "child_process";
 import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { homedir } from "os";
-import { basename, dirname, join as join2 } from "path";
+import { basename, dirname as dirname2, join as join3 } from "path";
 var PATH_DELIMITERS = /* @__PURE__ */ new Set([" ", "	", '"', "'", "="]);
 var MAX_SUGGESTIONS2 = 20;
 var WorkspaceAutocompleteProvider = class {
@@ -2343,7 +2455,8 @@ var WorkspaceAutocompleteProvider = class {
     const mention = extractMentionPrefix(before);
     if (mention) return this.mentionSuggestions(mention, options.signal);
     if (cursorLine === 0 && before.startsWith("/") && !/\s/.test(before)) {
-      const items2 = filterCommands(this.commands, before.slice(1));
+      const commands = typeof this.commands === "function" ? this.commands() : this.commands;
+      const items2 = filterCommands(commands, before.slice(1));
       return items2.length ? { items: items2, prefix: before } : null;
     }
     if (!options.force) return null;
@@ -2404,14 +2517,14 @@ var WorkspaceAutocompleteProvider = class {
   pathSuggestions(prefix) {
     const quoted = prefix.startsWith('"');
     const raw = quoted ? prefix.slice(1) : prefix;
-    const expanded = raw === "~" || raw.startsWith("~/") ? join2(homedir(), raw.slice(1)) : raw;
+    const expanded = raw === "~" || raw.startsWith("~/") ? join3(homedir(), raw.slice(1)) : raw;
     const absolute = expanded.startsWith("/") || /^[A-Za-z]:[\\/]/.test(expanded);
     const separator = Math.max(raw.lastIndexOf("/"), raw.lastIndexOf("\\"));
     const listsDirectory = raw === "" || raw === "~" || separator === raw.length - 1;
-    const directoryPart = listsDirectory ? expanded : dirname(expanded);
+    const directoryPart = listsDirectory ? expanded : dirname2(expanded);
     const namePrefix = listsDirectory ? "" : basename(expanded);
     const displayDirectory = raw === "~" ? "~/" : separator >= 0 ? raw.slice(0, separator + 1) : "";
-    const searchDirectory = absolute ? directoryPart : join2(this.cwd, directoryPart);
+    const searchDirectory = absolute ? directoryPart : join3(this.cwd, directoryPart);
     let entries;
     try {
       entries = readdirSync2(searchDirectory, { withFileTypes: true });
@@ -2425,7 +2538,7 @@ var WorkspaceAutocompleteProvider = class {
       if (!isDirectory && entry.isSymbolicLink()) {
         try {
           isDirectory = statSync2(
-            join2(searchDirectory, entry.name)
+            join3(searchDirectory, entry.name)
           ).isDirectory();
         } catch {
         }
@@ -2561,6 +2674,7 @@ function walkWithFd(cwd, fdPath, query, signal) {
 }
 
 // src/tui/session/session-picker.ts
+import { listStoredSessions } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
 function listSessionsForCwd(cwd) {
   return listStoredSessions(cwd);
 }
@@ -2609,6 +2723,9 @@ function formatDateTime(updatedAt) {
   return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : "unknown";
 }
 
+// src/tui/ink/dialogs/state.ts
+import { OTHER_OPTION_ID } from "@datalabrotterdam/nova-ai-agent/core/user-questions.js";
+
 // src/tui/ink/editor/buffer.ts
 var segmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function boundaries(text) {
@@ -2862,6 +2979,40 @@ var SelectionState = class {
     return "changed";
   }
 };
+var SliderState = class {
+  constructor(levels, selected, onSelect, onCancel) {
+    this.levels = levels;
+    this.selected = selected;
+    this.onSelect = onSelect;
+    this.onCancel = onCancel;
+  }
+  levels;
+  selected;
+  onSelect;
+  onCancel;
+  handleKey(input, key) {
+    if (isCancel(input, key)) {
+      this.onCancel();
+      return "closed";
+    }
+    if (key.return) {
+      const level = this.levels[this.selected];
+      if (!level) return "ignored";
+      this.onSelect(level);
+      return "closed";
+    }
+    const last = this.levels.length - 1;
+    let next = this.selected;
+    if (key.leftArrow || key.downArrow) next = Math.max(0, this.selected - 1);
+    else if (key.rightArrow || key.upArrow) next = Math.min(last, this.selected + 1);
+    else if (key.home) next = 0;
+    else if (key.end) next = last;
+    else return "ignored";
+    if (next === this.selected) return "ignored";
+    this.selected = next;
+    return "changed";
+  }
+};
 var ScrollState = class {
   constructor(onClose) {
     this.onClose = onClose;
@@ -3110,6 +3261,9 @@ function permissionKey(request, input, key) {
   return "closed";
 }
 
+// src/tui/ink/controller.ts
+import { effortLabel } from "@datalabrotterdam/nova-ai-agent/core/model-capabilities.js";
+
 // src/tui/ink/editor/prompt-editor.ts
 var MAX_HISTORY = 200;
 var PromptEditor = class {
@@ -3545,17 +3699,11 @@ var TranscriptCommitter = class {
   planSignature = null;
   snapshot = null;
   lastState = null;
-  redrawRequested = false;
-  /** The next sync starts a new epoch, e.g. after the terminal width changed. */
-  requestRedraw() {
-    this.redrawRequested = true;
-    this.lastState = null;
-  }
   sync(state, expanded) {
     if (this.snapshot && state === this.lastState && expanded === this.expanded)
       return this.snapshot;
     this.lastState = state;
-    if (this.redrawRequested || state.sessionId !== this.sessionId || expanded !== this.expanded || !this.prefixIntact(state.messages)) {
+    if (state.sessionId !== this.sessionId || expanded !== this.expanded || !this.prefixIntact(state.messages)) {
       this.startEpoch(state, expanded);
     }
     const messages = state.messages;
@@ -3708,7 +3856,6 @@ var TranscriptCommitter = class {
     return true;
   }
   startEpoch(state, expanded) {
-    this.redrawRequested = false;
     this.epoch++;
     this.sessionId = state.sessionId;
     this.expanded = expanded;
@@ -3754,7 +3901,6 @@ function safeSplitOffset(text, from) {
 }
 
 // src/tui/ink/controller.ts
-var CLEAR_SCREEN_AND_SCROLLBACK = "\x1B[2J\x1B[3J\x1B[H";
 var EXIT_CONFIRM_MS = 2e3;
 var TuiController = class {
   constructor(store, runner, io) {
@@ -3779,6 +3925,8 @@ var TuiController = class {
   exiting = false;
   view;
   lastEpoch = 0;
+  scroll = 0;
+  viewport = { rows: 10, contentRows: 0 };
   exitArmed = false;
   exitTimer;
   animationTimer;
@@ -3790,6 +3938,8 @@ var TuiController = class {
   unsubscribeStore;
   resolveExit = () => {
   };
+  /** Set by /update: the caller installs and restarts after the TUI exits. */
+  updateRequested = false;
   /** Settles once the user asked to quit; `run` then tears the view down. */
   exitRequested = new Promise((resolve2) => {
     this.resolveExit = resolve2;
@@ -3800,7 +3950,7 @@ var TuiController = class {
   };
   getView = () => this.view;
   start() {
-    void this.runner.ensureUsableModel().then(() => this.refresh());
+    void this.runner.prepareSession().then(() => this.refresh());
     this.syncWindowTitle();
     this.animationTimer = setInterval(() => this.syncWindowTitle(true), 120);
     this.animationTimer.unref?.();
@@ -3835,8 +3985,17 @@ var TuiController = class {
         this.runner.cancel();
         return true;
       }
+      if (this.scroll > 0) {
+        this.scrollTo(0);
+        return true;
+      }
       return false;
     }
+    if (key.pageUp || key.pageDown) {
+      const page = Math.max(1, this.viewport.rows - 2);
+      this.scrollBy(key.pageUp ? page : -page);
+      return true;
+    }
     if (key.tab && key.shift) {
       this.cycleInteractionMode();
       return true;
@@ -3938,8 +4097,8 @@ var TuiController = class {
         "Models",
         models.map((model) => ({
           value: model.id,
-          label: model.id,
-          description: model.name ?? void 0
+          label: model.thinking ? `${model.id} \u25C6` : model.id,
+          description: [model.name, model.thinking ? "thinking" : null].filter(Boolean).join(" \xB7 ") || void 0
         })),
         "model-picker",
         (model) => this.setModel(model)
@@ -3948,6 +4107,58 @@ var TuiController = class {
       this.showText("Models", errorMessage(error, "Failed to list models."));
     }
   };
+  effortName() {
+    const level = this.runner.currentEffort();
+    const efforts = level ? this.runner.modelEffortLevels() : [];
+    return level ? effortLabel(level, efforts) : null;
+  }
+  /** The selected model's levels and current one, or why it has none. */
+  async effortLevels() {
+    let info;
+    try {
+      info = await this.runner.modelDetails();
+    } catch (error) {
+      return errorMessage(error, "Could not load the model list.");
+    }
+    const model = this.runner.model || "This model";
+    if (!info?.efforts.length) {
+      return info?.thinking ? `${model} thinks at a fixed depth; there is no level to choose.` : `${model} is not a thinking model; /model lists the ones marked \u25C6.`;
+    }
+    return { efforts: info.efforts, current: this.runner.currentEffort() ?? info.efforts[0] };
+  }
+  /** /effort: a slider over the selected model's levels. */
+  openEffort = async () => {
+    const levels = await this.effortLevels();
+    if (typeof levels === "string") {
+      this.showText("Thinking effort", levels);
+      return;
+    }
+    const state = new SliderState(
+      levels.efforts.map((value) => ({ value, label: effortLabel(value, levels.efforts) })),
+      Math.max(0, levels.efforts.indexOf(levels.current)),
+      (item) => {
+        this.closeOverlay();
+        this.runner.setEffort(item.value);
+        this.store.setState({ statusLine: `Thinking effort: ${item.label}.` });
+      },
+      this.closeOverlay
+    );
+    this.showOverlay({ kind: "slider", title: `Thinking effort \xB7 ${this.runner.model}`, state });
+  };
+  /** /effort <level>: by id ("high") or name ("Extra high", "off"). */
+  setEffort = async (level) => {
+    const levels = await this.effortLevels();
+    if (typeof levels === "string") return levels;
+    const wanted = level.trim().toLowerCase();
+    const value = levels.efforts.find(
+      (candidate) => candidate === wanted || effortLabel(candidate, levels.efforts).toLowerCase() === wanted
+    );
+    const names = levels.efforts.map((candidate) => effortLabel(candidate, levels.efforts).toLowerCase());
+    if (!value) return `${this.runner.model} has these levels: ${names.join(", ")}.`;
+    this.runner.setEffort(value);
+    this.refresh();
+    return `Thinking effort: ${effortLabel(value, levels.efforts)}.`;
+  };
   openPermissionModes = () => {
     const modes = [
       { value: "ask", label: "ask", description: "Prompt before tools make changes" },
@@ -4001,9 +4212,13 @@ ${result.output}${result.truncated ? "\n\n[output truncated]" : ""}`
       state: new ToolInspectorState(() => this.toolCalls(), this.closeOverlay)
     });
   };
-  openMcpInspector = () => {
-    const servers = this.runner.configuredMcpServers();
+  openMcpInspector = async () => {
+    if (!this.runner.sessionLoaded) {
+      this.showText("MCP servers", "Connecting MCP servers...");
+      await this.runner.prepareSession();
+    }
     const connection = this.runner.mcpSessionStatus();
+    const servers = connection.configured;
     const configuredNames = new Set(servers.map((server) => server.name));
     const configurationFailures = connection.failures.filter((failure) => !configuredNames.has(failure.serverName)).map((failure) => `${failure.serverName}
 status: failed - ${failure.message}`);
@@ -4016,15 +4231,40 @@ status: failed - ${failure.message}`);
       rows.length ? rows.join("\n\n") : "No MCP servers configured for this workspace.\n\nAdd a project .mcp.json or mcpServers to .nova-ai/settings.json; ACP connects them when the session starts."
     );
   };
-  openSkillInspector = () => {
-    const skills = this.runner.skillSessionStatus();
+  /** Every discovered skill with its state; switched-off skills stay listed. */
+  openSkillInspector = async () => {
+    let skills;
+    try {
+      skills = await this.runner.listSkills();
+    } catch (error) {
+      this.showText("Skills", errorMessage(error, "Could not list the skills."));
+      return;
+    }
+    const on = skills.filter((skill) => skill.enabled).length;
     this.showText(
-      `Skills (${skills.length})`,
-      skills.length ? skills.map((skill) => `${skill.name} [${skill.source}]
+      `Skills (${on} on, ${skills.length - on} off)`,
+      skills.length ? [
+        ...skills.map(
+          (skill) => `${skill.name} [${skill.bundledBy ? `bundled with ${skill.bundledBy}` : skill.source}]${skill.enabled ? "" : " (off)"}
 ${skill.description}
-${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents/skills, .claude/skills, or .codex/skills in the workspace or user profile."
+${skill.path}`
+        ),
+        "/skills off <name> switches one off in this project (--global: everywhere); /skills on <name> switches it back on."
+      ].join("\n\n") : "No skills discovered. Add SKILL.md under .nova-ai/skills (or .agents, .claude, .codex skills) in the workspace, or ~/.nova-ai/skills for all projects."
     );
   };
+  /** /skills on|off <name> [--global]: applies from the next message. */
+  switchSkill = async (name, enabled, global) => {
+    let skills;
+    try {
+      skills = await this.runner.setSkillEnabled(name, enabled, global);
+    } catch (error) {
+      const message = errorMessage(error, "Could not change the skill.");
+      return message.startsWith("No skill named") ? `${message} /skills lists them.` : message;
+    }
+    const stillOff = enabled && skills.some((skill) => skill.name === name && !skill.enabled);
+    return stillOff ? `Switched "${name}" on ${global ? "globally" : "in this project"}, but it is still off ${global ? "in this project" : "globally"} (use ${global ? "/skills on " + name : "/skills on " + name + " --global"}).` : `Skill "${name}" is ${enabled ? "on" : "off"} ${global ? "everywhere" : "in this project"} from the next message.`;
+  };
   openUsageInspector = async () => {
     this.showText("Context usage", "Calculating context usage...");
     try {
@@ -4035,14 +4275,23 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
     }
   };
   /**
-   * Prints the whole transcript again. After the width changed, the terminal
-   * re-wrapped what is on screen on its own and the live area can't be
-   * erased exactly (Ink leaves stale prompt borders), and old scrollback keeps
-   * the old wrapping.
+   * The view reports its transcript size after each layout. While scrolled
+   * up, new output below grows the offset so the rows being read stay put.
    */
-  redrawAll() {
-    if (this.stopped || this.exiting) return;
-    this.committer.requestRedraw();
+  setViewport(rows, contentRows) {
+    const grown = contentRows - this.viewport.contentRows;
+    this.viewport = { rows, contentRows };
+    this.scrollTo(this.scroll > 0 && grown > 0 ? this.scroll + grown : this.scroll);
+  }
+  /** Positive scrolls toward older output. */
+  scrollBy(rows) {
+    this.scrollTo(this.scroll + rows);
+  }
+  scrollTo(offset) {
+    const max = Math.max(0, this.viewport.contentRows - this.viewport.rows);
+    const next = Math.max(0, Math.min(offset, max));
+    if (next === this.scroll) return;
+    this.scroll = next;
     this.refresh();
   }
   toggleToolDetails() {
@@ -4067,8 +4316,8 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
     this.runner.setInteractionMode(mode);
   }
   cycleInteractionMode() {
-    const current = INTERACTION_MODES.indexOf(this.runner.interactionMode);
-    this.setInteractionMode(INTERACTION_MODES[(current + 1) % INTERACTION_MODES.length]);
+    const modes = this.runner.modeIds;
+    this.setInteractionMode(modes[(modes.indexOf(this.runner.interactionMode) + 1) % modes.length]);
   }
   appendAssistant(text) {
     this.store.setState((state) => ({
@@ -4091,26 +4340,60 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
     clear: () => void this.runner.startNewSession(),
     newSession: () => this.runner.startNewSession(),
     exit: () => this.requestExit(),
+    requestUpdate: () => {
+      const update = this.store.getState().updateAvailable;
+      if (!update) return "No newer nova-ai found on npm.";
+      if (!update.installable) {
+        return `nova-ai ${update.latestVersion} is available, but this copy wasn't installed with npm -g, so it can't update itself. Run: ${update.command}`;
+      }
+      if (this.store.getState().busy) {
+        return "Wait for the current request to finish (or press Esc), then run /update again.";
+      }
+      this.updateRequested = true;
+      this.requestExit();
+      return null;
+    },
     resumeSession: (sessionId) => {
       const id = sessionId ?? listSessionsForCwd(this.runner.cwd)[0]?.sessionId;
       return id ? this.runner.resumeFrom(id) : false;
     },
     openSessionSwitcher: this.openSessions,
     openModelPicker: () => void this.openModels(),
+    hasThinkingLevels: () => this.runner.hasThinkingLevels(),
+    openEffortPicker: () => this.openEffort(),
+    setEffort: (level) => this.setEffort(level),
     getModel: () => this.runner.model,
     setModel: (model) => this.setModel(model),
     getInteractionMode: () => this.runner.interactionMode,
+    getInteractionModes: () => this.runner.modeIds,
+    agentCommands: () => this.agentCommands(),
     setInteractionMode: (mode) => this.setInteractionMode(mode),
     getPermissionMode: () => this.store.getState().permissionMode,
     setPermissionMode: (mode) => this.setPermissionMode(mode),
     openPermissionPicker: this.openPermissionModes,
-    trustWorkspace: () => {
-      setWorkspaceTrusted(this.runner.cwd, true);
+    mcpSignIn: async (serverName, signIn) => {
+      try {
+        const status = await this.runner.mcpSignIn(serverName, signIn);
+        this.refresh();
+        const failure = status.failures.find((item) => item.serverName === serverName);
+        if (!signIn) return `Signed out of "${serverName}".`;
+        return failure ? `Signed in, but "${serverName}" did not connect: ${failure.message}` : `Signed in to "${serverName}"; its tools are available from the next message.`;
+      } catch (error) {
+        return errorMessage(error, signIn ? "Sign-in failed." : "Sign-out failed.");
+      }
+    },
+    trustWorkspace: async () => {
+      try {
+        await this.runner.trustWorkspace();
+      } catch (error) {
+        return errorMessage(error, "Could not trust the workspace.");
+      }
       return "Workspace trusted: its allow rules apply now; MCP servers it declares start with the next session (/clear).";
     },
     openToolInspector: this.openToolInspector,
     openMcpInspector: this.openMcpInspector,
     openSkillInspector: this.openSkillInspector,
+    switchSkill: this.switchSkill,
     openUsageInspector: this.openUsageInspector,
     steerMessage: (message) => this.runner.steer(message),
     queuedMessages: () => this.runner.queuedMessages(),
@@ -4125,10 +4408,15 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
     killBackgroundJob: (jobId) => this.runner.killBackgroundJob(jobId),
     releaseBackgroundJob: (jobId) => this.runner.releaseBackgroundJob(jobId)
   };
+  /** The agent's commands the CLI doesn't have itself; a hint is shown after the description. */
+  agentCommands() {
+    return this.runner.agentCommands.filter((command) => !findCommand(command.name)).map(({ name, description, hint }) => ({ name, description: hint ? `${description} ${hint}` : description }));
+  }
   // ------------------------------------------------------------ prompt
   submit = async (text, images = [], pastes = []) => {
     const value = text.trim();
     if (!value) return;
+    this.scroll = 0;
     this.editor.addToHistory(value);
     this.store.setState((state) => ({
       inputHistory: [...state.inputHistory, value],
@@ -4143,6 +4431,10 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
     const name = match?.[1] ?? "";
     const command = findCommand(name);
     if (!command) {
+      if (this.agentCommands().some((agentCommand) => agentCommand.name === name)) {
+        await this.runner.submit(value, images, pastes);
+        return;
+      }
       this.appendError(`Unknown command: /${name}`);
       return;
     }
@@ -4204,7 +4496,7 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
     const fdPath = resolveFdPath();
     editor.setAutocompleteProvider(
       new WorkspaceAutocompleteProvider(
-        allCommands().map((command) => ({
+        () => [...allCommands(this.commandContext), ...this.agentCommands()].map((command) => ({
           name: command.name,
           description: command.description
         })),
@@ -4230,7 +4522,10 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
     this.view = this.buildView();
     if (this.view.transcript.epoch !== this.lastEpoch) {
       this.lastEpoch = this.view.transcript.epoch;
-      this.io.write(CLEAR_SCREEN_AND_SCROLLBACK);
+      if (this.scroll) {
+        this.scroll = 0;
+        this.view = this.buildView();
+      }
     }
     for (const listener of this.listeners) listener();
   }
@@ -4242,9 +4537,11 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
       overlay: this.overlay,
       question: this.questionState(ui.pendingQuestion),
       model: this.runner.model,
+      effort: this.effortName(),
       mcp: mcpCounts(this.runner),
       expandedTools: this.expandedTools,
-      exiting: this.exiting
+      exiting: this.exiting,
+      scroll: this.scroll
     };
   }
   questionState(pending) {
@@ -4276,18 +4573,16 @@ ${skill.path}`).join("\n\n") : "No skills discovered. Add SKILL.md under .agents
   }
 };
 function formatMcpServer(server, status) {
-  const type = "type" in server ? server.type : "stdio";
-  const lines = [`${server.name} [${type}]`];
-  if ("url" in server) lines.push(`url: ${server.url}`);
-  if ("command" in server) {
+  const lines = [`${server.name} [${server.transport}]`];
+  if (server.url) lines.push(`url: ${server.url}`);
+  if (server.command) {
     lines.push(`command: ${server.command}`);
-    if (server.args.length) lines.push(`args: ${server.args.join(" ")}`);
-    if (server.env.length)
-      lines.push(`env: ${server.env.map((entry) => entry.name).join(", ")} (values hidden)`);
+    if (server.args?.length) lines.push(`args: ${server.args.join(" ")}`);
+    if (server.env?.length) lines.push(`env: ${server.env.join(", ")} (values hidden)`);
   }
   const failure = status.failures.find((item) => item.serverName === server.name);
   lines.push(
-    failure ? `status: failed - ${failure.message}` : status.connected.includes(server.name) ? "status: connected" : "status: configured; connection starts with the ACP session"
+    failure?.needsAuth ? `status: needs sign-in - /mcp login ${server.name}` : failure ? `status: failed - ${failure.message}` : status.connected.includes(server.name) ? "status: connected" : "status: configured; connection starts with the ACP session"
   );
   return lines.join("\n");
 }
@@ -4308,12 +4603,13 @@ function errorMessage(error, fallback) {
 import { Box as Box5, Text as Text5, useInput as useInput2, usePaste as usePaste2 } from "ink";
 import stringWidth2 from "string-width";
 import { useMemo, useState } from "react";
+import { OTHER_OPTION_ID as OTHER_OPTION_ID2 } from "@datalabrotterdam/nova-ai-agent/core/user-questions.js";
 import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function useDialogInput(handle, isActive) {
   const [, setTick] = useState(0);
   useInput2(
     (input, key) => {
-      if (handle(input, key) === "changed") setTick((tick) => tick + 1);
+      if (!isMouseInput(input) && handle(input, key) === "changed") setTick((tick) => tick + 1);
     },
     { isActive }
   );
@@ -4325,6 +4621,25 @@ function Frame({ title, children, footer }) {
     footer ? /* @__PURE__ */ jsx5(Text5, { color: palette.faint, wrap: "truncate-end", children: footer }) : null
   ] });
 }
+function SliderDialog({
+  title,
+  state,
+  isActive = true
+}) {
+  useDialogInput((input, key) => state.handleKey(input, key), isActive);
+  const current = state.levels[state.selected];
+  return /* @__PURE__ */ jsxs5(Frame, { title, footer: "\u2190\u2192 adjust \xB7 Enter apply \xB7 Esc cancel", children: [
+    /* @__PURE__ */ jsx5(Text5, { wrap: "truncate-end", children: state.levels.map((level, index) => {
+      const selected = index === state.selected;
+      return /* @__PURE__ */ jsxs5(Text5, { children: [
+        index > 0 ? /* @__PURE__ */ jsx5(Text5, { color: palette.faint, children: " \u2500\u2500 " }) : null,
+        /* @__PURE__ */ jsx5(Text5, { color: selected ? palette.primary : palette.faint, children: selected ? "\u25CF " : "\u25CB " }),
+        /* @__PURE__ */ jsx5(Text5, { bold: selected, color: selected ? void 0 : palette.muted, children: level.label })
+      ] }, level.value);
+    }) }),
+    current?.description ? /* @__PURE__ */ jsx5(Text5, { color: palette.muted, children: current.description }) : null
+  ] });
+}
 function SelectionDialog({
   title,
   state,
@@ -4455,7 +4770,7 @@ function QuestionDialog({
   const [, setTick] = useState(0);
   useInput2(
     (input, key) => {
-      if (state.handleKey(input, key) === "changed") setTick((tick) => tick + 1);
+      if (!isMouseInput(input) && state.handleKey(input, key) === "changed") setTick((tick) => tick + 1);
     },
     { isActive }
   );
@@ -4520,7 +4835,7 @@ function QuestionDialog({
           /* @__PURE__ */ jsxs5(Text5, { wrap: "truncate-end", children: [
             /* @__PURE__ */ jsx5(Text5, { color: palette.primary, children: state.selected === otherIndex ? ">" : " " }),
             " ",
-            state.isSelected(question.id, OTHER_OPTION_ID) ? /* @__PURE__ */ jsx5(Text5, { color: palette.success, children: "[x]" }) : "[ ]",
+            state.isSelected(question.id, OTHER_OPTION_ID2) ? /* @__PURE__ */ jsx5(Text5, { color: palette.success, children: "[x]" }) : "[ ]",
             " ",
             otherAnswer ? `Other: ${otherAnswer}` : "Other... (write your own answer)"
           ] }),
@@ -4537,7 +4852,7 @@ function PermissionDialog({
 }) {
   useInput2(
     (input, key) => {
-      if (permissionKey(request, input, key) === "closed") onClose();
+      if (!isMouseInput(input) && permissionKey(request, input, key) === "closed") onClose();
     },
     { isActive }
   );
@@ -4588,9 +4903,8 @@ function wrapPlain(text, width) {
 }
 
 // src/tui/ink/app.tsx
-import { Fragment as Fragment4, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 var FRAME_MS = 120;
-var RESIZE_SETTLE_MS = 100;
 async function runInkTui(credentials, cwd, args, options = {}) {
   const store = createStore({
     messages: [],
@@ -4632,22 +4946,15 @@ async function runInkTui(credentials, cwd, args, options = {}) {
     // Ink otherwise turns non-interactive whenever CI is set in the
     // environment; the TUI only runs on a terminal anyway.
     interactive: Boolean(stdout.isTTY),
+    // Full screen: the transcript scrolls inside the app (PgUp/PgDn) and the
+    // terminal gets its own screen back on exit.
+    alternateScreen: Boolean(stdout.isTTY),
     kittyKeyboard: { mode: kittyKeyboard ? "enabled" : "disabled" }
   });
   controller.start();
+  if (stdout.isTTY) stdout.write(MOUSE_REPORTING_ON);
   const onSignal = () => controller.requestExit();
   process.once("SIGTERM", onSignal);
-  let printedColumns = stdout.columns;
-  let resizeTimer;
-  const onResize = () => {
-    if (resizeTimer) clearTimeout(resizeTimer);
-    resizeTimer = setTimeout(() => {
-      if (stdout.columns === printedColumns) return;
-      printedColumns = stdout.columns;
-      controller.redrawAll();
-    }, RESIZE_SETTLE_MS);
-  };
-  stdout.on("resize", onResize);
   void (options.checkForUpdate ?? checkForUpdate)().then((updateAvailable) => {
     if (updateAvailable) store.setState({ updateAvailable });
   });
@@ -4657,45 +4964,99 @@ async function runInkTui(credentials, cwd, args, options = {}) {
     await controller.stop();
   } finally {
     process.off("SIGTERM", onSignal);
-    stdout.off("resize", onResize);
-    if (resizeTimer) clearTimeout(resizeTimer);
+    if (stdout.isTTY) stdout.write(MOUSE_REPORTING_OFF);
     instance.unmount();
     await instance.waitUntilExit().catch(() => {
     });
   }
   stdout.write(`Resume this session with: nova-ai --resume ${runner.sessionId}
 `);
+  return { sessionId: runner.sessionId, updateRequested: controller.updateRequested };
 }
 function App({ controller }) {
   const view = useSyncExternalStore2(controller.subscribe, controller.getView);
   const { rows, columns } = useWindowSize();
   const bottomRef = useRef(null);
   const bottom = useBoxMetrics(bottomRef);
+  const contentRef = useRef(null);
+  const content = useBoxMetrics(contentRef);
   const working = useWorking(view);
+  const [userTops, setUserTops] = useState2(/* @__PURE__ */ new Map());
+  useInput3((input) => {
+    const rows2 = wheelRows(input);
+    if (rows2) controller.scrollBy(rows2);
+  });
+  const height = Math.max(4, rows - 1);
+  const viewportRows = Math.max(3, height - (bottom.hasMeasured ? bottom.height : 6));
+  useEffect(() => {
+    if (content.hasMeasured) controller.setViewport(viewportRows, content.height);
+  }, [controller, viewportRows, content.hasMeasured, content.height]);
+  if (view.exiting) return null;
   const { transcript } = view;
-  const scrollback = (
-    // <Static> is laid out as an absolute box; without a width its text
-    // wraps against its content and runs past the terminal edge.
-    /* @__PURE__ */ jsx6(Static, { items: [...transcript.committed], style: { width: columns }, children: (block) => /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(TranscriptBlockView, { block }) }, block.key) }, transcript.epoch)
-  );
-  if (view.exiting) return scrollback;
-  const liveRows = Math.max(3, rows - (bottom.hasMeasured ? bottom.height : 6) - 2);
-  const dialogRows = Math.max(6, rows - 4);
-  return /* @__PURE__ */ jsxs6(Fragment4, { children: [
-    scrollback,
-    /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", maxHeight: liveRows, overflowY: "hidden", justifyContent: "flex-end", children: /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", flexShrink: 0, children: [
-      transcript.live.map((block) => /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(TranscriptBlockView, { block, frame: working.frame }) }, block.key)),
-      working.line ? /* @__PURE__ */ jsx6(Box6, { marginTop: 1, paddingLeft: 1, children: /* @__PURE__ */ jsxs6(Text6, { children: [
-        /* @__PURE__ */ jsx6(Text6, { color: palette.accent, children: WORKING_FRAMES[working.frame] }),
-        /* @__PURE__ */ jsx6(Text6, { color: palette.muted, children: ` ${working.line}` })
-      ] }) }) : null
-    ] }) }),
-    /* @__PURE__ */ jsxs6(Box6, { ref: bottomRef, flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx6(Surface, { controller, view, rows: dialogRows, columns }),
-      /* @__PURE__ */ jsx6(StatusLine, { ui: view.ui, model: view.model, mcp: view.mcp })
+  const blocks = [...transcript.committed, ...transcript.live];
+  const liveKeys = new Set(transcript.live.map((block) => block.key));
+  const onUserTop = (key, top) => setUserTops((tops) => tops.get(key) === top ? tops : new Map(tops).set(key, top));
+  const firstVisibleRow = content.height - viewportRows - view.scroll;
+  let sticky = null;
+  for (const block of blocks) {
+    if (block.kind !== "user") continue;
+    const top = userTops.get(block.key);
+    if (top !== void 0 && top < firstVisibleRow) sticky = block.text;
+  }
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height, children: [
+    /* @__PURE__ */ jsxs6(
+      Box6,
+      {
+        flexDirection: "column",
+        height: viewportRows,
+        flexShrink: 0,
+        overflowY: "hidden",
+        justifyContent: "flex-end",
+        children: [
+          /* @__PURE__ */ jsxs6(Box6, { ref: contentRef, flexDirection: "column", flexShrink: 0, marginBottom: -view.scroll, children: [
+            blocks.map(
+              (block) => liveKeys.has(block.key) ? /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(TranscriptBlockView, { block, frame: working.frame }) }, block.key) : /* @__PURE__ */ jsx6(CommittedBlock, { block, onUserTop }, block.key)
+            ),
+            working.line ? /* @__PURE__ */ jsx6(Box6, { marginTop: 1, paddingLeft: 1, children: /* @__PURE__ */ jsxs6(Text6, { children: [
+              /* @__PURE__ */ jsx6(Text6, { color: palette.accent, children: WORKING_FRAMES[working.frame] }),
+              /* @__PURE__ */ jsx6(Text6, { color: palette.muted, children: ` ${working.line}` })
+            ] }) }) : null
+          ] }),
+          sticky !== null ? /* @__PURE__ */ jsx6(StickyPrompt, { text: sticky, columns }) : null
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs6(Box6, { ref: bottomRef, flexDirection: "column", flexShrink: 0, children: [
+      /* @__PURE__ */ jsx6(Surface, { controller, view, rows: Math.max(6, rows - 4), columns }),
+      /* @__PURE__ */ jsx6(StatusLine, { ui: view.ui, model: view.model, effort: view.effort, mcp: view.mcp, scroll: view.scroll })
     ] })
   ] });
 }
+var CommittedBlock = memo(function CommittedBlock2({
+  block,
+  onUserTop
+}) {
+  if (block.kind !== "user") {
+    return /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(TranscriptBlockView, { block }) });
+  }
+  return /* @__PURE__ */ jsx6(UserAnchor, { block, onUserTop, children: /* @__PURE__ */ jsx6(TranscriptBlockView, { block }) });
+}, (before, after) => before.block === after.block);
+function UserAnchor({
+  block,
+  onUserTop,
+  children
+}) {
+  const ref = useRef(null);
+  const { top, hasMeasured } = useBoxMetrics(ref);
+  useEffect(() => {
+    if (hasMeasured) onUserTop(block.key, top);
+  }, [block.key, top, hasMeasured]);
+  return /* @__PURE__ */ jsx6(Box6, { ref, marginTop: 1, children });
+}
+function StickyPrompt({ text, columns }) {
+  const line = `> ${text.replace(/\s+/g, " ").trim()}`;
+  return /* @__PURE__ */ jsx6(Box6, { position: "absolute", top: 0, left: 0, width: columns, children: /* @__PURE__ */ jsx6(Text6, { color: palette.primary, backgroundColor: palette.stickyBackground, wrap: "truncate-end", children: line.padEnd(columns) }) });
+}
 function Surface({
   controller,
   view,
@@ -4710,6 +5071,7 @@ function Surface({
   const overlay = view.overlay;
   if (overlay?.kind === "selection")
     return /* @__PURE__ */ jsx6(SelectionDialog, { title: overlay.title, state: overlay.state, height: rows });
+  if (overlay?.kind === "slider") return /* @__PURE__ */ jsx6(SliderDialog, { title: overlay.title, state: overlay.state });
   if (overlay?.kind === "text")
     return /* @__PURE__ */ jsx6(
       ScrollPanel,
@@ -4756,17 +5118,28 @@ function useWorking(view) {
 }
 
 // src/tui/index.ts
+import { workspaceNeedsTrust } from "@datalabrotterdam/nova-ai-agent/core/workspace-mcp.js";
 async function runChat(options) {
   const stored = readCredentials();
   if (!stored) {
     console.error("nova-ai isn't connected to a Nova AI account yet. Run `nova-ai login` first.");
     return 1;
   }
-  const credentials = options.model ? { ...stored, defaultModel: options.model } : stored;
+  const model = options.model ?? stored.defaultModel ?? process.env.NOVA_MODEL;
+  const credentials = { ...stored, defaultModel: model };
+  const updateCheck = checkForUpdate().then((update) => withInstallability(update));
+  const updatedFrom = process.env[UPDATED_FROM_ENV];
+  if (updatedFrom) {
+    delete process.env[UPDATED_FROM_ENV];
+    console.log(`Updated nova-ai ${updatedFrom} \u2192 ${cliVersion() ?? "?"}.`);
+  } else {
+    const restartedCode = await offerUpdateAtStart(updateCheck, process.argv.slice(2));
+    if (restartedCode !== null) return restartedCode;
+  }
   const cwd = process.cwd();
   let resume = options.resume;
   if (options.continueLast) {
-    resume = listStoredSessions(cwd)[0]?.sessionId ?? null;
+    resume = listStoredSessions2(cwd)[0]?.sessionId ?? null;
     if (!resume) {
       console.error(`No earlier session in ${cwd} to continue.`);
       return 1;
@@ -4774,11 +5147,22 @@ async function runChat(options) {
   }
   if (workspaceNeedsTrust(cwd)) await askToTrust(cwd);
   const args = resume ? ["--resume", resume] : [];
-  await runInkTui(credentials, cwd, args);
+  const result = await runInkTui(credentials, cwd, args, { checkForUpdate: () => updateCheck });
+  if (result.updateRequested) {
+    const update = await updateCheck;
+    if (update) {
+      const restartArgs = [
+        ...loadStoredSession2(result.sessionId) ? ["--resume", result.sessionId] : [],
+        ...options.model ? ["--model", options.model] : []
+      ];
+      const restartedCode = installAndRestart(update, restartArgs);
+      if (restartedCode !== null) return restartedCode;
+    }
+  }
   return 0;
 }
 async function askToTrust(cwd) {
-  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     console.log(`
 ${cwd}`);