@corenel/sidecar 0.8.2 → 0.8.3

package/dist/cli.js

@@ -14239,10 +14239,10 @@ var require_filters = __commonJS({
     _exports.striptags = striptags;
     function title(str10) {
       str10 = normalize3(str10, "");
-      var words = str10.split(" ").map(function(word) {
+      var words2 = str10.split(" ").map(function(word) {
         return capitalize(word);
       });
-      return r2.copySafeness(str10, words.join(" "));
+      return r2.copySafeness(str10, words2.join(" "));
     }
     _exports.title = title;
     function trim(str10) {
@@ -14297,7 +14297,7 @@ var require_filters = __commonJS({
         length = Infinity;
       }
       var noFollowAttr = nofollow === true ? ' rel="nofollow"' : "";
-      var words = str10.split(/(\s+)/).filter(function(word) {
+      var words2 = str10.split(/(\s+)/).filter(function(word) {
         return word && word.length;
       }).map(function(word) {
         var matches = word.match(puncRe);
@@ -14317,13 +14317,13 @@ var require_filters = __commonJS({
         }
         return word;
       });
-      return words.join("");
+      return words2.join("");
     }
     _exports.urlize = urlize;
     function wordcount(str10) {
       str10 = normalize3(str10, "");
-      var words = str10 ? str10.match(/\w+/g) : null;
-      return words ? words.length : null;
+      var words2 = str10 ? str10.match(/\w+/g) : null;
+      return words2 ? words2.length : null;
     }
     _exports.wordcount = wordcount;
     function float(val, def) {
@@ -17408,10 +17408,10 @@ ${yamlContent}` : yamlContent;
           if (!str10 || typeof str10 !== "string") {
             return "";
           }
-          const words = str10.split(/\s+/);
+          const words2 = str10.split(/\s+/);
           const lines = [];
           let currentLine = "";
-          for (const word of words) {
+          for (const word of words2) {
             if (currentLine.length + word.length + 1 <= width) {
               currentLine += (currentLine ? " " : "") + word;
             } else {
@@ -18083,10 +18083,10 @@ ${content}` : parentData.content;
           if (!str10 || typeof str10 !== "string") {
             return "";
           }
-          const words = str10.split(/\s+/);
+          const words2 = str10.split(/\s+/);
           const lines = [];
           let currentLine = "";
-          for (const word of words) {
+          for (const word of words2) {
             if (currentLine.length + word.length + 1 <= width) {
               currentLine += (currentLine ? " " : "") + word;
             } else {
@@ -24888,7 +24888,7 @@ var require_abort_controller = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var eventTargetShim = require_event_target_shim();
-    var AbortSignal = class extends eventTargetShim.EventTarget {
+    var AbortSignal2 = class extends eventTargetShim.EventTarget {
       /**
        * AbortSignal cannot be constructed directly.
        */
@@ -24907,9 +24907,9 @@ var require_abort_controller = __commonJS({
         return aborted;
       }
     };
-    eventTargetShim.defineEventAttribute(AbortSignal.prototype, "abort");
+    eventTargetShim.defineEventAttribute(AbortSignal2.prototype, "abort");
     function createAbortSignal() {
-      const signal = Object.create(AbortSignal.prototype);
+      const signal = Object.create(AbortSignal2.prototype);
       eventTargetShim.EventTarget.call(signal);
       abortedFlags.set(signal, false);
       return signal;
@@ -24922,11 +24922,11 @@ var require_abort_controller = __commonJS({
       signal.dispatchEvent({ type: "abort" });
     }
     var abortedFlags = /* @__PURE__ */ new WeakMap();
-    Object.defineProperties(AbortSignal.prototype, {
+    Object.defineProperties(AbortSignal2.prototype, {
       aborted: { enumerable: true }
     });
     if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
-      Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
+      Object.defineProperty(AbortSignal2.prototype, Symbol.toStringTag, {
         configurable: true,
         value: "AbortSignal"
       });
@@ -24970,11 +24970,11 @@ var require_abort_controller = __commonJS({
       });
     }
     exports.AbortController = AbortController2;
-    exports.AbortSignal = AbortSignal;
+    exports.AbortSignal = AbortSignal2;
     exports.default = AbortController2;
     module.exports = AbortController2;
     module.exports.AbortController = module.exports["default"] = AbortController2;
-    module.exports.AbortSignal = AbortSignal;
+    module.exports.AbortSignal = AbortSignal2;
   }
 });
 
@@ -41720,6 +41720,9 @@ var BUILTIN_NAMESPACES = {
   spawn_agents: "agent",
   call_agent: "agent",
   todo_write: "agent",
+  // Finds deferred MCP tools (toolSearch.ts). Deliberately not `system`, which
+  // the standard policy denies: search is a read and must always be reachable.
+  tool_search: "agent",
   // Named here as a backstop; the sidecar's own decls also carry `namespace`,
   // and an explicit field always wins (resolveNamespace). Both say the same
   // thing so a sidecar that predates this still lands in the right namespace.
@@ -41807,14 +41810,115 @@ ${ref.preview}${ref.bytes > ref.preview.length ? "\n\u2026(truncated)" : ""}` :
 // ../harness/prompts/toolsMarker.ts
 var TOOLS_MARKER = "\uE000PROMPD_TOOLS\uE000";
 function formatToolLines(tools) {
-  return tools.map((t2) => `- \`${t2.name}\`: ${t2.description}`).join("\n");
+  return tools.map((t2) => `\`${t2.name}\``).join(", ");
 }
 function fillToolsMarker(system, tools) {
   if (!system.includes(TOOLS_MARKER)) return system;
   return system.replaceAll(TOOLS_MARKER, tools.length ? formatToolLines(tools) : "(no tools available this run)");
 }
 
+// ../harness/tools/toolSearch.ts
+init_protocol();
+var TOOL_SEARCH_NAME = "tool_search";
+var LOADED_TOOLS_CAP = 24;
+var DEFAULT_LIMIT = 8;
+var MAX_LIMIT = 20;
+function serverOf(tool) {
+  return parseMcpWireName(tool.name)?.server ?? "mcp";
+}
+function words(s2) {
+  return s2.toLowerCase().split(/[^a-z0-9]+/).filter((w2) => w2.length > 1);
+}
+function rankTools(query, tools, opts = {}) {
+  const limit2 = Math.min(MAX_LIMIT, Math.max(1, Math.floor(opts.limit ?? DEFAULT_LIMIT)));
+  const pool = opts.server ? tools.filter((t2) => serverOf(t2) === opts.server) : tools;
+  const q2 = words(query);
+  const scored = pool.map((tool, i2) => {
+    const parsed = parseMcpWireName(tool.name);
+    const nameWords = words(parsed?.tool ?? tool.name);
+    const serverWords = words(parsed?.server ?? "");
+    const descWords = words(tool.description ?? "");
+    let score = 0;
+    for (const w2 of q2) {
+      if (nameWords.includes(w2)) score += 3;
+      else if (nameWords.some((n2) => n2.startsWith(w2) || w2.startsWith(n2))) score += 2;
+      if (serverWords.includes(w2)) score += 2;
+      if (descWords.includes(w2)) score += 1;
+      else if (descWords.some((d2) => d2.startsWith(w2))) score += 0.5;
+    }
+    return { tool, score, i: i2 };
+  });
+  return scored.filter((s2) => s2.score > 0 || opts.server).sort((a2, b2) => b2.score - a2.score || a2.i - b2.i).slice(0, limit2).map((s2) => s2.tool);
+}
+function serverIndex(deferred) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const t2 of deferred) counts.set(serverOf(t2), (counts.get(serverOf(t2)) ?? 0) + 1);
+  const lines = [...counts].map(([s2, n2]) => `- ${s2} \xB7 ${n2} tool${n2 === 1 ? "" : "s"}`);
+  return [
+    `Connected services. Their tools are not loaded until you find them: call \`${TOOL_SEARCH_NAME}\` with what you want to do (and optionally the server) before concluding something is unavailable. Tools it returns can be called directly from then on.`,
+    ...lines
+  ].join("\n");
+}
+function createToolLoader(opts) {
+  const cap = opts.cap ?? LOADED_TOOLS_CAP;
+  const byName = new Map(opts.deferred.map((t2) => [t2.name, t2]));
+  const incoming = opts.loaded ?? [];
+  let order = incoming.filter((n2, i2) => byName.has(n2) && incoming.indexOf(n2) === i2).slice(-cap);
+  if (order.length !== incoming.length) opts.onChange?.([...order]);
+  const add = (names) => {
+    const before = new Set(order);
+    for (const n2 of names) {
+      order = order.filter((x2) => x2 !== n2);
+      order.push(n2);
+    }
+    if (order.length > cap) order = order.slice(order.length - cap);
+    const changed = order.length !== before.size || order.some((n2) => !before.has(n2));
+    if (changed) opts.onChange?.([...order]);
+  };
+  const searchTool = {
+    name: TOOL_SEARCH_NAME,
+    namespace: "agent",
+    description: "Find tools on connected services (MCP servers) by what you want to do. Returns matching tools with their input schemas and makes them callable from your next step. Search before concluding a service cannot do something.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: 'What you want to do, in plain words, e.g. "send an email" or "list calendar events".' },
+        server: { type: "string", description: "Only search this server (a name from the connected services list)." },
+        limit: { type: "number", description: `Most results to return (default ${DEFAULT_LIMIT}, max ${MAX_LIMIT}).` }
+      },
+      required: ["query"]
+    },
+    mutates: false,
+    // The schemas ARE the answer; offloading them behind a pointer would hide
+    // exactly what the model searched for.
+    noOffload: true,
+    async run(args) {
+      const query = typeof args.query === "string" ? args.query.trim() : "";
+      const server = typeof args.server === "string" && args.server ? args.server : void 0;
+      if (!query && !server) return "Error: pass a query describing what you want to do.";
+      const limit2 = typeof args.limit === "number" ? args.limit : void 0;
+      const found = rankTools(query, opts.deferred, { server, limit: limit2 });
+      add(found.map((t2) => t2.name));
+      const servers = [...new Set(opts.deferred.map(serverOf))];
+      return JSON.stringify({
+        tools: found.map((t2) => ({ name: t2.name, server: serverOf(t2), description: t2.description, inputSchema: t2.parameters })),
+        note: found.length ? "These tools are now loaded; call them directly." : `No tools matched. Connected servers: ${servers.join(", ") || "(none)"}. Try other words or name a server.`
+      });
+    }
+  };
+  return {
+    searchTool,
+    loaded: () => order.map((n2) => byName.get(n2)).filter((t2) => !!t2),
+    loadedNames: () => [...order],
+    touch: (name) => {
+      if (!order.includes(name)) return;
+      order = [...order.filter((n2) => n2 !== name), name];
+    }
+  };
+}
+
 // ../harness/core/loop.ts
+var MAX_PROVIDER_TOOLS = 128;
 async function runAgent(args) {
   const { client, system, tools, toolCtx } = args;
   const policy = args.policy ?? STANDARD_POLICY;
@@ -41840,17 +41944,28 @@ async function runAgent(args) {
     turnAc?.abort();
   });
   const messages = [...args.messages];
-  const filledSystem = system ? fillToolsMarker(system, tools) : system;
+  const deferred = args.deferredTools ?? [];
+  const loader = deferred.length ? createToolLoader({ deferred, loaded: args.loadedTools, onChange: (names) => emit({ type: "tools-loaded", names }) }) : null;
+  const eager = loader ? [...tools, loader.searchTool] : tools;
+  const capped = (list) => list.length > MAX_PROVIDER_TOOLS ? list.slice(0, MAX_PROVIDER_TOOLS) : list;
+  const activeTools = () => capped(loader ? [...eager, ...loader.loaded()] : eager);
+  let sent = activeTools();
+  const indexedSystem = loader ? system ? `${system}
+
+${serverIndex(deferred)}` : serverIndex(deferred) : system;
+  const filledSystem = indexedSystem ? fillToolsMarker(indexedSystem, sent) : indexedSystem;
   if (filledSystem && !messages.some((m2) => m2.role === "system")) {
     messages.unshift({ role: "system", content: filledSystem });
   }
-  const toolDefs = tools.map((t2) => ({
+  const defsFor = (list) => list.map((t2) => ({
     type: "function",
     function: { name: t2.name, description: t2.description, parameters: t2.parameters }
   }));
-  const toolByName = new Map(tools.map((t2) => [t2.name, t2]));
+  let toolDefs = defsFor(sent);
+  let toolByName = new Map(sent.map((t2) => [t2.name, t2]));
   if (compressionStrategy === "deferred" && compression && compression.mode !== "off" && toolCtx.recall) {
-    await compactIncomingOffloads(messages, toolByName, compression, toolCtx.recall, emit);
+    const known = new Map([...eager, ...deferred].map((t2) => [t2.name, t2]));
+    await compactIncomingOffloads(messages, known, compression, toolCtx.recall, emit);
   }
   const usage = { promptTokens: 0, completionTokens: 0 };
   let text = "";
@@ -41879,6 +41994,11 @@ async function runAgent(args) {
         break;
       }
     }
+    if (loader) {
+      sent = activeTools();
+      toolDefs = defsFor(sent);
+      toolByName = new Map(sent.map((t2) => [t2.name, t2]));
+    }
     let streamed;
     let streamFail = null;
     const model = args.getModel?.() ?? args.model;
@@ -42005,6 +42125,7 @@ async function runAgent(args) {
         emit({ type: "tool-result", id: call.id, name: call.name, result: "unknown tool", isError: true });
         continue;
       }
+      loader?.touch(tool.name);
       const address = toolAddress(tool);
       const gate = evaluateToolCall(policy, gstate, { name: call.name, exists: true, address });
       if (!gate.ok) {
@@ -46193,7 +46314,7 @@ var FLAG_TO_KEY = {
   "--default-model": "defaultModel",
   "--name": "name"
 };
-var DEFAULT_GUEST_IMAGE2 = "prompd/corenel-sandbox:0.8.2";
+var DEFAULT_GUEST_IMAGE2 = "prompd/corenel-sandbox:0.8.3";
 function parseArgsWithProvenance(argv) {
   const explicit = /* @__PURE__ */ new Set();
   for (const a2 of argv) {
@@ -48914,7 +49035,8 @@ var McpHttpClient = class {
    *  loop -- a credential that fails twice is refused, not flaky. */
   async send(method, params, isRetry = false) {
     const headers = await this.buildHeaders();
-    const res = await this.request(headers, method, params);
+    const id = this.nextRequestId++;
+    const res = await this.request(headers, id, method, params);
     if (res.status === 401) {
       if (!isRetry && await this.auth.onUnauthorized()) {
         return this.send(method, params, true);
@@ -48925,26 +49047,77 @@ var McpHttpClient = class {
     }
     const sessionId = res.headers.get(SESSION_HEADER);
     if (sessionId) this.sessionId = sessionId;
+    if (!res.ok) {
+      throw new Error(`MCP server "${this.server.name}" returned HTTP ${res.status}`);
+    }
     const contentType = res.headers.get("content-type") ?? "";
+    let body2;
     if (contentType.includes("text/event-stream")) {
-      throw new Error(
-        `MCP server "${this.server.name}" answered with an SSE stream (content-type: ${contentType}); streaming MCP responses are not supported yet`
-      );
-    }
-    if (!contentType.includes("application/json")) {
+      body2 = await this.readSseResponse(res, id);
+    } else if (contentType.includes("application/json")) {
+      body2 = await res.json();
+    } else {
       throw new Error(
         `MCP server "${this.server.name}" answered with an unexpected content-type: "${contentType || "(none)"}"`
       );
     }
-    if (!res.ok) {
-      throw new Error(`MCP server "${this.server.name}" returned HTTP ${res.status}`);
-    }
-    const body2 = await res.json();
     if (body2.error) {
       throw new Error(`MCP server "${this.server.name}" returned error ${body2.error.code}: ${body2.error.message}`);
     }
     return body2.result;
   }
+  /** Read an SSE body until the JSON-RPC response for `id` arrives.
+   *
+   *  Events are separated by a blank line; an event's `data:` lines are joined
+   *  with newlines, per the SSE spec, and parsed as one JSON-RPC message.
+   *  Notifications (no `id`) and responses to other ids are skipped. The reader
+   *  is cancelled once the answer is in, so a server that keeps the stream open
+   *  after replying cannot hold this call open with it. */
+  async readSseResponse(res, id) {
+    if (!res.body) {
+      throw new Error(`MCP server "${this.server.name}" closed the stream without a response`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (value) buffer += decoder.decode(value, { stream: true });
+        buffer = buffer.replace(/\r\n/g, "\n");
+        let boundary = buffer.indexOf("\n\n");
+        while (boundary !== -1) {
+          const event = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          const match = this.matchSseEvent(event, id);
+          if (match) return match;
+          boundary = buffer.indexOf("\n\n");
+        }
+        if (done) {
+          const tail3 = buffer.trim() ? this.matchSseEvent(buffer, id) : null;
+          if (tail3) return tail3;
+          throw new Error(`MCP server "${this.server.name}" closed the stream without a response`);
+        }
+      }
+    } finally {
+      reader.cancel().catch(() => {
+      });
+    }
+  }
+  /** The JSON-RPC response in one SSE event, if it answers `id`; else null. */
+  matchSseEvent(event, id) {
+    const data = event.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+    if (!data) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    if (!isRecord3(parsed) || parsed.id !== id) return null;
+    if (!("result" in parsed) && !("error" in parsed)) return null;
+    return parsed;
+  }
   /** The bare `fetch()` call, wrapped -- every OTHER throw in `send` already
    *  names the server; this is the one call whose own failures (DNS miss,
    *  connection refused, TLS failure) never reach `send`'s response-handling
@@ -48954,12 +49127,12 @@ var McpHttpClient = class {
    *  whose entire job is diagnosis. `err.cause` carries the real reason
    *  (ECONNREFUSED, ENOTFOUND, a TLS alert); undici puts it there rather than
    *  in `err.message`. */
-  async request(headers, method, params) {
+  async request(headers, id, method, params) {
     try {
       return await this.fetchImpl(this.server.url, {
         method: "POST",
         headers,
-        body: JSON.stringify({ jsonrpc: "2.0", id: this.nextRequestId++, method, params })
+        body: JSON.stringify({ jsonrpc: "2.0", id, method, params })
       });
     } catch (err) {
       const cause = err instanceof Error && err.cause instanceof Error ? err.cause.message : err instanceof Error ? err.message : String(err);
@@ -49020,6 +49193,25 @@ function authProviderFor(stateDir, server, fetchImpl = fetch, accountToken = asy
 
 // src/mcp/registry.ts
 init_store();
+
+// src/mcp/timedFetch.ts
+var AUTH_REQUEST_TIMEOUT_MS = 15e3;
+function timedFetch(ms, inner = fetch) {
+  return async (input, init2 = {}) => {
+    const deadline = AbortSignal.timeout(ms);
+    const signal = init2.signal ? AbortSignal.any([init2.signal, deadline]) : deadline;
+    try {
+      return await inner(input, { ...init2, signal });
+    } catch (err) {
+      if (deadline.aborted && !init2.signal?.aborted) {
+        throw new Error(`no answer within ${ms / 1e3}s`, { cause: err });
+      }
+      throw err;
+    }
+  };
+}
+
+// src/mcp/registry.ts
 async function accountTokenFor(stateDir) {
   try {
     const cred = await resolveCredential(process.env, stateDir);
@@ -49029,8 +49221,12 @@ async function accountTokenFor(stateDir) {
   }
 }
 function defaultClientFactory(stateDir, server) {
-  return new McpHttpClient(server, authProviderFor(stateDir, server, fetch, () => accountTokenFor(stateDir)));
+  return new McpHttpClient(
+    server,
+    authProviderFor(stateDir, server, timedFetch(AUTH_REQUEST_TIMEOUT_MS), () => accountTokenFor(stateDir))
+  );
 }
+var SERVER_CONNECT_TIMEOUT_MS = 3e4;
 var McpRegistry = class {
   constructor(stateDir, clientFactory = defaultClientFactory) {
     this.stateDir = stateDir;
@@ -49054,27 +49250,60 @@ var McpRegistry = class {
    * a server that fails to initialize, or fails listing tools, is recorded
    * in `status()` with zero tools and the daemon keeps starting.
    */
-  async connectAll() {
+  async connectAll(opts = {}) {
     this.connected.clear();
     this.statuses.clear();
     const servers = await readMcpServers(this.stateDir);
     this.serverOrder = servers.map((s2) => s2.name);
-    await Promise.all(servers.map((server) => this.connectOne(server)));
+    const timeoutMs = opts.timeoutMs ?? SERVER_CONNECT_TIMEOUT_MS;
+    await Promise.all(servers.map((server) => this.connectOne(server, timeoutMs, opts.onServer)));
   }
-  async connectOne(server) {
-    try {
+  /* BOUNDED, AND SETTLED EXACTLY ONCE.
+   *
+   * Every server connects under one Promise.all, and daemon startup awaits it.
+   * With no bound, one stalled server -- measured: an expired Microsoft 365
+   * token refreshing against a cold service, still waiting at 60 seconds --
+   * left the terminal silent after `mirrors sessions`, indistinguishable from a
+   * crash.
+   *
+   * The deadline covers the whole connect (any credential refresh, initialize,
+   * tools/list), not each request, because several individually bounded steps
+   * in a row can still add up to a hang. The attempt that loses the race keeps
+   * running; its late result is deliberately ignored, so a server reported as
+   * timed out cannot quietly become connected afterwards -- status would then
+   * tell doctor one thing and the registered tools another. */
+  async connectOne(server, timeoutMs, onServer) {
+    let timer;
+    const deadline = new Promise((resolve13) => {
+      timer = setTimeout(() => resolve13("timeout"), timeoutMs);
+    });
+    const attempt = (async () => {
       const client = this.clientFactory(this.stateDir, server);
       await client.initialize();
       const tools = await client.listTools();
-      this.connected.set(server.name, { client, tools });
-      this.statuses.set(server.name, { connected: true, toolCount: tools.length });
+      return { client, tools };
+    })();
+    attempt.catch(() => {
+    });
+    try {
+      const outcome = await Promise.race([attempt, deadline]);
+      if (outcome === "timeout") {
+        this.statuses.set(server.name, { connected: false, toolCount: 0, error: `timed out after ${timeoutMs / 1e3}s` });
+      } else {
+        this.connected.set(server.name, outcome);
+        this.statuses.set(server.name, { connected: true, toolCount: outcome.tools.length });
+      }
     } catch (err) {
       this.statuses.set(server.name, {
         connected: false,
         toolCount: 0,
         error: err instanceof Error ? err.message : String(err)
       });
+    } finally {
+      clearTimeout(timer);
     }
+    const settled = this.statuses.get(server.name);
+    if (settled) onServer?.({ server: server.name, ...settled });
   }
   /** Every tool from every connected server, paired with the server it came
    *  from, in CONFIGURED order (`serverOrder`) -- not the order servers
@@ -49110,7 +49339,12 @@ var McpRegistry = class {
    *  that records a failure without a reason, because "no tools" alone tells
    *  the reader nothing about what to fix. */
   status() {
-    return Array.from(this.statuses, ([server, s2]) => ({ server, ...s2 }));
+    const out = [];
+    for (const server of this.serverOrder) {
+      const s2 = this.statuses.get(server);
+      if (s2) out.push({ server, ...s2 });
+    }
+    return out;
   }
 };
 
@@ -49755,11 +49989,11 @@ async function main() {
   const procs = args.allowShell ? createNodeProcs({ roots: args.roots, log: slog }) : void 0;
   const mcpPolicy = buildMcpPolicy(fileConfig);
   const mcpRegistry = new McpRegistry(args.stateDir);
-  await mcpRegistry.connectAll();
+  slog("mcp: connecting configured servers\u2026");
+  await mcpRegistry.connectAll({
+    onServer: (s2) => slog(s2.connected ? `mcp: "${s2.server}" connected -- ${s2.toolCount} tool(s)` : `mcp: "${s2.server}" not connected -- ${s2.error} (run: corenel mcp doctor)`)
+  });
   const unregisterMcpTools = registerMcpTools(mcpRegistry, mcpPolicy);
-  for (const s2 of mcpRegistry.status()) {
-    slog(s2.connected ? `mcp: "${s2.server}" connected -- ${s2.toolCount} tool(s)` : `mcp: "${s2.server}" not connected -- ${s2.error} (run: corenel mcp doctor)`);
-  }
   const mcpPort = buildMcpPort(mcpRegistry, mcpPolicy);
   const mcpAdminPort = buildMcpAdmin(args.stateDir);
   const sessions = runner ? await wireSessions({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corenel/sidecar",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "type": "module",
   "license": "Elastic-2.0",
   "description": "Prompd sidecar — a local capability server. Run it next to Prompd (prompd.app) so the browser app can reach your machine: local LLMs (Ollama/LM Studio/vLLM) without CORS, your filesystem, and (opt-in) shell.",
@@ -36,10 +36,10 @@
     "esbuild": "^0.21.5",
     "tsx": "^4.19.2",
     "typescript": "^5.9.3",
-    "@corenel/harness": "0.7.0",
-    "@corenel/protocol": "0.7.0",
-    "@corenel/crew": "0.0.0",
-    "@corenel/tools-node": "0.3.2"
+    "@corenel/protocol": "0.7.1",
+    "@corenel/harness": "0.7.1",
+    "@corenel/tools-node": "0.3.3",
+    "@corenel/crew": "0.0.0"
   },
   "repository": {
     "type": "git",