@skein-code/cli 0.3.21 → 0.3.23

package/README.md

@@ -57,8 +57,10 @@ inspectable index for code retrieval and no retrieval service dependency.
   artifact for bounded readback.
 - **Measurable token economy:** every model request records a privacy-safe
   receipt for stable, dynamic, history, retrieval, tool-result, and tool-schema
-  estimates, alongside actual provider usage when available. Receipts retain
-  only counts and runtime decisions, never prompt or source content.
+  estimates, alongside actual provider usage when available. OpenAI, Anthropic,
+  and Gemini cache/reasoning counters are normalized into session totals and
+  structured events when the provider reports them. Receipts retain only counts
+  and runtime decisions, never prompt or source content.
 - **Reversible work:** Skein snapshots affected files before mutation without
   touching your Git history.
 - **Resumable by default:** conversations, tasks, usage, and changed files live
@@ -94,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.21.tgz
+npm install -g ./artifacts/package/skein-code-cli-0.3.23.tgz
 ```
 
 To install the published package from npm:
@@ -212,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.21",
+  version: "0.3.23",
   description: "A context-first, model-agnostic coding agent with an auditable terminal workspace.",
   type: "module",
   license: "MIT",
@@ -236,6 +236,12 @@ 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",
       "Failed configured verification output yields bounded current-run diagnostic ranking without persisting paths",
       "Diagnostic hints cannot create zero-relevance hits and are cleared on success or the next agent run",
       "Python absolute and relative module imports now contribute deterministic offline graph adjacency",
@@ -1935,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(),
@@ -5349,10 +5356,7 @@ var AnthropicProvider = class {
         name: block.name ?? "unknown",
         arguments: safeJsonArguments(block.input)
       })),
-      usage: {
-        ...data.usage?.input_tokens !== void 0 ? { inputTokens: data.usage.input_tokens } : {},
-        ...data.usage?.output_tokens !== void 0 ? { outputTokens: data.usage.output_tokens } : {}
-      },
+      usage: normalizeAnthropicUsage(data.usage),
       ...data.stop_reason ? { stopReason: data.stop_reason } : {}
     };
   }
@@ -5393,6 +5397,8 @@ var AnthropicProvider = class {
     let content = "";
     let inputTokens;
     let outputTokens;
+    let cachedInputTokens;
+    let cacheWriteInputTokens;
     let stopReason;
     const calls = /* @__PURE__ */ new Map();
     for await (const event of parseServerSentEvents(response)) {
@@ -5402,6 +5408,13 @@ var AnthropicProvider = class {
       }
       if (chunk.usage?.input_tokens !== void 0) inputTokens = chunk.usage.input_tokens;
       if (chunk.usage?.output_tokens !== void 0) outputTokens = chunk.usage.output_tokens;
+      const usage = chunk.usage ?? chunk.message?.usage;
+      if (usage?.cache_read_input_tokens !== void 0) {
+        cachedInputTokens = usage.cache_read_input_tokens;
+      }
+      if (usage?.cache_creation_input_tokens !== void 0) {
+        cacheWriteInputTokens = usage.cache_creation_input_tokens;
+      }
       if (chunk.delta?.stop_reason) stopReason = chunk.delta.stop_reason;
       const index = chunk.index ?? 0;
       if (chunk.type === "content_block_start" && chunk.content_block?.type === "text") {
@@ -5440,7 +5453,9 @@ var AnthropicProvider = class {
         })),
         usage: {
           ...inputTokens !== void 0 ? { inputTokens } : {},
-          ...outputTokens !== void 0 ? { outputTokens } : {}
+          ...outputTokens !== void 0 ? { outputTokens } : {},
+          ...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+          ...cacheWriteInputTokens !== void 0 ? { cacheWriteInputTokens } : {}
         },
         ...stopReason ? { stopReason } : {}
       }
@@ -5456,13 +5471,18 @@ function normalizeAnthropicResponse(data) {
       name: block.name ?? "unknown",
       arguments: safeJsonArguments(block.input)
     })),
-    usage: {
-      ...data.usage?.input_tokens !== void 0 ? { inputTokens: data.usage.input_tokens } : {},
-      ...data.usage?.output_tokens !== void 0 ? { outputTokens: data.usage.output_tokens } : {}
-    },
+    usage: normalizeAnthropicUsage(data.usage),
     ...data.stop_reason ? { stopReason: data.stop_reason } : {}
   };
 }
+function normalizeAnthropicUsage(usage) {
+  return {
+    ...usage?.input_tokens !== void 0 ? { inputTokens: usage.input_tokens } : {},
+    ...usage?.output_tokens !== void 0 ? { outputTokens: usage.output_tokens } : {},
+    ...usage?.cache_read_input_tokens !== void 0 ? { cachedInputTokens: usage.cache_read_input_tokens } : {},
+    ...usage?.cache_creation_input_tokens !== void 0 ? { cacheWriteInputTokens: usage.cache_creation_input_tokens } : {}
+  };
+}
 function toAnthropicMessage(message2) {
   if (message2.role === "tool") {
     return {
@@ -5536,10 +5556,7 @@ var GeminiProvider = class {
         name: part.functionCall?.name ?? "unknown",
         arguments: safeJsonArguments(part.functionCall?.args)
       })),
-      usage: {
-        ...data.usageMetadata?.promptTokenCount !== void 0 ? { inputTokens: data.usageMetadata.promptTokenCount } : {},
-        ...data.usageMetadata?.candidatesTokenCount !== void 0 ? { outputTokens: data.usageMetadata.candidatesTokenCount } : {}
-      },
+      usage: normalizeGeminiUsage(data.usageMetadata),
       ...candidate?.finishReason ? { stopReason: candidate.finishReason } : {}
     };
   }
@@ -5579,6 +5596,8 @@ var GeminiProvider = class {
     let content = "";
     let inputTokens;
     let outputTokens;
+    let cachedInputTokens;
+    let reasoningTokens;
     let stopReason;
     const toolCalls = [];
     for await (const event of parseServerSentEvents(response)) {
@@ -5590,6 +5609,12 @@ var GeminiProvider = class {
       if (chunk.usageMetadata?.candidatesTokenCount !== void 0) {
         outputTokens = chunk.usageMetadata.candidatesTokenCount;
       }
+      if (chunk.usageMetadata?.cachedContentTokenCount !== void 0) {
+        cachedInputTokens = chunk.usageMetadata.cachedContentTokenCount;
+      }
+      if (chunk.usageMetadata?.thoughtsTokenCount !== void 0) {
+        reasoningTokens = chunk.usageMetadata.thoughtsTokenCount;
+      }
       const candidate = chunk.candidates?.[0];
       if (candidate?.finishReason) stopReason = candidate.finishReason;
       for (const part of candidate?.content?.parts ?? []) {
@@ -5613,7 +5638,9 @@ var GeminiProvider = class {
         toolCalls,
         usage: {
           ...inputTokens !== void 0 ? { inputTokens } : {},
-          ...outputTokens !== void 0 ? { outputTokens } : {}
+          ...outputTokens !== void 0 ? { outputTokens } : {},
+          ...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+          ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
         },
         ...stopReason ? { stopReason } : {}
       }
@@ -5630,13 +5657,18 @@ function normalizeGeminiResponse(data) {
       name: part.functionCall?.name ?? "unknown",
       arguments: safeJsonArguments(part.functionCall?.args)
     })),
-    usage: {
-      ...data.usageMetadata?.promptTokenCount !== void 0 ? { inputTokens: data.usageMetadata.promptTokenCount } : {},
-      ...data.usageMetadata?.candidatesTokenCount !== void 0 ? { outputTokens: data.usageMetadata.candidatesTokenCount } : {}
-    },
+    usage: normalizeGeminiUsage(data.usageMetadata),
     ...candidate?.finishReason ? { stopReason: candidate.finishReason } : {}
   };
 }
+function normalizeGeminiUsage(usage) {
+  return {
+    ...usage?.promptTokenCount !== void 0 ? { inputTokens: usage.promptTokenCount } : {},
+    ...usage?.candidatesTokenCount !== void 0 ? { outputTokens: usage.candidatesTokenCount } : {},
+    ...usage?.cachedContentTokenCount !== void 0 ? { cachedInputTokens: usage.cachedContentTokenCount } : {},
+    ...usage?.thoughtsTokenCount !== void 0 ? { reasoningTokens: usage.thoughtsTokenCount } : {}
+  };
+}
 function toGeminiMessage(message2) {
   if (message2.role === "tool") {
     return {
@@ -5764,6 +5796,8 @@ var OpenAIProvider = class {
     let content = "";
     let inputTokens;
     let outputTokens;
+    let cachedInputTokens;
+    let reasoningTokens;
     let stopReason;
     const calls = /* @__PURE__ */ new Map();
     for await (const event of parseServerSentEvents(response)) {
@@ -5771,6 +5805,12 @@ var OpenAIProvider = class {
       const chunk = JSON.parse(event.data);
       if (chunk.usage?.prompt_tokens !== void 0) inputTokens = chunk.usage.prompt_tokens;
       if (chunk.usage?.completion_tokens !== void 0) outputTokens = chunk.usage.completion_tokens;
+      if (chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0) {
+        cachedInputTokens = chunk.usage.prompt_tokens_details.cached_tokens;
+      }
+      if (chunk.usage?.completion_tokens_details?.reasoning_tokens !== void 0) {
+        reasoningTokens = chunk.usage.completion_tokens_details.reasoning_tokens;
+      }
       const choice = chunk.choices?.[0];
       if (choice?.finish_reason) stopReason = choice.finish_reason;
       const delta = choice?.delta;
@@ -5798,7 +5838,9 @@ var OpenAIProvider = class {
         })),
         usage: {
           ...inputTokens !== void 0 ? { inputTokens } : {},
-          ...outputTokens !== void 0 ? { outputTokens } : {}
+          ...outputTokens !== void 0 ? { outputTokens } : {},
+          ...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+          ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
         },
         ...stopReason ? { stopReason } : {}
       }
@@ -5816,13 +5858,18 @@ function normalizeOpenAIResponse(data) {
       name: call.function?.name ?? "unknown",
       arguments: safeJsonArguments(call.function?.arguments)
     })),
-    usage: {
-      ...data.usage?.prompt_tokens !== void 0 ? { inputTokens: data.usage.prompt_tokens } : {},
-      ...data.usage?.completion_tokens !== void 0 ? { outputTokens: data.usage.completion_tokens } : {}
-    },
+    usage: normalizeOpenAIUsage(data.usage),
     ...choice?.finish_reason ? { stopReason: choice.finish_reason } : {}
   };
 }
+function normalizeOpenAIUsage(usage) {
+  return {
+    ...usage?.prompt_tokens !== void 0 ? { inputTokens: usage.prompt_tokens } : {},
+    ...usage?.completion_tokens !== void 0 ? { outputTokens: usage.completion_tokens } : {},
+    ...usage?.prompt_tokens_details?.cached_tokens !== void 0 ? { cachedInputTokens: usage.prompt_tokens_details.cached_tokens } : {},
+    ...usage?.completion_tokens_details?.reasoning_tokens !== void 0 ? { reasoningTokens: usage.completion_tokens_details.reasoning_tokens } : {}
+  };
+}
 function toOpenAIMessage(message2) {
   if (message2.role === "tool") {
     return {
@@ -6399,6 +6446,9 @@ var sessionSchema = z5.object({
     outputSource: z5.enum(["actual", "estimated", "mixed", "unknown"]).optional(),
     actualInputTokens: z5.number().nonnegative().optional(),
     actualOutputTokens: z5.number().nonnegative().optional(),
+    actualCachedInputTokens: z5.number().nonnegative().optional(),
+    actualCacheWriteInputTokens: z5.number().nonnegative().optional(),
+    actualReasoningTokens: z5.number().nonnegative().optional(),
     estimatedInputTokens: z5.number().nonnegative().optional(),
     estimatedOutputTokens: z5.number().nonnegative().optional()
   }).strict(),
@@ -6419,7 +6469,10 @@ var sessionSchema = z5.object({
     }).strict(),
     actual: z5.object({
       inputTokens: z5.number().nonnegative().optional(),
-      outputTokens: z5.number().nonnegative().optional()
+      outputTokens: z5.number().nonnegative().optional(),
+      cachedInputTokens: z5.number().nonnegative().optional(),
+      cacheWriteInputTokens: z5.number().nonnegative().optional(),
+      reasoningTokens: z5.number().nonnegative().optional()
     }).strict(),
     inputSource: z5.enum(["actual", "estimated"]),
     outputSource: z5.enum(["actual", "estimated"]),
@@ -10830,6 +10883,9 @@ var AgentRunner = class {
         const { inputTokens, outputTokens } = turnUsage;
         const actualInputTokens = validTokenCount(response.usage?.inputTokens);
         const actualOutputTokens = validTokenCount(response.usage?.outputTokens);
+        const actualCachedInputTokens = validTokenCount(response.usage?.cachedInputTokens);
+        const actualCacheWriteInputTokens = validTokenCount(response.usage?.cacheWriteInputTokens);
+        const actualReasoningTokens = validTokenCount(response.usage?.reasoningTokens);
         const receipt = recordTokenLedger(this.session, {
           requestId: userMessage.id,
           turn,
@@ -10840,7 +10896,10 @@ var AgentRunner = class {
           },
           actual: {
             ...actualInputTokens === void 0 ? {} : { inputTokens: actualInputTokens },
-            ...actualOutputTokens === void 0 ? {} : { outputTokens: actualOutputTokens }
+            ...actualOutputTokens === void 0 ? {} : { outputTokens: actualOutputTokens },
+            ...actualCachedInputTokens === void 0 ? {} : { cachedInputTokens: actualCachedInputTokens },
+            ...actualCacheWriteInputTokens === void 0 ? {} : { cacheWriteInputTokens: actualCacheWriteInputTokens },
+            ...actualReasoningTokens === void 0 ? {} : { reasoningTokens: actualReasoningTokens }
           },
           inputSource: actualInputTokens === void 0 ? "estimated" : "actual",
           outputSource: actualOutputTokens === void 0 ? "estimated" : "actual",
@@ -10859,7 +10918,10 @@ var AgentRunner = class {
           outputSource: this.session.usage.outputSource ?? "unknown",
           actual: {
             inputTokens: this.session.usage.actualInputTokens ?? 0,
-            outputTokens: this.session.usage.actualOutputTokens ?? 0
+            outputTokens: this.session.usage.actualOutputTokens ?? 0,
+            ...this.session.usage.actualCachedInputTokens === void 0 ? {} : { cachedInputTokens: this.session.usage.actualCachedInputTokens },
+            ...this.session.usage.actualCacheWriteInputTokens === void 0 ? {} : { cacheWriteInputTokens: this.session.usage.actualCacheWriteInputTokens },
+            ...this.session.usage.actualReasoningTokens === void 0 ? {} : { reasoningTokens: this.session.usage.actualReasoningTokens }
           },
           estimated: {
             inputTokens: this.session.usage.estimatedInputTokens ?? 0,
@@ -11560,6 +11622,18 @@ function recordTokenUsage(session, providerUsage, estimatedInputTokens, estimate
   } else {
     session.usage.estimatedOutputTokens = (session.usage.estimatedOutputTokens ?? 0) + outputTokens;
   }
+  const cachedInputActual = validTokenCount(providerUsage?.cachedInputTokens);
+  const cacheWriteInputActual = validTokenCount(providerUsage?.cacheWriteInputTokens);
+  const reasoningActual = validTokenCount(providerUsage?.reasoningTokens);
+  if (cachedInputActual !== void 0) {
+    session.usage.actualCachedInputTokens = (session.usage.actualCachedInputTokens ?? 0) + cachedInputActual;
+  }
+  if (cacheWriteInputActual !== void 0) {
+    session.usage.actualCacheWriteInputTokens = (session.usage.actualCacheWriteInputTokens ?? 0) + cacheWriteInputActual;
+  }
+  if (reasoningActual !== void 0) {
+    session.usage.actualReasoningTokens = (session.usage.actualReasoningTokens ?? 0) + reasoningActual;
+  }
   session.usage.inputSource = mergeMeasurementSource(
     priorInputSource,
     inputActual === void 0 ? "estimated" : "actual",
@@ -19870,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 });
     }
@@ -19890,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");
@@ -19898,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 () => {
@@ -19922,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();
@@ -20006,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) {
@@ -20020,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}`);
@@ -20271,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,
@@ -20780,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();
@@ -20792,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) {