@datalabrotterdam/nova-ai-cli 1.2.0-alpha.6 → 1.2.0-alpha.8

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+# [@datalabrotterdam/nova-ai-cli-v1.2.0-alpha.8](https://github.com/Datalab-Rotterdam/nova-ai-cli/compare/@datalabrotterdam/nova-ai-cli@1.2.0-alpha.7...@datalabrotterdam/nova-ai-cli@1.2.0-alpha.8) (2026-10-24)
+
+
+### Features
+
+* slash commands from markdown files ([305f111](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/305f1112c6f8312ab8a0683954c4e5bc88d7b952))
+
+# [@datalabrotterdam/nova-ai-cli-v1.2.0-alpha.7](https://github.com/Datalab-Rotterdam/nova-ai-cli/compare/@datalabrotterdam/nova-ai-cli@1.2.0-alpha.6...@datalabrotterdam/nova-ai-cli@1.2.0-alpha.7) (2026-10-24)
+
+
+### Features
+
+* **agent:** Claude Code compatible hooks ([227fe8b](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/227fe8b273ec2e211e9d57674e76af5c42a473bd))
+* **agent:** install the shared Nova skills ([64139dd](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/64139dd612933343f04f165de1a9ab78832d6864))
+* **agent:** mark and protect bundled skills ([6ef52eb](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/6ef52eb6d048f8a3b4e75686244aabcfd0f62d6e))
+* **agent:** thinking effort for reasoning models ([8551fea](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/8551feacff3e1675f369030e20fb2b5071f0db7f))
+* **agent:** web_search tool ([12985eb](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/12985eb9ca06d6c814d4e0162465c651889d9370))
+* **cli:** /effort slider for thinking models ([8ca67f2](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/8ca67f2f5dcc8f6bff8c36409a2baba5d43c4a02))
+* **cli:** remember the thinking level ([883196c](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/883196c9fdb089f4f26ac82b557cc87dfc0b1c0b))
+* OAuth sign-in for MCP servers ([ba57c79](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/ba57c79642f902ab2bc20f59e4627fb2b774bb4a))
+* the user's agent files as session modes ([3386de8](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/3386de88d07b0351bd1e44960fcacfef26e3d45b))
+
 # [@datalabrotterdam/nova-ai-cli-v1.2.0-alpha.6](https://github.com/Datalab-Rotterdam/nova-ai-cli/compare/@datalabrotterdam/nova-ai-cli@1.2.0-alpha.5...@datalabrotterdam/nova-ai-cli@1.2.0-alpha.6) (2026-10-23)
 
 

package/README.md

@@ -79,6 +79,8 @@ row. To select text, hold Shift (Option in some macOS terminals) while dragging.
 
 - **Modes** (Shift+Tab): `agent` does the work; `plan` reads the code, asks
   questions and builds a task list but changes nothing; `ask` only answers.
+  Your own agents (`~/.nova-ai/agents/<name>.agent.md`, the format the VS Code
+  extension uses) are extra modes after these; `/mode` lists them.
 - **Permissions**: before an edit or command you choose once, for this
   session, always (saved as an exact rule) or deny. Ctrl+K switches between
   asking, accepting edits, and bypass (never remembered).
