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

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [@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)
+
+
+### Bug Fixes
+
+* **cli:** start the session before the first prompt ([0c26456](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/0c26456b8126e3b42a6de2e38212213ae5380e62))
+
+
+### Features
+
+* **agent:** set workspace trust over ACP ([cec4a89](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/cec4a8949a4232f46448219e4d5363289651215d))
+
 # [@datalabrotterdam/nova-ai-cli-v1.2.0-alpha.5](https://github.com/Datalab-Rotterdam/nova-ai-cli/compare/@datalabrotterdam/nova-ai-cli@1.2.0-alpha.4...@datalabrotterdam/nova-ai-cli@1.2.0-alpha.5) (2026-10-23)
 
 

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

@@ -1,147 +1,3 @@
-// src/tui/settings/workspace-mcp.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
-import { isWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
-import { readSettings } from "@datalabrotterdam/nova-ai-agent/core/policy/settings.js";
-
-// src/tui/settings/workspace-settings.ts
-import { readFileSync } from "fs";
-import { join } from "path";
-function settingsPath(cwd) {
-  return join(cwd, ".nova-ai", "settings.json");
-}
-function readWorkspaceSettings(cwd) {
-  try {
-    const raw = readFileSync(settingsPath(cwd), "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-
-// src/tui/settings/workspace-mcp.ts
-var UNTRUSTED_MCP_MESSAGE = "Not started: MCP servers declared by this workspace only run once you trust it (/trust in the TUI, --trust-workspace headless).";
-function readWorkspaceMcpConfiguration(cwd, options = {}) {
-  const configured = readWorkspaceSettings(cwd).mcpServers ?? [];
-  const project = readProjectMcpConfiguration(cwd);
-  const servers = new Map(configured.map((server) => [server.name, server]));
-  for (const server of project.servers) servers.set(server.name, server);
-  const declared = [...servers.values()];
-  if (declared.length && !(options.trusted ?? isWorkspaceTrusted(cwd))) {
-    return {
-      servers: [],
-      failures: [
-        ...project.failures,
-        ...declared.map((server) => ({ serverName: server.name, message: UNTRUSTED_MCP_MESSAGE }))
-      ],
-      untrusted: declared.map((server) => server.name)
-    };
-  }
-  return { servers: declared, failures: project.failures };
-}
-function workspaceNeedsTrust(cwd) {
-  if (isWorkspaceTrusted(cwd)) return false;
-  if (readWorkspaceMcpConfiguration(cwd, { trusted: true }).servers.length) return true;
-  return loadWorkspaceAllowRules(cwd).length > 0;
-}
-function loadWorkspaceAllowRules(cwd) {
-  return ["settings.json", "settings.local.json"].flatMap((name) => {
-    const allow = readSettings(join2(cwd, ".nova-ai", name))?.permissions?.allow;
-    return Array.isArray(allow) ? allow : [];
-  });
-}
-function readProjectMcpConfiguration(cwd) {
-  const path = join2(cwd, ".mcp.json");
-  let raw;
-  try {
-    raw = readFileSync2(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return { servers: [], failures: [] };
-    return { servers: [], failures: [{ serverName: ".mcp.json", message: errorMessage(error, "Could not read file") }] };
-  }
-  let document;
-  try {
-    document = JSON.parse(raw);
-  } catch (error) {
-    return { servers: [], failures: [{ serverName: ".mcp.json", message: errorMessage(error, "Invalid JSON") }] };
-  }
-  const root = asRecord(document);
-  const definitions = root ? asRecord(root.mcpServers) : null;
-  if (!definitions) {
-    return {
-      servers: [],
-      failures: [{ serverName: ".mcp.json", message: 'Expected an "mcpServers" object.' }]
-    };
-  }
-  const servers = [];
-  const failures = [];
-  for (const [name, value] of Object.entries(definitions)) {
-    const config = asRecord(value);
-    if (config?.disabled === true || config?.enabled === false) continue;
-    try {
-      servers.push(normalizeProjectServer(name, config));
-    } catch (error) {
-      failures.push({ serverName: `.mcp.json:${name}`, message: errorMessage(error, "Invalid server configuration") });
-    }
-  }
-  return { servers, failures };
-}
-function normalizeProjectServer(name, config) {
-  if (!config) throw new Error("Server definition must be an object.");
-  const type = typeof config.type === "string" ? config.type : config.url ? "http" : "stdio";
-  if (type === "http" || type === "sse") {
-    if (typeof config.url !== "string" || !config.url) throw new Error(`${type} server requires a URL.`);
-    try {
-      new URL(config.url);
-    } catch {
-      throw new Error(`${type} server requires a valid URL.`);
-    }
-    return {
-      name,
-      type,
-      url: config.url,
-      headers: normalizePairs(config.headers, "headers")
-    };
-  }
-  if (type !== "stdio") throw new Error(`Unsupported transport type: ${type}.`);
-  if (typeof config.command !== "string" || !config.command) throw new Error("stdio server requires a command.");
-  if (config.args !== void 0 && (!Array.isArray(config.args) || !config.args.every((arg) => typeof arg === "string"))) {
-    throw new Error("args must be an array of strings.");
-  }
-  return {
-    name,
-    command: config.command,
-    args: config.args ?? [],
-    env: normalizePairs(config.env, "env")
-  };
-}
-function normalizePairs(value, label) {
-  if (value === void 0) return [];
-  if (Array.isArray(value)) {
-    if (!value.every((entry) => {
-      const pair = asRecord(entry);
-      return typeof pair?.name === "string" && typeof pair.value === "string";
-    })) {
-      throw new Error(`${label} must contain name/value strings.`);
-    }
-    return value.map((entry) => {
-      const pair = entry;
-      return { name: pair.name, value: pair.value };
-    });
-  }
-  const record = asRecord(value);
-  if (!record || !Object.values(record).every((entry) => typeof entry === "string")) {
-    throw new Error(`${label} must be an object of string values.`);
-  }
-  return Object.entries(record).map(([name, entry]) => ({ name, value: entry }));
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function errorMessage(error, fallback) {
-  return error instanceof Error && error.message ? `${fallback}: ${error.message}` : fallback;
-}
-
 // src/tui/session/tui-acp-client.ts
 import { NOVA_NOTIFICATIONS } from "@datalabrotterdam/nova-ai-agent/acp/extensions.js";
 import { readFile, writeFile, mkdir } from "fs/promises";
@@ -746,8 +602,6 @@ function createStore(initial) {
 }
 
 export {
-  readWorkspaceMcpConfiguration,
-  workspaceNeedsTrust,
   TuiAcpClient,
   choosePermissionOption,
   createStore

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

@@ -1,9 +1,8 @@
 import {
   TuiAcpClient,
   choosePermissionOption,
-  createStore,
-  readWorkspaceMcpConfiguration
-} from "./chunk-NHGIUEIR.js";
+  createStore
+} from "./chunk-QSNU4H55.js";
 
 // src/headless/index.ts
 import { resolve } from "path";
@@ -12,7 +11,6 @@ import * as acp from "@agentclientprotocol/sdk";
 import { NovaAgent } from "@datalabrotterdam/nova-ai-agent/acp/agent.js";
 import { clientFromContext } from "@datalabrotterdam/nova-ai-agent/client/context-client.js";
 import { startInProcessAgent } from "@datalabrotterdam/nova-ai-agent/client/in-process.js";
-import { setWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
 import { listStoredSessions, loadStoredSession } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
 
 // src/headless/client.ts
@@ -191,15 +189,19 @@ ${HEADLESS_HELP}
     dependencies.agent ?? new NovaAgent()
   );
   const agent = connection.client;
-  if (options.trustWorkspace) setWorkspaceTrusted(options.cwd, true);
-  const mcpConfiguration = options.mcp ? readWorkspaceMcpConfiguration(options.cwd) : { servers: [], failures: [] };
-  for (const failure of mcpConfiguration.failures) {
-    output.write({
-      type: "mcp.configuration_error",
-      serverName: failure.serverName,
-      message: failure.message
-    });
-  }
+  const sessionMeta = { "nova-ai-cli/workspaceMcp": options.mcp };
+  const reportMcpFailures = (meta) => {
+    const failures = toRecord(toRecord(meta)?.["nova-ai-cli/mcp"])?.failures;
+    for (const failure of Array.isArray(failures) ? failures : []) {
+      const item = toRecord(failure);
+      if (typeof item?.serverName !== "string" || typeof item.message !== "string") continue;
+      output.write({
+        type: "mcp.configuration_error",
+        serverName: item.serverName,
+        message: item.message
+      });
+    }
+  };
   let sessionId = null;
   let interrupted = false;
   const onInterrupt = () => {
@@ -215,18 +217,23 @@ ${HEADLESS_HELP}
       clientCapabilities: client.capabilities,
       clientInfo: { name: "nova-ai-cli-headless", version: "1" }
     });
+    if (options.trustWorkspace) await agent.workspaceTrust({ cwd: options.cwd, trusted: true });
     if (options.resume) {
-      await agent.resumeSession({
+      const resumed = await agent.resumeSession({
         sessionId: options.resume,
         cwd: options.cwd,
-        mcpServers: mcpConfiguration.servers
+        mcpServers: [],
+        _meta: sessionMeta
       });
+      reportMcpFailures(resumed._meta);
       sessionId = options.resume;
     } else {
       const created = await agent.newSession({
         cwd: options.cwd,
-        mcpServers: mcpConfiguration.servers
+        mcpServers: [],
+        _meta: sessionMeta
       });
+      reportMcpFailures(created._meta);
       sessionId = created.sessionId;
     }
     await agent.setSessionConfigOption({

package/dist/index.js

@@ -140,7 +140,7 @@ ${MAIN_HELP}
     }
     case "print": {
       const update = startUpdateCheck();
-      const { default: runHeadless } = await import("./headless-OFJFVJ3O.js");
+      const { default: runHeadless } = await import("./headless-C36E4XSQ.js");
       const code = await runHeadless(command.args);
       if (update) await noticeUpdate(update, 500);
       return code;
@@ -175,7 +175,7 @@ ${MAIN_HELP}
         );
         return 2;
       }
-      const { default: runChat } = await import("./tui-4XTC6VJP.js");
+      const { default: runChat } = await import("./tui-TRADKND7.js");
       return runChat(options);
     }
   }

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

@@ -9,21 +9,14 @@ import {
 } from "./chunk-FMHWW3E6.js";
 import {
   TuiAcpClient,
-  createStore,
-  readWorkspaceMcpConfiguration,
-  workspaceNeedsTrust
-} from "./chunk-NHGIUEIR.js";
+  createStore
+} from "./chunk-QSNU4H55.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,10 +119,6 @@ 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";
@@ -138,15 +127,6 @@ 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";
 
 // src/tui/files/file-mentions.ts
 import { statSync } from "fs";
@@ -291,15 +271,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 +285,7 @@ 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.sessionId = crypto.randomUUID();
     this.sessionReady = Promise.resolve();
   }
@@ -337,15 +302,12 @@ var SessionRunner = class {
   connection;
   nova;
   initialized;
-  novaClient;
-  mcpServers = [];
-  mcpConfigurationFailures = [];
   mcpStatus = {
     configured: [],
     connected: [],
     failures: []
   };
-  skills;
+  skills = [];
   sessionReady;
   agentSessionLoaded = false;
   promptActive = false;
@@ -354,9 +316,6 @@ var SessionRunner = class {
   queuedAttachments = /* @__PURE__ */ new Map();
   editingQueuedMessageId = null;
   imageSupportByModel = /* @__PURE__ */ new Map();
-  contextWindow = null;
-  contextWindowModel = null;
-  contextWindowRequest = 0;
   contextUsageRequest = 0;
   modelCheck = null;
   resumeFrom(storedSessionId) {
@@ -369,15 +328,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,7 +347,7 @@ var SessionRunner = class {
         return await this.nova.loadSession({
           sessionId: stored.sessionId,
           cwd: stored.cwd,
-          mcpServers: this.mcpServers
+          mcpServers: []
         });
       } finally {
         this.acpClient.muteSessionUpdates = false;
@@ -521,9 +472,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 +482,29 @@ var SessionRunner = class {
   skillSessionStatus() {
     return this.skills.map((skill) => ({ ...skill }));
   }
+  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 +520,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 +579,30 @@ 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.imageSupportByModel.set(model.id, model.imageInput);
+    return models.map((model) => ({ id: model.id, name: model.name }));
   }
   /**
-   * 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.imageSupportByModel.set(model.id, model.imageInput);
+        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 +610,8 @@ 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;
+    if (!this.imageSupportByModel.has(model)) await this.listModels();
+    return this.imageSupportByModel.get(model) ?? false;
   }
   async compactContext() {
     if (this.store.getState().busy || this.promptActive) {
@@ -793,7 +735,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,11 +889,10 @@ var SessionRunner = class {
     ];
   }
   async createSession() {
-    this.loadMcpConfiguration(this.cwd);
     await this.initialized;
     const { sessionId, _meta } = await this.nova.newSession({
       cwd: this.cwd,
-      mcpServers: this.mcpServers
+      mcpServers: []
     });
     this.sessionId = sessionId;
     this.applyMcpStatus(_meta);
@@ -975,10 +916,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"
@@ -988,24 +939,7 @@ var SessionRunner = class {
       const item = entry;
       return typeof item.serverName === "string" && typeof item.message === "string" ? [{ serverName: item.serverName, message: item.message }] : [];
     }) : [];
-    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,12 +957,28 @@ 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();
     }
   }
   applyInteractionMode(mode, statusLine) {
@@ -1044,7 +994,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) {
@@ -1853,12 +1803,6 @@ 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
@@ -1983,8 +1927,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());
     }
   },
   {
@@ -2011,16 +1955,16 @@ var builtinCommands = [
     name: "mcp",
     description: "Inspect configured MCP servers",
     run(ctx) {
-      ctx.openMcpInspector();
+      return ctx.openMcpInspector();
     }
   },
   {
     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 +1973,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));
     }
   },
   {
@@ -3874,7 +3818,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?.();
@@ -4084,9 +4028,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 +4048,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.source}]${skill.enabled ? "" : " (off)"}
 ${skill.description}
 ${skill.path}`
         ),
@@ -4118,17 +4070,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 () => {
@@ -4232,8 +4182,12 @@ ${skill.path}`
     getPermissionMode: () => this.store.getState().permissionMode,
     setPermissionMode: (mode) => this.setPermissionMode(mode),
     openPermissionPicker: this.openPermissionModes,
-    trustWorkspace: () => {
-      setWorkspaceTrusted(this.runner.cwd, true);
+    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,
@@ -4410,14 +4364,12 @@ ${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(
@@ -4937,19 +4889,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 +4932,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 +4941,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.");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datalabrotterdam/nova-ai-cli",
-  "version": "1.2.0-alpha.5",
+  "version": "1.2.0-alpha.6",
   "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,8 +39,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.29.0",
-    "@datalabrotterdam/nova-ai-agent": "^1.0.0-alpha.2",
-    "@datalabrotterdam/nova-sdk": "^1.3.2",
+    "@datalabrotterdam/nova-ai-agent": "^1.0.0-alpha.3",
     "chalk": "^5.3.0",
     "cli-highlight": "^2.1.11",
     "diff": "^9.0.0",
@@ -75,5 +74,8 @@
         }
       ]
     ]
+  },
+  "devDependencies": {
+    "@datalabrotterdam/nova-sdk": "^1.3.2"
   }
 }