@datalabrotterdam/nova-ai-cli 1.2.0-alpha.5 → 1.2.0-alpha.7

package/dist/{tui-4XTC6VJP.js → tui-HJQOYGHL.js}

@@ -9,21 +9,14 @@ import {
 } from "./chunk-FMHWW3E6.js";
 import {
   TuiAcpClient,
-  createStore,
-  readWorkspaceMcpConfiguration,
-  workspaceNeedsTrust
-} from "./chunk-NHGIUEIR.js";
+  createStore
+} from "./chunk-EOPM4RRE.js";
 
 // src/tui/index.ts
 import { createInterface as createInterface2 } from "readline/promises";
-import {
-  readCredentials,
-  saveDefaultModel as saveDefaultModel2
-} from "@datalabrotterdam/nova-ai-agent/core/credentials.js";
-import { resolveDefaultModel as resolveDefaultModel2 } from "@datalabrotterdam/nova-ai-agent/core/model-capabilities.js";
-import { createNovaClient as createNovaClient2 } from "@datalabrotterdam/nova-ai-agent/core/nova-client.js";
+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 as setWorkspaceTrusted2 } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
+import { setWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
 
 // src/update-install.ts
 import { spawnSync } from "child_process";
@@ -126,27 +119,18 @@ import { savedPermissionMode } from "@datalabrotterdam/nova-ai-agent/core/policy
 
 // src/tui/session/session-runner.ts
 import * as acp from "@agentclientprotocol/sdk";
-import {
-  NovaAIError
-} from "@datalabrotterdam/nova-sdk";
-import { createNovaClient } from "@datalabrotterdam/nova-ai-agent/core/nova-client.js";
 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 { saveDefaultModel } from "@datalabrotterdam/nova-ai-agent/core/credentials.js";
+import {
+  saveDefaultEffort,
+  saveDefaultModel
+} from "@datalabrotterdam/nova-ai-agent/core/credentials.js";
 import {
   savePermissionMode
 } from "@datalabrotterdam/nova-ai-agent/core/policy/settings.js";
 import { loadStoredSession } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
-import { discoverSkills } from "@datalabrotterdam/nova-ai-agent/core/skills.js";
-import {
-  resolveModelContextWindow
-} from "@datalabrotterdam/nova-ai-agent/core/context-compaction.js";
-import {
-  chatModels,
-  resolveDefaultModel,
-  resolveModelSupportsImageInput
-} from "@datalabrotterdam/nova-ai-agent/core/model-capabilities.js";
+import { resolveEffort } from "@datalabrotterdam/nova-ai-agent/core/model-capabilities.js";
 
 // src/tui/files/file-mentions.ts
 import { statSync } from "fs";
@@ -291,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,
@@ -314,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();
   }
@@ -331,21 +301,22 @@ 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, 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;
@@ -353,10 +324,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) {
@@ -369,15 +340,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,
@@ -396,12 +359,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;
@@ -409,6 +373,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(() => {
       });
@@ -521,9 +486,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 })),
@@ -534,27 +496,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(
@@ -570,13 +542,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
@@ -634,27 +601,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 {
       }
@@ -662,14 +636,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) {
@@ -793,7 +794,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." });
@@ -947,13 +948,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;
@@ -961,6 +962,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(() => {
     });
@@ -975,10 +977,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"
@@ -986,26 +998,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"];
@@ -1023,14 +1024,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 });
@@ -1044,7 +1065,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) {
@@ -1500,6 +1521,7 @@ import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-run
 function StatusLine({
   ui,
   model,
+  effort = null,
   mcp,
   scroll = 0
 }) {
@@ -1510,6 +1532,7 @@ function StatusLine({
     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,
@@ -1852,24 +1875,14 @@ function PlanView({
   ] });
 }
 
-// src/tui/ink/controller.ts
-import { setWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
-import {
-  disabledSkillNames,
-  discoverSkills as discoverSkills2,
-  setSkillEnabled
-} from "@datalabrotterdam/nova-ai-agent/core/skills.js";
-import { INTERACTION_MODES } from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
-
 // src/tui/commands/builtins.ts
-import { isInteractionMode } from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
 var permissionModes = ["ask", "acceptEdits", "bypassAll"];
 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).map((c) => `/${c.name} \u2014 ${c.description}`);
       ctx.print(lines.join("\n"));
     }
   },
@@ -1950,15 +1963,15 @@ var builtinCommands = [
   },
   {
     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);
@@ -1983,8 +1996,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());
     }
   },
   {
@@ -2000,6 +2013,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",
@@ -2009,18 +2032,29 @@ 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: "List skills, or switch one: /skills on|off <name> [--global]",
-    run(ctx, args) {
+    async run(ctx, args) {
       const words = args.trim().split(/\s+/).filter(Boolean);
       if (!words.length) {
-        ctx.openSkillInspector();
+        await ctx.openSkillInspector();
         return;
       }
       const global = words.includes("--global");
@@ -2029,7 +2063,7 @@ var builtinCommands = [
         ctx.print("Usage: /skills, or /skills on|off <name> [--global]");
         return;
       }
-      ctx.print(ctx.switchSkill(name, action === "on", global));
+      ctx.print(await ctx.switchSkill(name, action === "on", global));
     }
   },
   {
@@ -2198,8 +2232,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);
@@ -2417,7 +2451,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;
@@ -2940,6 +2975,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;
@@ -3188,6 +3257,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 {
@@ -3874,7 +3946,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?.();
@@ -4021,8 +4093,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)
@@ -4031,6 +4103,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" },
@@ -4084,9 +4208,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}`);
@@ -4100,16 +4228,20 @@ status: failed - ${failure.message}`);
     );
   };
   /** Every discovered skill with its state; switched-off skills stay listed. */