@@ -95,15 +97,18 @@ row. To select text, hold Shift (Option in some macOS terminals) while dragging.
 | Enter / Shift+Enter | Send / new line (Shift+Enter where the terminal supports the kitty keyboard protocol: VS Code, kitty, WezTerm, Ghostty, foot, Alacritty, recent iTerm2; Alt+Enter, Ctrl+J or a trailing `\` work everywhere) |
 | Esc | Cancel the running turn |
 | Ctrl+C twice | Exit; prints `nova-ai --resume <id>` |
-| Shift+Tab | Cycle agent / ask / plan |
+| Shift+Tab | Cycle agent / ask / plan and your own agents |
 | Ctrl+R / Ctrl+P / Ctrl+K | Sessions / models / permission mode |
 | Ctrl+O / Ctrl+T / Ctrl+B | Verbose tool output / tool inspector / background jobs |
 | Alt+V | Paste a clipboard image |
 
-Slash commands: `/help`, `/model`, `/mode`, `/permission`, `/session`,
+Slash commands: `/help`, `/model`, `/effort` (thinking models), `/mode`, `/permission`, `/session`,
 `/resume`, `/clear`, `/compact`, `/rewind [n]`, `/queue`, `/steer`, `/usage`,
 `/tools`, `/mcp`, `/skills`, `/shell` and `/agent` (background jobs), `/trust`
-and `/exit`. Details:
+and `/exit`. Your own commands are markdown files in `~/.nova-ai/commands/` or
+the repository's `.nova-ai/commands/` (Claude Code's format, so
+`.claude/commands` works too): the file is the prompt, `$ARGUMENTS` what you
+type after the command, and they show up in the `/` menu. Details:
 [`src/tui/README.md`](https://github.com/Datalab-Rotterdam/nova-ai-cli/blob/main/packages/cli/src/tui/README.md).
 
 ## Headless
@@ -169,7 +174,10 @@ need ACP. Everything is documented in
   and nested shells need an exact rule.
 - **Web pages are fetched only with approval.** `fetch_url` asks every time
   unless a rule allows that URL (a URL can carry data out), and a redirect to
-  another site needs its own approval.
+  another site needs its own approval. `web_search` asks the same way, since
+  the query goes to the search providers (You.com, DuckDuckGo; your own
+  SearXNG server first when `~/.nova-ai/settings.json` has
+  `"webSearch": { "searxngUrl": "https://…" }`).
 - **File access stays in the workspace** (symlinks resolved); commands run in
   their own process group with a timeout, and the whole tree is stopped on
   cancel.
@@ -194,7 +202,22 @@ VS Code extension: settings, per-project trust, sessions and memory.
   skills folders are read too). `/skills` lists them; `/skills off <name>`
   switches one off in this project (`--global`: everywhere). Only names and
   short descriptions go into the prompt; Nova loads a skill when it fits.
+  Nova installs its own skills for Word, Excel, PowerPoint and PDF files
+  (`nova-docx`, `nova-xlsx`, `nova-pptx`, `nova-pdf`, from
+  [nova-ai-skills](https://github.com/Datalab-Rotterdam/nova-ai-skills)) in
+  `~/.nova-ai/skills` and keeps them up to date; they need Python 3.
+- **Hooks**: Claude Code's `hooks` format in the same settings files (a
+  repository's own only once you trust the workspace): `PreToolUse`,
+  `PostToolUse`, `UserPromptSubmit`, `SessionStart` and `Stop`, with Claude
+  Code's tool names as matchers, so hooks from `.claude/settings.json` work
+  when copied over.
 - **MCP servers**: `.mcp.json` or `mcpServers` in `.nova-ai/settings.json`.
+  HTTP servers that use OAuth show "needs sign-in" in `/mcp`; `/mcp login
+  <server>` opens the sign-in page in your browser (tokens are kept in
+  `~/.nova-ai/mcp-auth`, refreshed automatically), `/mcp logout <server>`
+  forgets them. A server that wants a client registered by hand takes
+  `"oauth": { "clientId", "clientSecret", "scope", "callbackPort" }` in
+  `.mcp.json`.
 
 The complete layout and rule syntax: [docs/NOVA_HOME.md](https://github.com/Datalab-Rotterdam/nova-ai-cli/blob/main/docs/NOVA_HOME.md).
 
@@ -207,6 +230,12 @@ to a text protocol for models that don't support it. When the context window
 fills up, older messages are summarized automatically (`/compact` does it by
 hand).
 
+Thinking models are marked ◆ in the model list. For those with levels the
+status line shows the current one (`· thinking medium`) and `/effort` opens a
+slider (←/→, Enter), or sets one directly (`/effort high`, `/effort off`). The
+choice is remembered like the model; a model without that level uses its own
+default.
+
 | Environment | |
 |---|---|
 | `NOVA_API_KEY`, `NOVA_MODEL` | Use this key / model instead of the stored ones |

package/dist/{chunk-QSNU4H55.js → chunk-KDAUUQBE.js}

@@ -1,5 +1,6 @@
 // src/tui/session/tui-acp-client.ts
 import { NOVA_NOTIFICATIONS } from "@datalabrotterdam/nova-ai-agent/acp/extensions.js";
+import { openBrowser } from "@datalabrotterdam/nova-ai-agent/acp/auth-server.js";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { dirname } from "path";
 import {
@@ -7,13 +8,11 @@ import {
   terminateProcessTree
 } from "@datalabrotterdam/nova-ai-agent/core/process-tree.js";
 import { resolveWorkspaceFile } from "@datalabrotterdam/nova-ai-agent/core/tools/workspace-paths.js";
-import {
-  isInteractionMode
-} from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
 import {
   fromElicitationRequest,
   toElicitationResponse
 } from "@datalabrotterdam/nova-ai-agent/acp/user-questions.js";
+import { INTERACTION_MODES } from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
 var DEFAULT_OUTPUT_LIMIT = 1e5;
 var nextMessageId = 0;
 function uid() {
@@ -31,6 +30,10 @@ var TuiAcpClient = class {
   cwd;
   onBackgroundLifecycle;
   onInteractionModeChange;
+  /** The modes the agent offers (built-in, then the user's agent files); set by the runner. */
+  modeIds = [...INTERACTION_MODES];
+  /** Slash commands the agent understands, such as the user's command files. */
+  agentCommands = [];
   capabilities = {
     fs: { readTextFile: true, writeTextFile: true },
     terminal: true,
@@ -91,6 +94,29 @@ var TuiAcpClient = class {
   appendUserMessage(text) {
     this.appendMessage({ id: uid(), role: "user", text });
   }
+  /** An MCP server's sign-in page: opened in the browser, and printed in case that fails. */
+  mcpAuthUrl(params) {
+    const { serverName, url } = params ?? {};
+    if (typeof serverName !== "string" || typeof url !== "string") return;
+    let page;
+    try {
+      page = new URL(url);
+    } catch {
+      return;
+    }
+    if (page.protocol !== "https:" && page.protocol !== "http:") {
+      this.appendError(`MCP server "${serverName}" sent a sign-in address that is not a web page; not opened.`);
+      return;
+    }
+    openBrowser(page.toString());
+    this.appendMessage({
+      id: uid(),
+      role: "assistant",
+      streaming: false,
+      text: `Sign in to MCP server "${serverName}" in your browser. If it did not open, visit:
+${page}`
+    });
+  }
   appendError(text) {
     this.appendMessage({ id: uid(), role: "error", text });
   }
@@ -294,8 +320,15 @@ ${err.message}`;
           });
         }
         return;
