spacecode 2.10.0 → 2.10.1

package/dist/repl.mjs

@@ -6019,9 +6019,9 @@ async function sha256(content) {
   const hashArray = new Uint8Array(hashBuffer);
   return Array.from(hashArray).map((b2) => b2.toString(16).padStart(2, "0")).join("");
 }
-async function computeLockfileHash(readFile10) {
+async function computeLockfileHash(readFile11) {
   for (const name of LOCKFILES) {
-    const content = await readFile10(name);
+    const content = await readFile11(name);
     if (content) {
       const hash = await sha256(content);
       return hash.slice(0, 12);
@@ -7274,6 +7274,70 @@ var init_source_changes = __esm({
   }
 });
 
+// ../agent/src/import/mcp-tool-cache.ts
+function serverCacheKey(def, hash) {
+  return hash(JSON.stringify([def.name, def.command, def.args, [...def.envNames].sort()]));
+}
+function cleanTool(raw) {
+  if (!isPlainObject(raw) || typeof raw.name !== "string" || raw.name === "" || typeof raw.description !== "string" || !isPlainObject(raw.inputSchema)) return null;
+  return { name: raw.name, description: raw.description.slice(0, MAX_DESCRIPTION), inputSchema: raw.inputSchema };
+}
+function parseToolCache(text) {
+  if (text === null || text === "") return { cache: {} };
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    if (!(err instanceof SyntaxError)) throw err;
+    return { cache: {}, error: "tool cache ignored: not valid JSON" };
+  }
+  if (!isPlainObject(raw) || raw.version !== 1 || !isPlainObject(raw.servers)) return { cache: {}, error: "tool cache ignored: unsupported format" };
+  const cache4 = {};
+  for (const key of Object.keys(raw.servers)) {
+    if (Object.keys(cache4).length >= MAX_SERVERS) break;
+    const entry = raw.servers[key];
+    if (!isPlainObject(entry) || !Array.isArray(entry.tools)) continue;
+    const tools = [];
+    for (const t of entry.tools) {
+      const clean = cleanTool(t);
+      if (clean) tools.push(clean);
+      if (tools.length >= MAX_TOOLS_PER_SERVER) break;
+    }
+    Object.defineProperty(cache4, key, { value: { tools }, enumerable: true, writable: true, configurable: true });
+  }
+  return { cache: cache4 };
+}
+function serializeToolCache(cache4) {
+  return JSON.stringify({ version: 1, servers: cache4 });
+}
+function getCachedTools(cache4, key) {
+  return own(cache4, key) ? cache4[key].tools : void 0;
+}
+function sameTools(a, b2) {
+  return JSON.stringify(a) === JSON.stringify(b2);
+}
+function putCachedTools(cache4, key, tools) {
+  const existing = getCachedTools(cache4, key);
+  if (existing && sameTools(existing, tools)) return cache4;
+  const next = {};
+  for (const k2 of Object.keys(cache4)) if (k2 !== key) Object.defineProperty(next, k2, { value: cache4[k2], enumerable: true, writable: true, configurable: true });
+  Object.defineProperty(next, key, { value: { tools }, enumerable: true, writable: true, configurable: true });
+  const keys = Object.keys(next);
+  for (const k2 of keys.slice(0, Math.max(0, keys.length - MAX_SERVERS))) delete next[k2];
+  return next;
+}
+var MAX_TOOLS_PER_SERVER, MAX_SERVERS, MAX_DESCRIPTION, own, isPlainObject;
+var init_mcp_tool_cache = __esm({
+  "../agent/src/import/mcp-tool-cache.ts"() {
+    "use strict";
+    MAX_TOOLS_PER_SERVER = 200;
+    MAX_SERVERS = 500;
+    MAX_DESCRIPTION = 1024;
+    own = (o, k2) => Object.hasOwn(o, k2);
+    isPlainObject = (v2) => typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
+  }
+});
+
 // ../agent/src/import/imports-config.ts
 function allOffConfig() {
   return {
@@ -7289,7 +7353,7 @@ function allOffConfig() {
     models: {}
   };
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseImportsConfig(text, path12) {
@@ -7301,11 +7365,11 @@ function parseImportsConfig(text, path12) {
   } catch {
     return fail("invalid JSON");
   }
-  if (!isPlainObject(parsed)) return fail("top-level JSON must be an object");
+  if (!isPlainObject2(parsed)) return fail("top-level JSON must be an object");
   if (parsed.version !== 1) return fail(`unsupported version ${String(parsed.version)}`);
   const config = allOffConfig();
   if (parsed.categories !== void 0) {
-    if (!isPlainObject(parsed.categories)) return fail("categories must be an object");
+    if (!isPlainObject2(parsed.categories)) return fail("categories must be an object");
     for (const [key, value] of Object.entries(parsed.categories)) {
       if (!IMPORT_CATEGORIES.includes(key)) return fail(`unknown category key "${key}"`);
       if (typeof value !== "boolean") return fail(`category "${key}" must be a boolean`);
@@ -7313,7 +7377,7 @@ function parseImportsConfig(text, path12) {
     }
   }
   if (parsed.models !== void 0) {
-    if (!isPlainObject(parsed.models)) return fail("models must be an object");
+    if (!isPlainObject2(parsed.models)) return fail("models must be an object");
     for (const key of MODEL_KEYS) {
       const value = parsed.models[key];
       if (value === void 0) continue;
@@ -8021,6 +8085,7 @@ __export(src_exports, {
   formatSkillBody: () => formatSkillBody,
   formatSourceChanges: () => formatSourceChanges,
   formatToolResult: () => formatToolResult,
+  getCachedTools: () => getCachedTools,
   guardHost: () => guardHost,
   isReadOnlyCommand: () => isReadOnlyCommand,
   joinSections: () => joinSections,
@@ -8032,13 +8097,18 @@ __export(src_exports, {
   parseImportsConfig: () => parseImportsConfig,
   parseSkillFile: () => parseSkillFile,
   parseTodos: () => parseTodos,
+  parseToolCache: () => parseToolCache,
   prepareAdaptation: () => prepareAdaptation,
   projectKey: () => projectKey,
+  putCachedTools: () => putCachedTools,
   readClaudeAssets: () => readClaudeAssets,
   renderProjectCard: () => renderProjectCard,
   runAgentLoop: () => runAgentLoop,
   safeSkillPath: () => safeSkillPath,
+  sameTools: () => sameTools,
   serializeImportsConfig: () => serializeImportsConfig,
+  serializeToolCache: () => serializeToolCache,
+  serverCacheKey: () => serverCacheKey,
   siblingAssetName: () => siblingAssetName,
   splitCommand: () => splitCommand,
   splitSections: () => splitSections,
@@ -8086,6 +8156,7 @@ var init_src = __esm({
     init_instructions_tool();
     init_trust();
     init_source_changes();
+    init_mcp_tool_cache();
     init_imports_config();
     init_permission_rules();
     init_command_args();
@@ -8115,7 +8186,7 @@ __export(api_key_exports, {
 });
 import { join } from "node:path";
 async function resolveApiKey(deps) {
-  const { env: env3, readFile: readFile10, homedir: homedir3 } = deps;
+  const { env: env3, readFile: readFile11, homedir: homedir3 } = deps;
   for (const name of ["SPACECODE_API_KEY", "ANTHROPIC_API_KEY"]) {
     const value = env3[name]?.trim();
     if (value) return value;
@@ -8124,7 +8195,7 @@ async function resolveApiKey(deps) {
   const file = join(dir, "auth.json");
   let raw;
   try {
-    raw = await readFile10(file);
+    raw = await readFile11(file);
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw new Error(`Cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
@@ -8904,6 +8975,14 @@ var init_mcp_manager = __esm({
       servers = /* @__PURE__ */ new Map();
       turnSignal;
       startPromise = null;
+      primePromise = null;
+      cache = {};
+      /** Cached tools of approved, startable servers, usable until the live list replaces them. */
+      cachedTools = /* @__PURE__ */ new Map();
+      /** Settles when a server has connected or failed, so a call on a cached tool can wait for it. */
+      connected = /* @__PURE__ */ new Map();
+      cacheNotes = [];
+      cacheWrite = Promise.resolve();
       /** Server states in definition order, so output does not depend on which server connected first. */
       ordered() {
         return this.deps.defs.map((d) => this.servers.get(d.name)).filter((s) => s !== void 0);
@@ -8912,11 +8991,86 @@ var init_mcp_manager = __esm({
       beginTurn(signal) {
         this.turnSignal = signal;
       }
+      /**
+       * Loads cached tool lists for servers that could start right now (stdio, approved on this machine, environment set),
+       * without spawning anything. Await it before building the first toolset. Never throws; a bad cache is noted in /status.
+       */
+      prime() {
+        this.primePromise ??= this.primeOnce();
+        return this.primePromise;
+      }
+      async primeOnce() {
+        const tc = this.deps.toolCache;
+        if (!tc) return;
+        try {
+          const parsed = parseToolCache(await tc.read());
+          this.cache = parsed.cache;
+          if (parsed.error) this.cacheNotes.push(parsed.error);
+        } catch (err) {
+          this.cacheNotes.push(`tool cache not read (${err instanceof Error ? err.message : String(err)})`);
+          return;
+        }
+        for (const def of this.deps.defs) {
+          try {
+            if (def.transport !== "stdio") continue;
+            const envNames = approvalEnv(def.env);
+            if (!await this.deps.isStdioApproved({ command: def.command, args: def.args, envNames })) continue;
+            if (!expandServerEnv({ command: def.command, args: def.args, env: def.env }, this.deps.env).ok) continue;
+            const hit = getCachedTools(this.cache, serverCacheKey({ name: def.name, command: def.command, args: def.args, envNames }, tc.hash));
+            if (hit) this.cachedTools.set(def.name, this.usable(def.name, hit).tools);
+          } catch (err) {
+            this.cacheNotes.push(`${def.name}: cached tools skipped (${err instanceof Error ? err.message : String(err)})`);
+          }
+        }
+      }
       /** Starts every eligible server in the background. Resolves when all have connected or failed; callers need not await it. */
       start() {
-        this.startPromise ??= Promise.all(this.deps.defs.map((def) => this.startOne(def))).then(() => void 0);
+        this.startPromise ??= Promise.all(this.deps.defs.map((def) => {
+          const p = this.startOne(def);
+          this.connected.set(def.name, p);
+          return p;
+        })).then(() => void 0);
         return this.startPromise;
       }
+      /** Tools whose full names are valid and unique, plus the ones that are not. */
+      usable(server, listed) {
+        const tools = [];
+        const skipped = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const tool of listed) {
+          const full = mcpToolName(server, tool.name);
+          if (!TOOL_NAME_RE.test(full) || seen.has(full)) skipped.push(tool.name);
+          else {
+            seen.add(full);
+            tools.push(tool);
+          }
+        }
+        return { tools, skipped };
+      }
+      /** Live tools once connected; cached ones while a server is still connecting (or not started yet). */
+      toolsOf(def) {
+        const s = this.servers.get(def.name);
+        if (s?.status === "ready") return s.tools;
+        if (s === void 0 || s.status === "connecting") return this.cachedTools.get(def.name) ?? [];
+        return [];
+      }
+      /** Stores the live list for the next start. Writes are serialized; a failure becomes a /status line. */
+      saveToolCache(def, tools) {
+        const tc = this.deps.toolCache;
+        if (!tc) return Promise.resolve();
+        this.cacheWrite = this.cacheWrite.then(async () => {
+          try {
+            const key = serverCacheKey({ name: def.name, command: def.command, args: def.args, envNames: approvalEnv(def.env) }, tc.hash);
+            const next = putCachedTools(this.cache, key, tools.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })));
+            if (next === this.cache) return;
+            await tc.write(serializeToolCache(next));
+            this.cache = next;
+          } catch (err) {
+            this.cacheNotes.push(`${def.name}: tool list not cached (${err instanceof Error ? err.message : String(err)})`);
+          }
+        });
+        return this.cacheWrite;
+      }
       async startOne(def) {
         const name = def.name;
         const skip = (reason) => void this.servers.set(name, { name, def, status: "skipped", reason });
@@ -8967,19 +9121,11 @@ var init_mcp_manager = __esm({
           });
           await client.initialize();
           const listed = await client.listTools();
-          const tools = [];
-          const skippedTools = [];
-          const seen = /* @__PURE__ */ new Set();
-          for (const tool of listed.tools) {
-            const full = mcpToolName(name, tool.name);
-            if (!TOOL_NAME_RE.test(full) || seen.has(full)) skippedTools.push(tool.name);
-            else {
-              seen.add(full);
-              tools.push(tool);
-            }
-          }
+          const { tools, skipped: skippedTools } = this.usable(name, listed.tools);
           if (listed.skipped > 0) skippedTools.push(`${listed.skipped} unnamed`);
           this.servers.set(name, { name, def, status: "ready", client, transport, session: session2, tools, skippedTools });
+          this.cachedTools.delete(name);
+          await this.saveToolCache(def, tools);
         } catch (err) {
           await transport?.close().catch(() => void 0);
           fail(err instanceof Error ? err.message : String(err));
@@ -8988,22 +9134,29 @@ var init_mcp_manager = __esm({
       /** Tools of every connected server, as the model sees them. */
       tools() {
         const out = [];
-        for (const s of this.ordered()) {
-          if (s.status !== "ready") continue;
-          for (const t of s.tools) {
-            out.push({ name: mcpToolName(s.name, t.name), description: `[MCP server ${s.name}] ${t.description}`.slice(0, 1024), input_schema: t.inputSchema });
+        for (const def of this.deps.defs) {
+          for (const t of this.toolsOf(def)) {
+            out.push({ name: mcpToolName(def.name, t.name), description: `[MCP server ${def.name}] ${t.description}`.slice(0, 1024), input_schema: t.inputSchema });
           }
         }
         return out;
       }
       handlers() {
         const out = {};
-        for (const s of this.ordered()) {
-          if (s.status !== "ready") continue;
-          for (const t of s.tools) out[mcpToolName(s.name, t.name)] = (input) => this.call(s.name, t.name, input);
+        for (const def of this.deps.defs) {
+          for (const t of this.toolsOf(def)) out[mcpToolName(def.name, t.name)] = (input) => this.callWhenReady(def.name, t.name, input);
         }
         return out;
       }
+      /** A call on a cached tool waits for its server to connect (bounded by the connect timeout) and then goes through the normal checks. */
+      async callWhenReady(server, tool, input) {
+        await this.connected.get(server);
+        const state = this.servers.get(server);
+        if (state?.status === "ready" && !state.tools.some((t) => t.name === tool)) {
+          return { output: `MCP server "${server}" no longer offers ${tool}; its tool list changed since it was cached.`, is_error: true };
+        }
+        return this.call(server, tool, input);
+      }
       async call(server, tool, input) {
         const full = mcpToolName(server, tool);
         const state = this.servers.get(server);
@@ -9045,11 +9198,18 @@ var init_mcp_manager = __esm({
       /** One line per server for /status; reasons never include env values or stderr. */
       statusLines() {
         const lines2 = [];
-        for (const s of this.ordered()) {
+        for (const def of this.deps.defs) {
+          const s = this.servers.get(def.name);
+          if (s === void 0) {
+            const cached3 = this.cachedTools.get(def.name);
+            if (cached3) lines2.push(`mcp: ${def.name} connecting... (${cached3.length} tools from cache)`);
+            continue;
+          }
           if (s.status === "ready") lines2.push(`mcp: ${s.name} ready, ${s.tools.length} tools${s.skippedTools.length ? ` (not usable: ${s.skippedTools.join(", ")})` : ""}`);
-          else if (s.status === "connecting") lines2.push(`mcp: ${s.name} connecting...`);
+          else if (s.status === "connecting") lines2.push(`mcp: ${s.name} connecting...${this.cachedTools.has(s.name) ? ` (${this.cachedTools.get(s.name).length} tools from cache)` : ""}`);
           else lines2.push(`mcp: ${s.name} NOT available (${s.reason})`);
         }
+        for (const n of this.cacheNotes) lines2.push(`mcp: ${n}`);
         return lines2;
       }
       /** For /tools: names grouped by server. */
@@ -44353,7 +44513,7 @@ var require_core = __commonJS({
       return match && match.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join14(regexps, separator = "|") {
+    function join15(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex2) => {
         numCaptures += 1;
@@ -44657,7 +44817,7 @@ var require_core = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join14(terminators), true);
+          this.matcherRe = langRe(join15(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -105001,12 +105161,37 @@ var init_skills_command = __esm({
   }
 });
 
-// src/permission-rules-loader.ts
+// src/mcp/tool-cache-file.ts
 import { readFile as readFile8 } from "node:fs/promises";
 import { join as join11 } from "node:path";
+function nodeToolCache(configDir) {
+  const path12 = join11(configDir, "mcp-tools-cache.json");
+  return {
+    read: async () => {
+      try {
+        return await readFile8(path12, "utf8");
+      } catch (err) {
+        if (err.code === "ENOENT") return null;
+        throw err;
+      }
+    },
+    write: (text) => writeTextAtomic(path12, text),
+    hash: sha2562
+  };
+}
+var init_tool_cache_file = __esm({
+  "src/mcp/tool-cache-file.ts"() {
+    "use strict";
+    init_import_gate();
+  }
+});
+
+// src/permission-rules-loader.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 async function readOrNull2(path12) {
   try {
-    return await readFile8(path12, "utf8");
+    return await readFile9(path12, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -105014,7 +105199,7 @@ async function readOrNull2(path12) {
 }
 async function loadPermissionRules(deps) {
   const none = (line) => ({ rules: void 0, defaultMode: void 0, statusLines: [line] });
-  const configPath = join11(deps.configDir, "imports.json");
+  const configPath = join12(deps.configDir, "imports.json");
   try {
     const loaded = parseImportsConfig(await readOrNull2(configPath), configPath);
     if (loaded.error) return none("permission rules: off (imports.json unreadable)");
@@ -105023,13 +105208,13 @@ async function loadPermissionRules(deps) {
     return none(`permission rules: off (imports.json not read: ${err instanceof Error ? err.message : String(err)})`);
   }
   const lines2 = [];
-  const files = [{ scope: "user", path: join11(deps.homeDir, ".claude", "settings.json") }];
+  const files = [{ scope: "user", path: join12(deps.homeDir, ".claude", "settings.json") }];
   try {
     const sources2 = await readRepoSources(deps.cwd);
     if (sources2[".claude/settings.json"] !== void 0 || sources2[".claude/settings.local.json"] !== void 0) {
       const status = await createNodeTrustStore(deps.configDir).repoStatus(deps.cwd, sources2);
       if (status === "trusted" || status === "session") {
-        files.push({ scope: "repo", path: join11(deps.cwd, ".claude", "settings.json") }, { scope: "local", path: join11(deps.cwd, ".claude", "settings.local.json") });
+        files.push({ scope: "repo", path: join12(deps.cwd, ".claude", "settings.json") }, { scope: "local", path: join12(deps.cwd, ".claude", "settings.local.json") });
       } else lines2.push(`permission rules: repo settings NOT loaded (${status === "never" ? "marked never trust" : "untrusted repo"})`);
     }
   } catch (err) {
@@ -105106,7 +105291,7 @@ var init_import_reload = __esm({
 });
 
 // src/command-loader.ts
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function userCommands(deps, lines2) {
   try {
     const apiKey = await resolveApiKey({ env: deps.env, readFile: deps.readFile, homedir: deps.homedir });
@@ -105161,7 +105346,7 @@ async function repoCommands(deps, lines2) {
   }
 }
 async function loadCommands(deps) {
-  const configPath = join12(deps.configDir, "imports.json");
+  const configPath = join13(deps.configDir, "imports.json");
   try {
     const loaded = parseImportsConfig(await deps.readFile(configPath).catch((err) => {
       if (err.code === "ENOENT") return null;
@@ -105194,9 +105379,9 @@ var init_command_loader = __esm({
 });
 
 // src/useReplController.ts
-import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir6 } from "node:fs/promises";
+import { readFile as readFile10, writeFile as writeFile6, mkdir as mkdir6 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { execFile as execFile4 } from "node:child_process";
 function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mentionsOpt, sessions, resumeLatest: resumeLatest2, onViewTurns, onViewResume, isEscOwned }) {
   const { exit } = use_app_default();
@@ -105219,7 +105404,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
   }, [turnStartedAt]);
   const projectRoot = (0, import_react30.useMemo)(() => process.cwd(), []);
   const promptTemplates = (0, import_react30.useCallback)(
-    () => loadPromptTemplates({ env: process.env, readFile: (p) => readFile9(p, "utf-8"), writeFile: (p, d) => writeFile6(p, d, "utf-8"), mkdir: (p) => mkdir6(p, { recursive: true }).then(() => void 0), homedir: homedir2, fetch }),
+    () => loadPromptTemplates({ env: process.env, readFile: (p) => readFile10(p, "utf-8"), writeFile: (p, d) => writeFile6(p, d, "utf-8"), mkdir: (p) => mkdir6(p, { recursive: true }).then(() => void 0), homedir: homedir2, fetch }),
     []
   );
   (0, import_react30.useEffect)(() => {
@@ -105235,11 +105420,11 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
   const recordingRef = (0, import_react30.useRef)(null);
   const recording = () => recordingRef.current ??= createRecordingRuntime({
     env: process.env,
-    configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join13(homedir2(), ".spacecode"),
+    configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join14(homedir2(), ".spacecode"),
     projectRoot,
     fetch,
     baseUrl: backendUrl(process.env),
-    resolveApiKey: () => resolveApiKey({ env: process.env, readFile: (p) => readFile9(p, "utf-8"), homedir: homedir2 }).catch(() => null),
+    resolveApiKey: () => resolveApiKey({ env: process.env, readFile: (p) => readFile10(p, "utf-8"), homedir: homedir2 }).catch(() => null),
     log: (m2) => console.error(`[agent-ui] ${m2}`)
   });
   const resumeListRef = (0, import_react30.useRef)([]);
@@ -105263,10 +105448,10 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
   (0, import_react30.useEffect)(() => {
     let live2 = true;
     loadCommands({
-      configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join13(homedir2(), ".spacecode"),
+      configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join14(homedir2(), ".spacecode"),
       cwd: process.cwd(),
       env: process.env,
-      readFile: (p) => readFile9(p, "utf-8"),
+      readFile: (p) => readFile10(p, "utf-8"),
       homedir: homedir2,
       fetch,
       builtins: SLASH_COMMANDS.map((c) => c.name)
@@ -105484,7 +105669,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
           notice(formatContextReport({ contextTokens: estimateTotalTokens("", history), maxContextTokens: DEFAULT_MAX_CONTEXT_TOKENS }));
           return;
         case "import": {
-          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join13(homedir2(), ".spacecode");
+          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join14(homedir2(), ".spacecode");
           const deps = { configDir, cwd: process.cwd() };
           const [sub, ...rest] = slash.args.split(/\s+/).filter(Boolean);
           if (sub !== "reload" || rest.length > 1 || rest[0] !== void 0 && rest[0] !== "trust") {
@@ -105497,7 +105682,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
               loadedSourcesRef.current = await trustCurrentSources(deps);
               const loaded = await loadPermissionRules({ configDir, homeDir: homedir2(), cwd: process.cwd() });
               rulesRef.current = loaded.rules;
-              const cmds = await loadCommands({ configDir, cwd: process.cwd(), env: process.env, readFile: (p) => readFile9(p, "utf-8"), homedir: homedir2, fetch, builtins: SLASH_COMMANDS.map((c) => c.name) });
+              const cmds = await loadCommands({ configDir, cwd: process.cwd(), env: process.env, readFile: (p) => readFile10(p, "utf-8"), homedir: homedir2, fetch, builtins: SLASH_COMMANDS.map((c) => c.name) });
               setCommandsLoaded(cmds);
               notice(["Trusted the repo import sources as they are now.", ...loaded.statusLines, ...cmds.statusLines, "MCP servers and skills apply on the next start."].join("\n"));
             } else notice((await describeReload(deps, baseline)).join("\n"));
@@ -105577,7 +105762,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
           }
           setIsRunning(true);
           try {
-            const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile9(p, "utf-8"), homedir: homedir2 });
+            const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile10(p, "utf-8"), homedir: homedir2 });
             if (!apiKey2) {
               notice(MISSING_KEY_MESSAGE);
               return;
@@ -105599,7 +105784,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
         }
         case "model": {
           try {
-            const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile9(p, "utf-8"), homedir: homedir2 });
+            const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile10(p, "utf-8"), homedir: homedir2 });
             if (!apiKey2) {
               notice(MISSING_KEY_MESSAGE);
               return;
@@ -105634,7 +105819,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
         }
         case "skills": {
           const state = profileRef.current;
-          const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile9(p, "utf-8"), homedir: homedir2 }).catch(() => null);
+          const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile10(p, "utf-8"), homedir: homedir2 }).catch(() => null);
           const client = apiKey2 ? createProfileClient({ baseUrl: backendUrl(process.env), apiKey: apiKey2, fetch }) : null;
           notice(await runSkillsCommand(slash.args, { source: state?.skills ?? null, client, statusLines: state?.statusLines.filter((l) => l.startsWith("skills")) ?? ["skills: not loaded yet (loads on your first message)"] }));
           return;
@@ -105656,7 +105841,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
     try {
       apiKey = await resolveApiKey({
         env: process.env,
-        readFile: (p) => readFile9(p, "utf-8"),
+        readFile: (p) => readFile10(p, "utf-8"),
         homedir: homedir2
       });
     } catch (err) {
@@ -105692,7 +105877,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
     let keepForRetry = false;
     try {
       if (loadedSourcesRef.current) {
-        const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join13(homedir2(), ".spacecode");
+        const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join14(homedir2(), ".spacecode");
         try {
           const check = await checkRepoSources({ configDir, cwd: process.cwd() }, loadedSourcesRef.current);
           if (check.changes.changed) {
@@ -105709,7 +105894,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
       }
       profilePromiseRef.current ??= prepareProfile({
         env: process.env,
-        readFile: (p) => readFile9(p, "utf-8"),
+        readFile: (p) => readFile10(p, "utf-8"),
         writeFile: (p, d) => writeFile6(p, d, { encoding: "utf-8", mode: 384 }),
         mkdir: async (p) => {
           await mkdir6(p, { recursive: true });
@@ -105719,7 +105904,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
         cwd: process.cwd(),
         gitRoot: gitTopLevel,
         importGate: async () => {
-          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join13(homedir2(), ".spacecode");
+          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join14(homedir2(), ".spacecode");
           const fingerprint = fingerprintSources(await readRepoSources(process.cwd()), sha2562);
           const gate = await importGateStatus({ configDir, cwd: process.cwd(), interactive: Boolean(process.stdin.isTTY) });
           const loaded = await loadPermissionRules({ configDir, homeDir: homedir2(), cwd: process.cwd() });
@@ -105731,7 +105916,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
       });
       profileRef.current = await profilePromiseRef.current;
       if (mcpRef.current === null && (profileRef.current?.mcpDefs?.length ?? 0) > 0) {
-        const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join13(homedir2(), ".spacecode");
+        const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join14(homedir2(), ".spacecode");
         const trust = createNodeTrustStore(configDir);
         const manager = new McpManager({
           defs: profileRef.current.mcpDefs,
@@ -105741,10 +105926,12 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
           ...rulesRef.current ? { rules: rulesRef.current } : {},
           permissions,
           confirm: askUser,
-          audit: new FileAuditLog(join13(homedir2(), ".spacecode", "audit.jsonl")),
-          clientVersion: process.env.SPACECODE_VERSION ?? "0"
+          audit: new FileAuditLog(join14(homedir2(), ".spacecode", "audit.jsonl")),
+          clientVersion: process.env.SPACECODE_VERSION ?? "0",
+          toolCache: nodeToolCache(configDir)
         });
         mcpRef.current = manager;
+        await manager.prime();
         void manager.start();
       }
       const toolset = createToolset();
@@ -105882,6 +106069,7 @@ var init_useReplController = __esm({
     init_skills_command();
     init_src();
     init_mcp_manager();
+    init_tool_cache_file();
     init_import_gate();
     init_permission_rules_loader();
     init_import_reload();
@@ -106471,7 +106659,7 @@ function clearOnResize(stdout) {
 var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
 if (process.argv[2] === "import-claude") {
   const { runImportClaude: runImportClaude2 } = await Promise.resolve().then(() => (init_import_claude(), import_claude_exports));
-  const { readFile: readFile10, readdir: readdir6 } = await import("node:fs/promises");
+  const { readFile: readFile11, readdir: readdir6 } = await import("node:fs/promises");
   const { execFile: execFile5 } = await import("node:child_process");
   const gitRoot = () => new Promise((resolve2) => {
     execFile5("git", ["rev-parse", "--show-toplevel"], { cwd: process.cwd() }, (err, stdout) => resolve2(err ? null : stdout.trim() || null));
@@ -106479,8 +106667,8 @@ if (process.argv[2] === "import-claude") {
   const code = await runImportClaude2({
     argv: process.argv.slice(2),
     env: process.env,
-    fs: { readFile: (p) => readFile10(p, "utf-8"), readdir: (p) => readdir6(p) },
-    readFile: (p) => readFile10(p, "utf-8"),
+    fs: { readFile: (p) => readFile11(p, "utf-8"), readdir: (p) => readdir6(p) },
+    readFile: (p) => readFile11(p, "utf-8"),
     homedir: os5.homedir,
     cwd: process.cwd(),
     gitRoot,
@@ -106505,9 +106693,9 @@ if (process.argv[2] === "approve-mcp") {
   const { resolveApiKey: resolveApiKey2 } = await Promise.resolve().then(() => (init_api_key(), api_key_exports));
   const { backendUrl: backendUrl2 } = await Promise.resolve().then(() => (init_profile_runtime(), profile_runtime_exports));
   const { createProfileClient: createProfileClient2 } = await Promise.resolve().then(() => (init_src(), src_exports));
-  const { readFile: readFile10 } = await import("node:fs/promises");
+  const { readFile: readFile11 } = await import("node:fs/promises");
   const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || path11.join(os5.homedir(), ".spacecode");
-  const apiKey = await resolveApiKey2({ env: process.env, readFile: (p) => readFile10(p, "utf-8"), homedir: os5.homedir }).catch(() => null);
+  const apiKey = await resolveApiKey2({ env: process.env, readFile: (p) => readFile11(p, "utf-8"), homedir: os5.homedir }).catch(() => null);
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const { createInterface } = interactive ? await import("node:readline/promises") : { createInterface: void 0 };
   const rl = createInterface ? createInterface({ input: process.stdin, output: process.stdout }) : void 0;
@@ -106515,7 +106703,7 @@ if (process.argv[2] === "approve-mcp") {
     const code = await runApproveMcp2({
       configDir,
       cwd: process.cwd(),
-      readFile: (p) => readFile10(p, "utf-8"),
+      readFile: (p) => readFile11(p, "utf-8"),
       client: apiKey ? createProfileClient2({ baseUrl: backendUrl2(process.env), apiKey, fetch }) : null,
       trust: createNodeTrustStore2(configDir),
       ...rl ? { ask: async (q2) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacecode",
-  "version": "2.10.0",
+  "version": "2.10.1",
   "description": "SpaceCode - launch cloud dev environments with AI coding agents",
   "license": "MIT",
   "type": "commonjs",