-  openSkillInspector = () => {
-    const cwd = this.runner.cwd;
-    const skills = discoverSkills2(cwd);
-    const disabled = disabledSkillNames(cwd);
-    const on = skills.filter((skill) => !disabled.has(skill.name)).length;
+  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 (${on} on, ${skills.length - on} off)`,
       skills.length ? [
         ...skills.map(
-          (skill) => `${skill.name} [${skill.source}]${disabled.has(skill.name) ? " (off)" : ""}
+          (skill) => `${skill.name} [${skill.bundledBy ? `bundled with ${skill.bundledBy}` : skill.source}]${skill.enabled ? "" : " (off)"}
 ${skill.description}
 ${skill.path}`
         ),
@@ -4118,17 +4250,15 @@ ${skill.path}`
     );
   };
   /** /skills on|off <name> [--global]: applies from the next message. */
-  switchSkill = (name, enabled, global) => {
-    const cwd = this.runner.cwd;
-    if (!discoverSkills2(cwd).some((skill) => skill.name === name)) {
-      return `No skill named "${name}". /skills lists them.`;
-    }
+  switchSkill = async (name, enabled, global) => {
+    let skills;
     try {
-      setSkillEnabled(cwd, global ? "global" : "project", name, enabled);
+      skills = await this.runner.setSkillEnabled(name, enabled, global);
     } catch (error) {
-      return errorMessage(error, "Could not change the skill.");
+      const message = errorMessage(error, "Could not change the skill.");
+      return message.startsWith("No skill named") ? `${message} /skills lists them.` : message;
     }
-    const stillOff = enabled && disabledSkillNames(cwd).has(name);
+    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 () => {
@@ -4182,8 +4312,8 @@ ${skill.path}`
     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) => ({
@@ -4225,15 +4355,34 @@ ${skill.path}`
     },
     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,
     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,
@@ -4334,7 +4483,7 @@ ${skill.path}`
     const fdPath = resolveFdPath();
     editor.setAutocompleteProvider(
       new WorkspaceAutocompleteProvider(
-        allCommands().map((command) => ({
+        () => allCommands(this.commandContext).map((command) => ({
           name: command.name,
           description: command.description
         })),
@@ -4375,6 +4524,7 @@ ${skill.path}`
       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,
@@ -4410,18 +4560,16 @@ ${skill.path}`
   }
 };
 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");
 }
@@ -4460,6 +4608,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,
@@ -4848,7 +5015,7 @@ function App({ controller }) {
     ),
     /* @__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, mcp: view.mcp, scroll: view.scroll })
+      /* @__PURE__ */ jsx6(StatusLine, { ui: view.ui, model: view.model, effort: view.effort, mcp: view.mcp, scroll: view.scroll })
     ] })
   ] });
 }
@@ -4891,6 +5058,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,
@@ -4937,19 +5105,14 @@ 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 model = options.model ?? stored.defaultModel ?? process.env.NOVA_MODEL ?? await pickDefaultModel(stored);
-  if (!model) {
-    console.error("nova-ai has no model to use yet. Start it with one, for example:");
-    console.error("  nova-ai --model <model-id>     (or set NOVA_MODEL)");
-    console.error("Then Ctrl+P in nova-ai switches and remembers the model.");
-    return 1;
-  }
+  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];
@@ -4985,19 +5148,6 @@ async function runChat(options) {
   }
   return 0;
 }
-async function pickDefaultModel(credentials) {
-  try {
-    const { data } = await createNovaClient2(credentials.apiKey).models.list({ limit: 100 });
-    const model = resolveDefaultModel2(data, void 0);
-    if (model) {
-      saveDefaultModel2(model);
-      console.log(`Using model ${model} (Ctrl+P switches).`);
-    }
-    return model;
-  } catch {
-    return void 0;
-  }
-}
 async function askToTrust(cwd) {
   const prompt = createInterface2({ input: process.stdin, output: process.stdout });
   try {
@@ -5007,7 +5157,7 @@ ${cwd}`);
     console.log("Trusting it starts those servers and applies those rules. Only trust code you know.");
     const answer = (await prompt.question("Trust this workspace? [y/N] ")).trim().toLowerCase();
     if (answer === "y" || answer === "yes") {
-      setWorkspaceTrusted2(cwd, true);
+      setWorkspaceTrusted(cwd, true);
     } else {
       console.log("Not trusted: its MCP servers stay off and its allow rules are ignored. Use /trust later to change this.");
     }