+      case "available_commands_update":
+        this.agentCommands = update.availableCommands.map(({ name, description, input }) => ({
+          name,
+          description,
+          ...input && "hint" in input && input.hint ? { hint: input.hint } : {}
+        }));
+        return;
       case "current_mode_update":
-        if (isInteractionMode(update.currentModeId)) {
+        if (this.modeIds.includes(update.currentModeId)) {
           this.onInteractionModeChange?.(update.currentModeId);
         }
         return;
@@ -415,6 +448,8 @@ ${err.message}`;
         return this.backgroundUpdate(params);
       case NOVA_NOTIFICATIONS.queueChanged:
         return this.queueChanged(params);
+      case NOVA_NOTIFICATIONS.mcpAuthUrl:
+        return this.mcpAuthUrl(params);
       default:
         return;
     }

package/dist/{headless-C36E4XSQ.js → headless-BQXK7TNC.js}

@@ -2,7 +2,7 @@ import {
   TuiAcpClient,
   choosePermissionOption,
   createStore
-} from "./chunk-QSNU4H55.js";
+} from "./chunk-KDAUUQBE.js";
 
 // src/headless/index.ts
 import { resolve } from "path";

package/dist/index.js

@@ -17,8 +17,7 @@ var MODE_FLAGS = {
   "--headless": "print",
   "--setup": "login",
   "--version": "version",
-  "-v": "version",
-  "--web": "web"
+  "-v": "version"
 };
 function parseCli(argv) {
   const first = argv[0];
@@ -34,7 +33,7 @@ function parseCli(argv) {
   const mode = [...modes][0];
   const wantsHelp = options.includes("--help") || options.includes("-h");
   if (!mode) return wantsHelp ? { mode: "help", args: [] } : { mode: "tui", args: argv };
-  const drop = /* @__PURE__ */ new Set(["--acp", "--headless", "--setup", "--version", "-v", "--web"]);
+  const drop = /* @__PURE__ */ new Set(["--acp", "--headless", "--setup", "--version", "-v"]);
   return { mode, args: argv.filter((arg, index) => !(drop.has(arg) && (end < 0 || index < end))) };
 }
 function versionText() {
@@ -140,7 +139,7 @@ ${MAIN_HELP}
     }
     case "print": {
       const update = startUpdateCheck();
-      const { default: runHeadless } = await import("./headless-C36E4XSQ.js");
+      const { default: runHeadless } = await import("./headless-BQXK7TNC.js");
       const code = await runHeadless(command.args);
       if (update) await noticeUpdate(update, 500);
       return code;
@@ -153,11 +152,6 @@ ${MAIN_HELP}
       const { runLogout } = await import("@datalabrotterdam/nova-ai-agent/commands/login.js");
       return runLogout();
     }
-    case "web": {
-      const { default: runWebUi } = await import("./webui-L4GGMXJ3.js");
-      await runWebUi();
-      return 0;
-    }
     case "tui": {
       let options;
       try {
@@ -175,7 +169,7 @@ ${MAIN_HELP}
         );
         return 2;
       }
-      const { default: runChat } = await import("./tui-TRADKND7.js");
+      const { default: runChat } = await import("./tui-TJFV6NC6.js");
       return runChat(options);
     }
   }

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

@@ -10,7 +10,7 @@ import {
 import {
   TuiAcpClient,
   createStore
-} from "./chunk-QSNU4H55.js";
+} from "./chunk-KDAUUQBE.js";
 
 // src/tui/index.ts
 import { createInterface as createInterface2 } from "readline/promises";
@@ -122,11 +122,15 @@ 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 { 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 { resolveEffort } from "@datalabrotterdam/nova-ai-agent/core/model-capabilities.js";
 
 // src/tui/files/file-mentions.ts
 import { statSync } from "fs";
@@ -286,6 +290,7 @@ var SessionRunner = class {
       clientInfo: { name: "nova-ai-cli-tui", version: "1" }
     });
     this.model = credentials.defaultModel ?? process.env.NOVA_MODEL ?? "";
+    this.effort = credentials.defaultEffort ?? null;
     this.sessionId = crypto.randomUUID();
     this.sessionReady = Promise.resolve();
   }
@@ -296,6 +301,14 @@ 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;
@@ -315,7 +328,10 @@ var SessionRunner = class {
   handoffActive = false;
   queuedAttachments = /* @__PURE__ */ new Map();
   editingQueuedMessageId = null;
-  imageSupportByModel = /* @__PURE__ */ new Map();
+  /** 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) {
@@ -353,6 +369,7 @@ var SessionRunner = class {
         this.acpClient.muteSessionUpdates = false;
       }
     }).then((response) => {
+      this.applyModes(response.modes);
       this.applyMcpStatus(response._meta);
       this.applySkillStatus(response._meta);
       this.agentSessionLoaded = true;
@@ -360,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(() => {
       });
@@ -482,6 +500,14 @@ 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 });
@@ -581,8 +607,12 @@ var SessionRunner = class {
   async listModels() {
     await this.initialized;
     const { models } = await this.nova.modelsList();
-    for (const model of models) this.imageSupportByModel.set(model.id, model.imageInput);
-    return models.map((model) => ({ id: model.id, name: model.name }));
+    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;
   }
   /**
    * Takes the account's default model when none is set, and replaces a saved
@@ -597,7 +627,7 @@ var SessionRunner = class {
         const { models, defaultModel } = await this.nova.modelsList(
           this.model ? { preferred: this.model } : {}
         );
-        for (const model of models) this.imageSupportByModel.set(model.id, model.imageInput);
+        for (const model of models) this.modelInfo.set(model.id, model);
         if (!defaultModel || defaultModel === this.model) return;
         const previous = this.model;
         this.setModel(defaultModel);
@@ -610,8 +640,41 @@ var SessionRunner = class {
     return this.modelCheck;
   }
   async supportsImageInput(model = this.model) {
-    if (!this.imageSupportByModel.has(model)) await this.listModels();
-    return this.imageSupportByModel.get(model) ?? false;
+    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) {
@@ -890,11 +953,12 @@ var SessionRunner = class {
   }
   async createSession() {
     await this.initialized;
-    const { sessionId, _meta } = await this.nova.newSession({
+    const { sessionId, _meta, modes } = await this.nova.newSession({
       cwd: this.cwd,
       mcpServers: []
     });
     this.sessionId = sessionId;
+    this.applyModes(modes);
     this.applyMcpStatus(_meta);
     this.applySkillStatus(_meta);
     this.agentSessionLoaded = true;
@@ -902,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(() => {
     });
@@ -937,7 +1002,13 @@ 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 };
   }
@@ -981,6 +1052,10 @@ var SessionRunner = class {
       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 });
@@ -1450,6 +1525,7 @@ import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-run
 function StatusLine({
   ui,
   model,
+  effort = null,
   mcp,
   scroll = 0
 }) {
@@ -1460,6 +1536,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,
@@ -1802,18 +1879,14 @@ function PlanView({
   ] });
 }
 
-// src/tui/ink/controller.ts
-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), ...ctx.agentCommands()].map((c) => `/${c.name} \u2014 ${c.description}`);
       ctx.print(lines.join("\n"));
     }
   },
@@ -1894,15 +1967,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);
@@ -1944,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",
@@ -1953,9 +2036,20 @@ var builtinCommands = [
   },
   {
     name: "mcp",
-    description: "Inspect configured MCP servers",
-    run(ctx) {
-      return 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"));
     }
   },
   {
@@ -2142,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);
@@ -2361,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;
@@ -2884,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;
@@ -3132,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 {
@@ -3965,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)
@@ -3975,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" },
@@ -4061,7 +4245,7 @@ status: failed - ${failure.message}`);
       `Skills (${on} on, ${skills.length - on} off)`,
       skills.length ? [
         ...skills.map(
-          (skill) => `${skill.name} [${skill.source}]${skill.enabled ? "" : " (off)"}
+          (skill) => `${skill.name} [${skill.bundledBy ? `bundled with ${skill.bundledBy}` : skill.source}]${skill.enabled ? "" : " (off)"}
 ${skill.description}
 ${skill.path}`
         ),
@@ -4132,8 +4316,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) => ({
@@ -4175,13 +4359,29 @@ ${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,
+    agentCommands: () => this.agentCommands(),
     setInteractionMode: (mode) => this.setInteractionMode(mode),
     getPermissionMode: () => this.store.getState().permissionMode,
     setPermissionMode: (mode) => this.setPermissionMode(mode),
     openPermissionPicker: this.openPermissionModes,
+    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();
@@ -4208,6 +4408,10 @@ ${skill.path}`
     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();
@@ -4227,6 +4431,10 @@ ${skill.path}`
     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;
     }
@@ -4288,7 +4496,7 @@ ${skill.path}`
     const fdPath = resolveFdPath();
     editor.setAutocompleteProvider(
       new WorkspaceAutocompleteProvider(
-        allCommands().map((command) => ({
+        () => [...allCommands(this.commandContext), ...this.agentCommands()].map((command) => ({
           name: command.name,
           description: command.description
         })),
@@ -4329,6 +4537,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,
@@ -4373,7 +4582,7 @@ function formatMcpServer(server, status) {
   }
   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");
 }
@@ -4412,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,
@@ -4800,7 +5028,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 })
     ] })
   ] });
 }
