@skein-code/cli 0.3.22 → 0.3.23

package/README.md

@@ -96,7 +96,7 @@ To build, verify, and install a local package artifact from this checkout:
 
 ```bash
 npm run verify:package -- --output-dir artifacts/package
-npm install -g ./artifacts/package/skein-code-cli-0.3.22.tgz
+npm install -g ./artifacts/package/skein-code-cli-0.3.23.tgz
 ```
 
 To install the published package from npm:
@@ -214,6 +214,13 @@ only to the originating session, expire after seven days, and are removed when
 that session is deleted. A receipt marked `source-truncated` is honest about
 bytes already omitted by the producing tool; those bytes cannot be recovered.
 
+Normal chat runs discover MCP servers lazily. Startup exposes only a compact
+`mcp_activate` catalog of configured servers; selecting one connects that
+server, runs remote discovery, and loads at most eight request-relevant schemas
+into the live tool registry. All activated MCP tools remain `network`
+operations. The explicit `skein mcp status` diagnostic still connects
+configured servers eagerly.
+
 At 96 columns and wider, a fresh session uses a two-column welcome surface. The
 left side keeps Skein's brand, workspace path, and next actions close to the
 composer; the right side reports the actual model, mode, local index file/chunk

package/dist/cli.js

@@ -220,7 +220,7 @@ function isSqliteBusy(error) {
 // package.json
 var package_default = {
   name: "@skein-code/cli",
-  version: "0.3.22",
+  version: "0.3.23",
   description: "A context-first, model-agnostic coding agent with an auditable terminal workspace.",
   type: "module",
   license: "MIT",
@@ -236,6 +236,9 @@ var package_default = {
   },
   skein: {
     releaseNotes: [
+      "Normal chat startup now exposes a compact mcp_activate catalog instead of eagerly connecting MCP servers",
+      "MCP activation connects one selected server, discovers remote tools, and loads at most eight relevant schemas",
+      "Explicit MCP diagnostics can still connect eagerly while all MCP activation and remote calls remain network operations",
       "OpenAI, Anthropic, and Gemini usage now normalizes cached input, cache-write input, and reasoning tokens when reported",
       "Token Ledger, session totals, and structured usage events preserve provider cache and reasoning counts without prompt content",
       "Streaming, non-streaming, explicit-zero, and legacy-session compatibility paths are covered without claiming cache activation",
@@ -1938,6 +1941,7 @@ var agentTeamConfigSchema = z2.object({
 var mcpServerSchema = z2.object({
   enabled: z2.boolean().optional(),
   transport: z2.enum(["stdio", "http"]).optional(),
+  description: z2.string().min(1).max(500).optional(),
   command: z2.string().min(1).max(512).optional(),
   args: z2.array(z2.string().max(4e3)).max(64).optional(),
   cwd: z2.string().max(4e3).optional(),
@@ -19940,12 +19944,24 @@ var MAX_TOOLS_PER_SERVER = 256;
 var MAX_LIST_PAGES = 16;
 var DEFAULT_CONNECT_TIMEOUT = 12e3;
 var DEFAULT_TOOL_TIMEOUT = 6e4;
+var LAZY_SCHEMA_LIMIT = 8;
 var McpManager = class {
   constructor(config, options = {}) {
     this.config = config;
     this.options = options;
-    for (const [name, server] of Object.entries(config.servers ?? {})) {
+    const entries = Object.entries(config.servers ?? {});
+    for (const [index, [name, server]] of entries.entries()) {
       const transport = server.transport ?? "stdio";
+      if (index >= MAX_SERVERS) {
+        this.statuses.set(name, {
+          name,
+          state: "error",
+          transport,
+          toolCount: 0,
+          error: `MCP server limit exceeded (maximum ${MAX_SERVERS})`
+        });
+        continue;
+      }
       const state = config.enabled === false || server.enabled === false ? "disabled" : "disconnected";
       this.statuses.set(name, { name, state, transport, toolCount: 0 });
     }
@@ -19960,6 +19976,75 @@ var McpManager = class {
   options;
   shutdownController = new AbortController();
   closed = false;
+  /** Compact model-visible catalog; transport and remote discovery stay lazy. */
+  activationTool(registry) {
+    const names = this.activatableServerNames();
+    if (!names.length) return;
+    const catalog = names.map((name) => {
+      const server = this.config.servers[name];
+      const description = sanitizeCatalogText(server?.description) || `${server?.transport ?? "stdio"} MCP server`;
+      return `${name}: ${description}`;
+    }).join("; ");
+    return {
+      definition: {
+        name: "mcp_activate",
+        description: `Connect to one configured MCP server only when the current task needs it, discover its tools, and load at most ${LAZY_SCHEMA_LIMIT} relevant schemas. Available servers: ${catalog}`,
+        category: "network",
+        inputSchema: {
+          type: "object",
+          properties: {
+            server: { type: "string", enum: names, description: "Configured MCP server to activate." },
+            query: { type: "string", minLength: 1, maxLength: 500, description: "Capability needed from that server." }
+          },
+          required: ["server", "query"],
+          additionalProperties: false
+        }
+      },
+      permissionCategories: () => ["network"],
+      execute: async (arguments_, context) => {
+        const server = typeof arguments_.server === "string" ? arguments_.server : "";
+        const query = typeof arguments_.query === "string" ? arguments_.query.trim() : "";
+        if (!names.includes(server)) throw new ToolInputError("MCP server is not available for activation");
+        if (!query || query.length > 500) {
+          throw new ToolInputError("MCP activation query must contain 1 to 500 characters");
+        }
+        const result = await this.activate(server, query, registry, context.signal);
+        if (!result.ok) {
+          return {
+            ok: false,
+            content: `MCP server ${server} could not be activated: ${result.status.error ?? result.status.state}`,
+            metadata: activationMetadata(result)
+          };
+        }
+        const loaded = result.registeredTools.length ? result.registeredTools.join(", ") : "no matching tool schemas";
+        const deferred = result.deferredTools ? ` ${result.deferredTools} additional schemas remain deferred; activate again with a narrower query if needed.` : "";
+        return {
+          content: `Activated MCP server ${server}. Loaded: ${loaded}.${deferred}`,
+          metadata: activationMetadata(result)
+        };
+      }
+    };
+  }
+  /** Connect/discover one server, then register only request-relevant schemas. */
+  async activate(name, query, registry, signal) {
+    const connected = await this.connect(name, signal);
+    if (!connected.ok) {
+      return { ...connected, registeredTools: [], availableTools: 0, deferredTools: 0 };
+    }
+    const connection = this.connections.get(name);
+    if (!connection) {
+      return { ...connected, ok: false, registeredTools: [], availableTools: 0, deferredTools: 0 };
+    }
+    const tools = [...connection.tools.values()];
+    const selected = tools.length <= LAZY_SCHEMA_LIMIT ? tools : selectRelevantTools(tools, query, LAZY_SCHEMA_LIMIT);
+    this.registerSelectedTools(registry, selected);
+    return {
+      ...connected,
+      registeredTools: selected.map((tool) => tool.definition.name),
+      availableTools: tools.length,
+      deferredTools: Math.max(0, tools.length - selected.length)
+    };
+  }
   /** Connect enabled servers with a small concurrency bound. */
   async connectAll(signal) {
     if (this.closed) throw new Error("MCP manager is closed");
@@ -19968,15 +20053,6 @@ var McpManager = class {
     if (this.config.enabled === false) {
       return configuredNames.map((name) => this.resultFor(name, false, 0));
     }
-    for (const name of configuredNames.slice(MAX_SERVERS)) {
-      const server = this.config.servers[name];
-      this.setStatus(name, {
-        state: "error",
-        transport: server?.transport ?? "stdio",
-        toolCount: 0,
-        error: `MCP server limit exceeded (maximum ${MAX_SERVERS})`
-      });
-    }
     const results = [];
     let cursor = 0;
     const worker = async () => {
@@ -19992,6 +20068,10 @@ var McpManager = class {
   /** Connect one configured server. Connection errors are captured in status. */
   async connect(name, signal) {
     if (this.closed) throw new Error("MCP manager is closed");
+    const status = this.statuses.get(name);
+    if (status?.state === "error" && status.error?.includes("server limit exceeded")) {
+      return this.resultFor(name, false, 0);
+    }
     const existing = this.pending.get(name);
     if (existing) return existing;
     const connectionController = new AbortController();
@@ -20076,8 +20156,11 @@ var McpManager = class {
   }
   /** Register connected MCP tools, preserving idempotency for the same adapter. */
   registerTools(registry) {
+    return this.registerSelectedTools(registry, this.tools());
+  }
+  registerSelectedTools(registry, tools) {
     const registered = [];
-    for (const tool of this.tools()) {
+    for (const tool of tools) {
       const existing = registry.get(tool.definition.name);
       if (existing) {
         if (existing !== tool) {
@@ -20090,6 +20173,10 @@ var McpManager = class {
     }
     return registered;
   }
+  activatableServerNames() {
+    if (this.config.enabled === false) return [];
+    return [...this.statuses.values()].filter((status) => status.state !== "disabled" && status.state !== "error").map((status) => status.name).sort((left, right) => left.localeCompare(right));
+  }
   async connectInternal(name, signal) {
     const configured = this.config.servers?.[name];
     if (!configured) throw new Error(`Unknown MCP server: ${name}`);
@@ -20341,6 +20428,28 @@ var McpManager = class {
     return { name, ok, status: { ...status }, skippedTools };
   }
 };
+function activationMetadata(result) {
+  return {
+    mcpServer: result.name,
+    state: result.status.state,
+    availableTools: result.availableTools,
+    loadedTools: result.registeredTools,
+    deferredTools: result.deferredTools,
+    skippedTools: result.skippedTools
+  };
+}
+function selectRelevantTools(tools, query, limit) {
+  const terms = new Set(query.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []);
+  return tools.map((tool) => {
+    const searchable = `${tool.definition.name.replaceAll("_", " ")} ${tool.definition.description}`.toLocaleLowerCase();
+    let score = 0;
+    for (const term of terms) if (searchable.includes(term)) score += term.length;
+    return { tool, score };
+  }).sort((left, right) => right.score - left.score || left.tool.definition.name.localeCompare(right.tool.definition.name)).slice(0, limit).map(({ tool }) => tool);
+}
+function sanitizeCatalogText(value) {
+  return value ? stripAnsi5(value).replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim().slice(0, 200) : "";
+}
 function requestOptions(timeoutMs, signal) {
   return {
     timeout: timeoutMs,
@@ -20850,7 +20959,7 @@ var ExtensionRuntime = class _ExtensionRuntime {
       throw error;
     }
   }
-  async initialize(registry, signal) {
+  async initialize(registry, _signal) {
     if (this.initialized) return;
     if (this.memory) {
       await this.memory.open();
@@ -20862,8 +20971,8 @@ var ExtensionRuntime = class _ExtensionRuntime {
     }
     await this.skills?.discover();
     if (this.mcp) {
-      await this.mcp.connectAll(signal);
-      this.mcp.registerTools(registry);
+      const activationTool = this.mcp.activationTool(registry);
+      if (activationTool) registry.register(activationTool);
     }
     await this.profiles?.discover();
     if (this.config.agents?.enabled && this.profiles && this.options.provider && this.options.contextEngine) {