@@ -4843,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datalabrotterdam/nova-ai-cli",
-  "version": "1.2.0-alpha.6",
+  "version": "1.2.0-alpha.8",
   "description": "Agentic coding with DataLab Rotterdam's Nova AI in your terminal: interactive TUI, headless mode, and an ACP agent for editors",
   "license": "Apache-2.0",
   "author": "DataLab Rotterdam",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.29.0",
-    "@datalabrotterdam/nova-ai-agent": "^1.0.0-alpha.3",
+    "@datalabrotterdam/nova-ai-agent": "^1.0.0-alpha.5",
     "chalk": "^5.3.0",
     "cli-highlight": "^2.1.11",
     "diff": "^9.0.0",
@@ -76,6 +76,6 @@
     ]
   },
   "devDependencies": {
-    "@datalabrotterdam/nova-sdk": "^1.3.2"
+    "@datalabrotterdam/nova-sdk": "1.4.0-k8s.3"
   }
 }

package/dist/webui-L4GGMXJ3.js

@@ -1,9 +0,0 @@
-// src/webui/index.ts
-async function runWebUi() {
-  console.log("nova-ai --web is a work in progress \u2014 the browser UI isn't built yet.");
-  console.log("Use `nova-ai` for the terminal UI, `nova-ai -p` headless, or `nova-ai --acp` for editors.");
-}
-var webui_default = runWebUi;
-export {
-  webui_default as default
-};