spacecode 2.10.0 → 2.10.2

package/dist/repl.mjs

@@ -3490,12 +3490,6 @@ function truncateOutput(text, maxChars) {
 
 ` + text.slice(text.length - effectiveTail);
 }
-function createSimpleRouter(opts) {
-  const threshold = opts.complexAfterTurn ?? 5;
-  return (turn, _lastToolCount) => {
-    return turn > threshold ? opts.complex : opts.default;
-  };
-}
 async function runAgentLoop(prompt, config, executor, emit, signal, existingMessages) {
   const defaultModel = config.model ?? DEFAULT_MODEL;
   const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
@@ -4211,98 +4205,9 @@ ${s.lines.join("\n")}`)].join("\n");
 });
 
 // ../agent/src/storage/file-store.ts
-var FileStore;
 var init_file_store = __esm({
   "../agent/src/storage/file-store.ts"() {
     "use strict";
-    FileStore = class {
-      constructor(db, sessionId) {
-        this.db = db;
-        this.sessionId = sessionId;
-      }
-      async readFile(path12) {
-        const stmt = this.db.prepare(
-          "SELECT content, status FROM session_files WHERE session_id = ? AND path = ?"
-        ).bind(this.sessionId, path12);
-        const row = await stmt.first();
-        if (row) {
-          if (row.status === "deleted") return null;
-          if (row.content !== null) return row.content;
-        }
-        return null;
-      }
-      async writeFile(path12, content) {
-        await this.db.prepare(
-          `INSERT OR REPLACE INTO session_files (session_id, path, status, content, updated_at)
-       VALUES (?, ?, 'created', ?, ?)`
-        ).bind(this.sessionId, path12, content, Date.now()).run();
-      }
-      async editFile(path12, oldStr, newStr) {
-        const content = await this.readFile(path12);
-        if (content === null) {
-          return { success: false, error: `File not found: ${path12}` };
-        }
-        if (!content.includes(oldStr)) {
-          return { success: false, error: `String not found in ${path12}` };
-        }
-        const occurrences = content.split(oldStr).length - 1;
-        if (occurrences > 1) {
-          return { success: false, error: `String appears ${occurrences} times in ${path12}. Provide more context to make it unique.` };
-        }
-        const newContent = content.replace(oldStr, newStr);
-        await this.db.prepare(
-          `INSERT OR REPLACE INTO session_files (session_id, path, status, content, updated_at)
-       VALUES (?, ?, 'modified', ?, ?)`
-        ).bind(this.sessionId, path12, newContent, Date.now()).run();
-        return { success: true };
-      }
-      async listDirectory(dirPath) {
-        const prefix = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
-        const stmt = this.db.prepare(
-          `SELECT DISTINCT path FROM session_files
-       WHERE session_id = ? AND path LIKE ? AND status != 'deleted'`
-        ).bind(this.sessionId, `${prefix}%`);
-        const { results } = await stmt.all();
-        const children = /* @__PURE__ */ new Set();
-        for (const row of results) {
-          const relative2 = row.path.slice(prefix.length);
-          const firstSlash = relative2.indexOf("/");
-          if (firstSlash === -1) {
-            children.add(relative2);
-          } else {
-            children.add(relative2.slice(0, firstSlash + 1));
-          }
-        }
-        return Array.from(children).sort();
-      }
-      async getDirtyFiles() {
-        const stmt = this.db.prepare(
-          `SELECT path, content, status FROM session_files
-       WHERE session_id = ? AND status IN ('modified', 'created')`
-        ).bind(this.sessionId);
-        const { results } = await stmt.all();
-        return results;
-      }
-      async markClean(paths) {
-        if (paths.length === 0) return;
-        const stmts = paths.map(
-          (p) => this.db.prepare(
-            `UPDATE session_files SET status = 'clean', updated_at = ? WHERE session_id = ? AND path = ?`
-          ).bind(Date.now(), this.sessionId, p)
-        );
-        await this.db.batch(stmts);
-      }
-      async upsertFiles(files) {
-        if (files.length === 0) return;
-        const stmts = files.map(
-          (f) => this.db.prepare(
-            `INSERT OR REPLACE INTO session_files (session_id, path, status, content, updated_at)
-         VALUES (?, ?, ?, ?, ?)`
-          ).bind(this.sessionId, f.path, f.status, f.content, Date.now())
-        );
-        await this.db.batch(stmts);
-      }
-    };
   }
 });
 
@@ -4329,9 +4234,9 @@ function createFileTools(store) {
     readCache.clear();
     listCache.clear();
   }
-  function invalidatePath(path12) {
-    readCache.delete(path12);
-    const parent = path12.includes("/") ? path12.slice(0, path12.lastIndexOf("/") + 1) : "";
+  function invalidatePath(path13) {
+    readCache.delete(path13);
+    const parent = path13.includes("/") ? path13.slice(0, path13.lastIndexOf("/") + 1) : "";
     listCache.delete(parent);
     listCache.delete("");
     listCache.delete(".");
@@ -4339,36 +4244,36 @@ function createFileTools(store) {
   }
   const handlers = {
     read_file: async (input) => {
-      const path12 = input.path;
-      const cached3 = readCache.get(path12);
+      const path13 = input.path;
+      const cached3 = readCache.get(path13);
       if (cached3 !== void 0) {
         return { output: cached3 };
       }
-      const content = await store.readFile(path12);
+      const content = await store.readFile(path13);
       if (content === null) {
-        return { output: `File not found: ${path12}`, is_error: true };
+        return { output: `File not found: ${path13}`, is_error: true };
       }
-      readCache.set(path12, content);
+      readCache.set(path13, content);
       return { output: content };
     },
     write_file: async (input) => {
-      const path12 = input.path;
+      const path13 = input.path;
       const content = input.content;
-      await store.writeFile(path12, content);
-      invalidatePath(path12);
-      readCache.set(path12, content);
-      return { output: `Written: ${path12}` };
+      await store.writeFile(path13, content);
+      invalidatePath(path13);
+      readCache.set(path13, content);
+      return { output: `Written: ${path13}` };
     },
     edit_file: async (input) => {
-      const path12 = input.path;
+      const path13 = input.path;
       const oldStr = input.old_string;
       const newStr = input.new_string;
-      let content = readCache.get(path12);
+      let content = readCache.get(path13);
       if (content === void 0) {
-        const stored = await store.readFile(path12);
+        const stored = await store.readFile(path13);
         if (stored === null) {
           return {
-            output: `File not found: ${path12}. Did you read the file first?`,
+            output: `File not found: ${path13}. Did you read the file first?`,
             is_error: true
           };
         }
@@ -4378,41 +4283,41 @@ function createFileTools(store) {
       if (lineNumbers.length === 0) {
         const lineCount = content.split("\n").length;
         return {
-          output: `old_string not found in ${path12}. The file has ${lineCount} lines. Did you read the file first?`,
+          output: `old_string not found in ${path13}. The file has ${lineCount} lines. Did you read the file first?`,
           is_error: true
         };
       }
       if (lineNumbers.length > 1) {
         const locations = lineNumbers.map((ln) => `  - line ${ln}`).join("\n");
         return {
-          output: `old_string matches ${lineNumbers.length} locations in ${path12}:
+          output: `old_string matches ${lineNumbers.length} locations in ${path13}:
 ${locations}
 Include more surrounding context to make old_string unique.`,
           is_error: true
         };
       }
-      const result = await store.editFile(path12, oldStr, newStr);
+      const result = await store.editFile(path13, oldStr, newStr);
       if (!result.success) {
         return { output: result.error, is_error: true };
       }
-      invalidatePath(path12);
-      const updated = await store.readFile(path12);
-      if (updated !== null) readCache.set(path12, updated);
-      return { output: `Edited: ${path12}` };
+      invalidatePath(path13);
+      const updated = await store.readFile(path13);
+      if (updated !== null) readCache.set(path13, updated);
+      return { output: `Edited: ${path13}` };
     },
     list_directory: async (input) => {
-      const path12 = input.path;
-      const cached3 = listCache.get(path12);
+      const path13 = input.path;
+      const cached3 = listCache.get(path13);
       if (cached3 !== void 0) {
         if (cached3.length === 0) {
-          return { output: `Empty or not found: ${path12}` };
+          return { output: `Empty or not found: ${path13}` };
         }
         return { output: cached3.join("\n") };
       }
-      const entries = await store.listDirectory(path12);
-      listCache.set(path12, entries);
+      const entries = await store.listDirectory(path13);
+      listCache.set(path13, entries);
       if (entries.length === 0) {
-        return { output: `Empty or not found: ${path12}` };
+        return { output: `Empty or not found: ${path13}` };
       }
       return { output: entries.join("\n") };
     }
@@ -4480,234 +4385,15 @@ var init_files = __esm({
 });
 
 // ../agent/src/storage/indexer.ts
-var CHUNK_SIZE, CHUNK_OVERLAP, BATCH_SIZE, MAX_FILE_SIZE, INDEXABLE_EXTENSIONS, RepoIndexer;
+var MAX_FILE_SIZE;
 var init_indexer = __esm({
   "../agent/src/storage/indexer.ts"() {
     "use strict";
-    CHUNK_SIZE = 500;
-    CHUNK_OVERLAP = 100;
-    BATCH_SIZE = 50;
     MAX_FILE_SIZE = 100 * 1024;
-    INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".ts",
-      ".js",
-      ".py",
-      ".go",
-      ".rs",
-      ".java",
-      ".tsx",
-      ".jsx",
-      ".md",
-      ".json",
-      ".yaml",
-      ".yml",
-      ".toml",
-      ".sql",
-      ".sh",
-      ".css",
-      ".html"
-    ]);
-    RepoIndexer = class {
-      config;
-      model;
-      constructor(config) {
-        this.config = config;
-        this.model = config.embeddingModel || "@cf/bge-base-en-v1.5";
-      }
-      /**
-       * Index files into Vectorize. Skips if repo+commit is already indexed.
-       * Returns number of chunks indexed.
-       */
-      async indexFiles(files) {
-        const existing = await this.config.db.prepare(
-          "SELECT COUNT(*) as count FROM repo_files WHERE repo_id = ? AND commit_sha = ?"
-        ).bind(this.config.repoId, this.config.commitSha).first();
-        if (existing && existing.count > 0) {
-          return 0;
-        }
-        const chunks = files.flatMap((f) => this.chunkFile(f.path, f.content));
-        if (chunks.length === 0) return 0;
-        let totalIndexed = 0;
-        for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
-          const batch = chunks.slice(i, i + BATCH_SIZE);
-          const texts = batch.map((c) => c.content);
-          const embedResult = await this.config.ai.run(this.model, { text: texts });
-          const vectors = batch.map((chunk, j2) => ({
-            id: chunk.id,
-            values: embedResult.data[j2],
-            metadata: {
-              path: chunk.path,
-              repo_id: this.config.repoId,
-              start_line: String(chunk.startLine),
-              end_line: String(chunk.endLine)
-            }
-          }));
-          await this.config.vectorize.upsert(vectors);
-          totalIndexed += vectors.length;
-        }
-        const stmts = files.map(
-          (f) => this.config.db.prepare(
-            `INSERT OR REPLACE INTO repo_files (repo_id, commit_sha, path, size, hash)
-         VALUES (?, ?, ?, ?, ?)`
-          ).bind(
-            this.config.repoId,
-            this.config.commitSha,
-            f.path,
-            f.content.length,
-            this.simpleHash(f.content)
-          )
-        );
-        for (let i = 0; i < stmts.length; i += 100) {
-          await this.config.db.batch(stmts.slice(i, i + 100));
-        }
-        return totalIndexed;
-      }
-      /**
-       * Delta re-index: index only files that changed.
-       */
-      async reindexFile(path12, content) {
-        const prefix = `${this.config.repoId}:${path12}:`;
-        const oldIds = Array.from({ length: 100 }, (_2, i) => `${prefix}${i}`);
-        await this.config.vectorize.deleteByIds(oldIds);
-        const chunks = this.chunkFile(path12, content);
-        if (chunks.length === 0) return 0;
-        const texts = chunks.map((c) => c.content);
-        const embedResult = await this.config.ai.run(this.model, { text: texts });
-        const vectors = chunks.map((chunk, j2) => ({
-          id: chunk.id,
-          values: embedResult.data[j2],
-          metadata: {
-            path: chunk.path,
-            repo_id: this.config.repoId,
-            start_line: String(chunk.startLine),
-            end_line: String(chunk.endLine)
-          }
-        }));
-        await this.config.vectorize.upsert(vectors);
-        return vectors.length;
-      }
-      /**
-       * Check if a repo+commit is already indexed.
-       */
-      async isIndexed() {
-        const result = await this.config.db.prepare(
-          "SELECT COUNT(*) as count FROM repo_files WHERE repo_id = ? AND commit_sha = ?"
-        ).bind(this.config.repoId, this.config.commitSha).first();
-        return (result?.count ?? 0) > 0;
-      }
-      /**
-       * Read all files from a FileStore and index those with indexable extensions.
-       * Skips files larger than 100KB.
-       * Returns the number of chunks indexed.
-       */
-      async indexFromStore(store, basePath = "/") {
-        const storeDb = store.db;
-        const sessionId = store.sessionId;
-        const prefix = basePath === "/" ? "" : basePath;
-        const allFiles = await storeDb.prepare(
-          `SELECT path, content FROM session_files
-       WHERE session_id = ? AND status != 'deleted' AND path LIKE ?`
-        ).bind(sessionId, `${prefix}%`).all();
-        const files = [];
-        for (const row of allFiles.results) {
-          const dotIndex = row.path.lastIndexOf(".");
-          if (dotIndex === -1) continue;
-          const ext = row.path.slice(dotIndex);
-          if (!INDEXABLE_EXTENSIONS.has(ext)) continue;
-          if (row.content && row.content.length > MAX_FILE_SIZE) continue;
-          if (!row.content) continue;
-          files.push({ path: row.path, content: row.content });
-        }
-        if (files.length === 0) return 0;
-        return this.indexFiles(files);
-      }
-      chunkFile(path12, content) {
-        if (content.length === 0) return [];
-        const chunks = [];
-        let charPos = 0;
-        let lineNum = 1;
-        let chunkIndex = 0;
-        while (charPos < content.length) {
-          const chunkContent = content.slice(charPos, charPos + CHUNK_SIZE);
-          const startLine = lineNum;
-          const linesInChunk = chunkContent.split("\n").length - 1;
-          const endLine = startLine + linesInChunk;
-          chunks.push({
-            id: `${this.config.repoId}:${path12}:${chunkIndex}`,
-            path: path12,
-            content: chunkContent,
-            startLine,
-            endLine
-          });
-          chunkIndex++;
-          const advance = CHUNK_SIZE - CHUNK_OVERLAP;
-          charPos += advance;
-          const advancedContent = content.slice(charPos - advance, charPos);
-          lineNum += (advancedContent.match(/\n/g) || []).length;
-        }
-        return chunks;
-      }
-      simpleHash(content) {
-        let hash = 0;
-        for (let i = 0; i < content.length; i++) {
-          const char = content.charCodeAt(i);
-          hash = (hash << 5) - hash + char;
-          hash |= 0;
-        }
-        return hash.toString(16);
-      }
-    };
   }
 });
 
 // ../agent/src/tools/search.ts
-function createSearchTool(config) {
-  const model = config.embeddingModel || "@cf/bge-base-en-v1.5";
-  return async (input) => {
-    const query = input.query;
-    const limit = input.limit || 10;
-    if (!query || query.trim().length === 0) {
-      return { output: "Search query cannot be empty", is_error: true };
-    }
-    try {
-      let embedResult;
-      try {
-        embedResult = await config.ai.run(model, { text: [query] });
-      } catch {
-        return { output: `Semantic search is not available. Use the bash tool with grep to search the codebase instead.
-Example: bash -c "grep -rn 'pattern' ."` };
-      }
-      const queryVector = embedResult.data[0];
-      const results = await config.vectorize.query(queryVector, {
-        topK: limit,
-        filter: { repo_id: config.repoId },
-        returnMetadata: "all"
-      });
-      if (results.matches.length === 0) {
-        return { output: "No results found." };
-      }
-      const byFile = /* @__PURE__ */ new Map();
-      for (const match of results.matches) {
-        const path12 = match.metadata?.path ?? "unknown";
-        if (!byFile.has(path12)) byFile.set(path12, []);
-        byFile.get(path12).push({
-          score: match.score,
-          startLine: match.metadata?.start_line ?? "?",
-          endLine: match.metadata?.end_line ?? "?"
-        });
-      }
-      const lines2 = [];
-      for (const [path12, matches] of byFile) {
-        const bestScore = Math.max(...matches.map((m2) => m2.score));
-        const lineRanges = matches.sort((a, b2) => Number(a.startLine) - Number(b2.startLine)).map((m2) => `L${m2.startLine}-${m2.endLine}`).join(", ");
-        lines2.push(`${path12} (score: ${bestScore.toFixed(3)}) \u2014 ${lineRanges}`);
-      }
-      return { output: lines2.join("\n") };
-    } catch (err) {
-      return { output: `Search failed: ${err instanceof Error ? err.message : String(err)}`, is_error: true };
-    }
-  };
-}
 function createHostSearchTool(exec2) {
   return async (input) => {
     const query = input.query;
@@ -4748,126 +4434,9 @@ var init_search = __esm({
 });
 
 // ../agent/src/tools/sentry.ts
-function formatIssue(issue) {
-  return `[${issue.shortId}] ${issue.title}
-  Level: ${issue.level} | Count: ${issue.count} | Last seen: ${issue.lastSeen}`;
-}
-function formatIssueDetail(issue) {
-  const lines2 = [];
-  lines2.push(`Issue: ${issue.shortId} (${issue.id})`);
-  lines2.push(`Title: ${issue.title}`);
-  lines2.push(`Culprit: ${issue.culprit}`);
-  lines2.push(`Level: ${issue.level} | Count: ${issue.count}`);
-  lines2.push(`First seen: ${issue.firstSeen}`);
-  lines2.push(`Last seen: ${issue.lastSeen}`);
-  if (issue.metadata.type || issue.metadata.value) {
-    lines2.push(`
-Error: ${issue.metadata.type ?? ""}: ${issue.metadata.value ?? ""}`);
-  }
-  if (issue.tags.length > 0) {
-    lines2.push(`
-Tags:`);
-    for (const tag of issue.tags) {
-      lines2.push(`  ${tag.key}: ${tag.value}`);
-    }
-  }
-  if (issue.stackTrace && issue.stackTrace.length > 0) {
-    lines2.push(`
-Stack trace:`);
-    for (const frame of issue.stackTrace) {
-      lines2.push(`  ${frame.filename}:${frame.lineNo} in ${frame.function}`);
-      if (frame.context.length > 0) {
-        for (const [lineNo, code] of frame.context) {
-          const marker = lineNo === frame.lineNo ? ">" : " ";
-          lines2.push(`  ${marker} ${lineNo}: ${code}`);
-        }
-      }
-    }
-  }
-  return lines2.join("\n");
-}
-function createSentryTools(fetchFn) {
-  const handlers = {
-    sentry_list_issues: async (input) => {
-      const project = input.project;
-      const query = input.query;
-      const params = new URLSearchParams();
-      if (project) params.set("project", project);
-      if (query) params.set("query", query);
-      const qs = params.toString();
-      const path12 = `/api/sentry/issues${qs ? `?${qs}` : ""}`;
-      try {
-        const res = await fetchFn(path12);
-        if (!res.ok) {
-          const text = await res.text();
-          return { output: `Sentry API error (${res.status}): ${text}`, is_error: true };
-        }
-        const issues = await res.json();
-        if (issues.length === 0) {
-          return { output: "No unresolved issues found." };
-        }
-        return { output: issues.map(formatIssue).join("\n\n") };
-      } catch (err) {
-        return { output: `Failed to list Sentry issues: ${err.message}`, is_error: true };
-      }
-    },
-    sentry_get_issue: async (input) => {
-      const issueId = input.issue_id;
-      if (!issueId) {
-        return { output: "Missing required parameter: issue_id", is_error: true };
-      }
-      try {
-        const res = await fetchFn(`/api/sentry/issues/${encodeURIComponent(issueId)}`);
-        if (!res.ok) {
-          const text = await res.text();
-          return { output: `Sentry API error (${res.status}): ${text}`, is_error: true };
-        }
-        const issue = await res.json();
-        return { output: formatIssueDetail(issue) };
-      } catch (err) {
-        return { output: `Failed to get Sentry issue: ${err.message}`, is_error: true };
-      }
-    }
-  };
-  return { handlers };
-}
-var SENTRY_LIST_ISSUES_TOOL, SENTRY_GET_ISSUE_TOOL, SENTRY_TOOL_DEFINITIONS;
 var init_sentry = __esm({
   "../agent/src/tools/sentry.ts"() {
     "use strict";
-    SENTRY_LIST_ISSUES_TOOL = {
-      name: "sentry_list_issues",
-      description: "List unresolved Sentry issues. Optionally filter by project slug or search query.",
-      input_schema: {
-        type: "object",
-        properties: {
-          project: {
-            type: "string",
-            description: "Sentry project slug to filter by (optional)"
-          },
-          query: {
-            type: "string",
-            description: "Search query to filter issues (optional)"
-          }
-        },
-        required: []
-      }
-    };
-    SENTRY_GET_ISSUE_TOOL = {
-      name: "sentry_get_issue",
-      description: "Get detailed information about a Sentry issue including its stack trace.",
-      input_schema: {
-        type: "object",
-        properties: {
-          issue_id: {
-            type: "string",
-            description: "The Sentry issue ID"
-          }
-        },
-        required: ["issue_id"]
-      }
-    };
-    SENTRY_TOOL_DEFINITIONS = [SENTRY_LIST_ISSUES_TOOL, SENTRY_GET_ISSUE_TOOL];
   }
 });
 
@@ -4966,83 +4535,9 @@ var init_github = __esm({
 });
 
 // ../agent/src/tools/preview.ts
-function formatResult(body) {
-  switch (body.status) {
-    case "ready":
-      return { output: `Preview ready: ${body.url}
-Framework: ${body.framework ?? "unknown"}` };
-    case "starting":
-      return {
-        output: `Preview server is starting (still compiling). URL will be: ${body.url ?? "unknown"}
-Check again in a few seconds by calling this tool again.`
-      };
-    case "crashed":
-      return {
-        output: `Preview server crashed.${body.url ? ` URL was: ${body.url}` : ""}${body.exitCode !== void 0 ? ` Exit code: ${body.exitCode}` : ""}${body.logs ? `
-Logs:
-${body.logs}` : ""}${body.error ? `
-${body.error}` : ""}`,
-        is_error: true
-      };
-    default:
-      return { output: body.error ?? "Unknown preview status", is_error: true };
-  }
-}
-function createPreviewTool(fetchFn) {
-  return async (_input) => {
-    let startBody;
-    try {
-      const startRes = await fetchFn("/preview", { method: "POST" });
-      startBody = await startRes.json();
-      if (!startRes.ok) {
-        return { output: startBody.error ?? `Failed to start preview (HTTP ${startRes.status})`, is_error: true };
-      }
-    } catch (err) {
-      return { output: `Failed to start preview: ${err.message}`, is_error: true };
-    }
-    if (startBody.status !== "starting") {
-      return formatResult(startBody);
-    }
-    let lastPollError;
-    for (let attempt = 0; attempt < POLL_ATTEMPTS; attempt++) {
-      await new Promise((resolve2) => setTimeout(resolve2, POLL_DELAY_MS));
-      try {
-        const statusRes = await fetchFn("/preview", { method: "GET" });
-        const statusBody = await statusRes.json();
-        lastPollError = void 0;
-        if (statusBody.status === "ready" || statusBody.status === "crashed") {
-          return formatResult(statusBody);
-        }
-      } catch (err) {
-        lastPollError = err instanceof Error ? err.message : String(err);
-        console.error("Preview status poll failed, retrying", { error: lastPollError });
-      }
-    }
-    if (lastPollError) {
-      return {
-        output: `Could not confirm preview status after ${POLL_ATTEMPTS} attempts (last error: ${lastPollError}). The server may still be starting, or status checks may be failing \u2014 try calling this tool again.`,
-        is_error: true
-      };
-    }
-    return formatResult(startBody);
-  };
-}
-var PREVIEW_TOOL, PREVIEW_TOOL_DEFINITIONS, POLL_ATTEMPTS, POLL_DELAY_MS;
 var init_preview = __esm({
   "../agent/src/tools/preview.ts"() {
     "use strict";
-    PREVIEW_TOOL = {
-      name: "preview",
-      description: 'Start or check the status of the front-end dev server preview for this workspace and get a live URL to view the current state of the app. Call this after making a front-end change to verify it visually. The result distinguishes "starting" (server launching, still compiling) from "ready" (server is up, safe to view) from "crashed" (server process died \u2014 check logs in the result).',
-      input_schema: {
-        type: "object",
-        properties: {},
-        required: []
-      }
-    };
-    PREVIEW_TOOL_DEFINITIONS = [PREVIEW_TOOL];
-    POLL_ATTEMPTS = 3;
-    POLL_DELAY_MS = 1500;
   }
 });
 
@@ -5109,414 +4604,23 @@ var init_todo = __esm({
 });
 
 // ../agent/src/tools/codegen.ts
-async function detectStackType(fileStore) {
-  if (await fileStore.readFile("wrangler.toml") !== null || await fileStore.readFile("wrangler.jsonc") !== null) return "worker";
-  if (await fileStore.readFile("app.json") !== null || await fileStore.readFile("expo.json") !== null) return "mobile";
-  if (await fileStore.readFile("next.config.js") !== null || await fileStore.readFile("next.config.ts") !== null || await fileStore.readFile("next.config.mjs") !== null) return "pages";
-  return "worker";
-}
-async function cancelBuild(baseUrl, buildId, authHeader) {
-  try {
-    const res = await fetch(`${baseUrl}/builds/${buildId}/cancel`, {
-      method: "POST",
-      headers: { "Authorization": authHeader }
-    });
-    if (!res.ok) console.error(`[codegen] cancel of build ${buildId} failed: HTTP ${res.status}`);
-  } catch (err) {
-    console.error(`[codegen] cancel of build ${buildId} failed:`, err);
-  }
-}
-function createCodegenTools(fileStore, config) {
-  const handlers = {
-    build_feature: async (input, onOutput) => {
-      const title = input.title;
-      const requirements = input.requirements;
-      const context = input.context;
-      const stackTypeOverride = input.stackType;
-      if (!title || !requirements) {
-        return { output: "Missing required parameters: title and requirements", is_error: true };
-      }
-      const stackType = stackTypeOverride ?? await detectStackType(fileStore);
-      const toolId = crypto.randomUUID();
-      if (config.jwtToken) {
-        const baseUrl = "https://api.codemindhq.dev";
-        const authHeader = `Bearer ${config.jwtToken}`;
-        onOutput?.(toolId, "stdout", `[codegen] Submitting build...
-`);
-        const submitRes = await fetch(`${baseUrl}/builds`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json", "Authorization": authHeader },
-          body: JSON.stringify({
-            product: config.product ?? "spacecode",
-            repoUrl: config.repoUrl,
-            storyTitle: title,
-            acceptanceCriteria: requirements,
-            architectureContext: context ?? "",
-            stackType,
-            skipCommit: true
-          })
-        });
-        if (!submitRes.ok) {
-          const err = await submitRes.text().catch(() => "unknown");
-          throw new Error(`Codegen submit error: ${submitRes.status} ${err}`);
-        }
-        const { id: buildId2 } = await submitRes.json();
-        onOutput?.(toolId, "stdout", `[codegen] Build ${buildId2} queued, waiting...
-`);
-        const baseDelay = CODEGEN_POLL_INTERVAL_MS;
-        let status = "queued";
-        let consecutiveFailures = 0;
-        for (let i = 0; i < CODEGEN_POLL_MAX_ATTEMPTS && status !== "completed"; i++) {
-          await new Promise((r) => setTimeout(r, baseDelay));
-          const poll = await fetch(`${baseUrl}/builds/${buildId2}`, {
-            headers: { "Authorization": authHeader }
-          });
-          if (!poll.ok) {
-            consecutiveFailures++;
-            if (consecutiveFailures >= MAX_CONSECUTIVE_POLL_FAILURES) {
-              await cancelBuild(baseUrl, buildId2, authHeader);
-              throw new Error(`Codegen build ${buildId2}: polling failed ${consecutiveFailures} times in a row (last HTTP ${poll.status}); build cancelled`);
-            }
-            continue;
-          }
-          consecutiveFailures = 0;
-          const b2 = await poll.json();
-          status = b2.status;
-          if (b2.error) throw new Error(`Codegen failed: ${b2.error}`);
-          if (TERMINAL_FAILURE_STATUSES.has(status)) {
-            throw new Error(`Build ${buildId2} ended with status: ${status}`);
-          }
-        }
-        if (status !== "completed") {
-          await cancelBuild(baseUrl, buildId2, authHeader);
-          throw new Error(`Build ${buildId2} did not finish within ${CODEGEN_POLL_MAX_ATTEMPTS * baseDelay / 1e3}s (last status: ${status}); cancelled`);
-        }
-        const filesRes = await fetch(`${baseUrl}/builds/${buildId2}/files`, {
-          headers: { "Authorization": authHeader }
-        });
-        if (!filesRes.ok) throw new Error(`Failed to fetch files: ${filesRes.status}`);
-        const { files: files2 } = await filesRes.json();
-        if (!files2?.length) throw new Error("Build completed but no files generated");
-        const written2 = [];
-        for (const file of files2) {
-          await fileStore.writeFile(file.path, file.content);
-          written2.push(file.path);
-        }
-        onOutput?.(toolId, "stdout", `[codegen] ${files2.length} files written
-`);
-        return {
-          output: [
-            `Generated ${files2.length} files for: ${title}`,
-            "",
-            "Files written to workspace:",
-            ...written2.map((p) => `  ${p}`),
-            "",
-            "Run tests to verify, then commit when ready."
-          ].join("\n")
-        };
-      }
-      if (!config.codegenUrl) {
-        throw new Error("No codegen backend configured (set jwtToken or codegenUrl)");
-      }
-      const res = await fetch(`${config.codegenUrl}/builds?mode=interactive`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${config.apiKey}`,
-          "x-tenant-id": config.tenantId ?? ""
-        },
-        body: JSON.stringify({
-          product: config.product,
-          repoUrl: config.repoUrl,
-          storyTitle: title,
-          acceptanceCriteria: requirements,
-          architectureContext: context ?? "",
-          stackType,
-          skipCommit: true
-        })
-      });
-      if (!res.ok) {
-        const err = await res.text().catch(() => "unknown");
-        throw new Error(`Codegen service error: ${res.status} ${err}`);
-      }
-      const reader = res.body?.getReader();
-      if (!reader) throw new Error("No response body");
-      const decoder = new TextDecoder();
-      let buildId = "";
-      let summary = "";
-      let buffer = "";
-      let currentEvent = "";
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines2 = buffer.split("\n");
-          buffer = lines2.pop() ?? "";
-          for (const line of lines2) {
-            if (line.startsWith("event: ")) {
-              currentEvent = line.slice(7).trim();
-              continue;
-            }
-            if (!line.startsWith("data: ")) continue;
-            let data;
-            try {
-              data = JSON.parse(line.slice(6));
-            } catch (parseErr) {
-              throw new Error(`Codegen stream sent malformed event data: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
-            }
-            if (currentEvent === "phase" && onOutput) {
-              const count = data.componentCount ? ` (${data.componentCount} components)` : "";
-              onOutput(toolId, "stdout", `[codegen] ${data.phase}: ${data.status}${count}
-`);
-            }
-            if (currentEvent === "component" && onOutput) {
-              const status = data.fromLibrary ? "reused from library" : data.status;
-              onOutput(toolId, "stdout", `[codegen] ${data.name}: ${status}
-`);
-            }
-            if (currentEvent === "error") {
-              throw new Error(`Codegen error: ${data.message}`);
-            }
-            if (currentEvent === "complete") {
-              buildId = data.buildId;
-              summary = `Generated ${data.filesGenerated ?? 0} files (${data.componentsReused ?? 0} reused)`;
-            }
-            currentEvent = "";
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
-      if (!buildId) {
-        throw new Error("Codegen stream ended without completion");
-      }
-      const buildRes = await fetch(`${config.codegenUrl}/builds/${buildId}`, {
-        headers: {
-          "Authorization": `Bearer ${config.apiKey}`,
-          "x-tenant-id": config.tenantId ?? ""
-        }
-      });
-      if (!buildRes.ok) {
-        throw new Error(`Failed to fetch build result: ${buildRes.status}`);
-      }
-      const build2 = await buildRes.json();
-      if (!build2.result) {
-        throw new Error("Build completed but no files in result");
-      }
-      let files;
-      try {
-        const parsed = JSON.parse(build2.result);
-        files = parsed.files ?? [];
-      } catch {
-        throw new Error("Failed to parse build result");
-      }
-      if (files.length === 0) {
-        throw new Error("Codegen produced no files");
-      }
-      const written = [];
-      for (const file of files) {
-        await fileStore.writeFile(file.path, file.content);
-        written.push(file.path);
-      }
-      return {
-        output: [
-          summary,
-          "",
-          "Files written to workspace:",
-          ...written.map((p) => `  ${p}`),
-          "",
-          "Run tests to verify, then commit when ready."
-        ].join("\n")
-      };
-    }
-  };
-  return { handlers };
-}
-var BUILD_FEATURE_TOOL, CODEGEN_TOOL_DEFINITIONS, CODEGEN_POLL_INTERVAL_MS, CODEGEN_POLL_MAX_ATTEMPTS, MAX_CONSECUTIVE_POLL_FAILURES, TERMINAL_FAILURE_STATUSES;
 var init_codegen = __esm({
   "../agent/src/tools/codegen.ts"() {
     "use strict";
-    BUILD_FEATURE_TOOL = {
-      name: "build_feature",
-      description: "Generate a complete feature using the platform codegen service. Produces multiple files with tests, leveraging a library of reusable components. Use this for multi-file features, new modules, or significant refactors. Files are written to the workspace \u2014 run tests afterwards to verify. Prefer this over manually writing multiple files.",
-      input_schema: {
-        type: "object",
-        properties: {
-          title: {
-            type: "string",
-            description: 'Feature title (e.g., "Add user authentication with sessions and API keys")'
-          },
-          requirements: {
-            type: "string",
-            description: "Acceptance criteria or detailed requirements for the feature"
-          },
-          context: {
-            type: "string",
-            description: "Architecture context \u2014 existing code patterns, tech stack, conventions."
-          },
-          stackType: {
-            type: "string",
-            enum: ["worker", "mobile", "pages"],
-            description: "Override auto-detected stack type. Usually not needed."
-          }
-        },
-        required: ["title", "requirements"]
-      }
-    };
-    CODEGEN_TOOL_DEFINITIONS = [BUILD_FEATURE_TOOL];
-    CODEGEN_POLL_INTERVAL_MS = 5e3;
-    CODEGEN_POLL_MAX_ATTEMPTS = 120;
-    MAX_CONSECUTIVE_POLL_FAILURES = 5;
-    TERMINAL_FAILURE_STATUSES = /* @__PURE__ */ new Set(["failed", "cancelled", "canceled", "error"]);
   }
 });
 
 // ../agent/src/sandbox/snapshot-manager.ts
-var SnapshotManager;
 var init_snapshot_manager = __esm({
   "../agent/src/sandbox/snapshot-manager.ts"() {
     "use strict";
-    SnapshotManager = class {
-      constructor(config) {
-        this.config = config;
-      }
-      /**
-       * Get or create a container for the given repo+lockfile.
-       * If a snapshot exists, restore from it (~1-3s).
-       * If not, create fresh container (~30-60s), then snapshot it for next time.
-       */
-      async getOrCreateContainer(repoId, lockfileHash, setupFn) {
-        const existing = await this.config.db.prepare(
-          "SELECT backup_handle, image_version FROM repo_snapshots WHERE repo_id = ? AND lockfile_hash = ?"
-        ).bind(repoId, lockfileHash).first();
-        if (existing && existing.image_version === this.config.imageVersion) {
-          const sandbox2 = await this.config.sandboxNs.restore(existing.backup_handle);
-          await this.config.db.prepare(
-            "UPDATE repo_snapshots SET last_used_at = ? WHERE repo_id = ? AND lockfile_hash = ?"
-          ).bind(Date.now(), repoId, lockfileHash).run();
-          return sandbox2;
-        }
-        const sandbox = await this.config.sandboxNs.create();
-        if (setupFn) {
-          await setupFn(sandbox);
-        }
-        const handle = await sandbox.backup();
-        await this.config.db.prepare(
-          `INSERT OR REPLACE INTO repo_snapshots (repo_id, lockfile_hash, backup_handle, image_version, created_at, last_used_at, ttl_hours)
-       VALUES (?, ?, ?, ?, ?, ?, 168)`
-        ).bind(repoId, lockfileHash, handle, this.config.imageVersion, Date.now(), Date.now()).run();
-        return sandbox;
-      }
-      /**
-       * Clean up expired snapshots (older than TTL).
-       */
-      async cleanupExpired() {
-        const now = Date.now();
-        const result = await this.config.db.prepare(
-          "SELECT repo_id, lockfile_hash FROM repo_snapshots WHERE (last_used_at + ttl_hours * 3600000) < ?"
-        ).bind(now).all();
-        if (result.results.length === 0) return 0;
-        const stmts = result.results.map(
-          (r) => this.config.db.prepare(
-            "DELETE FROM repo_snapshots WHERE repo_id = ? AND lockfile_hash = ?"
-          ).bind(r.repo_id, r.lockfile_hash)
-        );
-        await this.config.db.batch(stmts);
-        return result.results.length;
-      }
-    };
   }
 });
 
 // ../agent/src/sandbox/sync.ts
-async function syncBeforeBash(store, sandbox, workDir) {
-  const dirtyFiles = await store.getDirtyFiles();
-  const errors = [];
-  let pushed = 0;
-  for (const file of dirtyFiles) {
-    try {
-      const fullPath = `${workDir}/${file.path}`;
-      const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
-      await sandbox.exec(`mkdir -p '${dir}'`);
-      await sandbox.writeFile(fullPath, file.content);
-      pushed++;
-    } catch (err) {
-      errors.push(`Failed to push ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  return { filesPushed: pushed, errors };
-}
-async function syncAfterBash(store, sandbox, workDir) {
-  const errors = [];
-  let pulled = 0;
-  const gitResult = await sandbox.exec(`cd '${workDir}' && git status --short`);
-  if (gitResult.exitCode !== 0) {
-    return { filesPulled: 0, errors: [`git status failed: ${gitResult.stderr}`] };
-  }
-  if (!gitResult.stdout.trim()) {
-    return { filesPulled: 0, errors: [] };
-  }
-  const changedFiles = parseGitStatus(gitResult.stdout);
-  const fileEntries = [];
-  for (const file of changedFiles) {
-    if (file.status === "deleted") {
-      fileEntries.push({ path: file.path, content: "", status: "deleted" });
-      pulled++;
-      continue;
-    }
-    if (isGeneratedPath(file.path)) continue;
-    try {
-      const content = await sandbox.readFile(`${workDir}/${file.path}`);
-      fileEntries.push({
-        path: file.path,
-        content,
-        status: file.status === "new" ? "created" : "modified"
-      });
-      pulled++;
-    } catch (err) {
-      errors.push(`Failed to pull ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  if (fileEntries.length > 0) {
-    await store.upsertFiles(fileEntries);
-  }
-  return { filesPulled: pulled, errors };
-}
-function parseGitStatus(output) {
-  const entries = [];
-  for (const line of output.split("\n")) {
-    if (!line.trim()) continue;
-    const statusCode = line.substring(0, 2);
-    const path12 = line.substring(3).trim();
-    if (!path12) continue;
-    if (statusCode.includes("D")) {
-      entries.push({ path: path12, status: "deleted" });
-    } else if (statusCode === "??" || statusCode.includes("A")) {
-      entries.push({ path: path12, status: "new" });
-    } else {
-      entries.push({ path: path12, status: "modified" });
-    }
-  }
-  return entries;
-}
-function isGeneratedPath(path12) {
-  return GENERATED_PATTERNS.some((p) => path12.startsWith(p) || path12.includes(`/${p}`));
-}
-var GENERATED_PATTERNS;
 var init_sync = __esm({
   "../agent/src/sandbox/sync.ts"() {
     "use strict";
-    GENERATED_PATTERNS = [
-      "node_modules/",
-      "dist/",
-      ".cache/",
-      ".next/",
-      "__pycache__/",
-      ".pytest_cache/",
-      "coverage/",
-      ".git/"
-    ];
   }
 });
 
@@ -5927,17 +5031,11 @@ import * as path2 from "node:path";
 function truncate(e) {
   return e.subject.length > MAX_SUBJECT ? { ...e, subject: e.subject.slice(0, MAX_SUBJECT) + "...[truncated]" } : e;
 }
-var MAX_SUBJECT, MemoryAuditLog, FileAuditLog;
+var MAX_SUBJECT, FileAuditLog;
 var init_audit_log = __esm({
   "../agent/src/host/audit-log.ts"() {
     "use strict";
     MAX_SUBJECT = 4096;
-    MemoryAuditLog = class {
-      entries = [];
-      async record(entry) {
-        this.entries.push(truncate(entry));
-      }
-    };
     FileAuditLog = class {
       constructor(file) {
         this.file = file;
@@ -5951,89 +5049,23 @@ var init_audit_log = __esm({
 });
 
 // ../agent/src/host/cloud-host.ts
-var CloudHost;
 var init_cloud_host = __esm({
   "../agent/src/host/cloud-host.ts"() {
     "use strict";
-    CloudHost = class {
-      kind = "cloud";
-      files;
-      execFn;
-      constructor(config) {
-        this.files = config.files;
-        this.execFn = config.exec;
-      }
-      exec(command, onOutput) {
-        return this.execFn(command, onOutput);
-      }
-    };
   }
 });
 
 // ../agent/src/replay-buffer.ts
-var ReplayBuffer;
 var init_replay_buffer = __esm({
   "../agent/src/replay-buffer.ts"() {
     "use strict";
-    ReplayBuffer = class {
-      buffer = [];
-      maxSize;
-      constructor(maxSize = 1e3) {
-        this.maxSize = maxSize;
-      }
-      /** Add an event, evicting the oldest if at capacity. */
-      push(event) {
-        if (this.buffer.length >= this.maxSize) {
-          this.buffer.shift();
-        }
-        this.buffer.push(event);
-      }
-      /** Return all events with seq > lastSeq, in order. */
-      getAfter(lastSeq) {
-        return this.buffer.filter((e) => e.seq > lastSeq);
-      }
-      /** Current number of buffered events. */
-      get size() {
-        return this.buffer.length;
-      }
-      /** Lowest seq still in the buffer, or 0 if empty. */
-      get oldestSeq() {
-        return this.buffer.length > 0 ? this.buffer[0].seq : 0;
-      }
-      /** Highest seq in the buffer, or 0 if empty. */
-      get newestSeq() {
-        return this.buffer.length > 0 ? this.buffer[this.buffer.length - 1].seq : 0;
-      }
-      /** Clear the buffer. */
-      clear() {
-        this.buffer = [];
-      }
-    };
   }
 });
 
 // ../agent/src/sandbox/lockfile-hash.ts
-async function sha256(content) {
-  const data = new TextEncoder().encode(content);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  const hashArray = new Uint8Array(hashBuffer);
-  return Array.from(hashArray).map((b2) => b2.toString(16).padStart(2, "0")).join("");
-}
-async function computeLockfileHash(readFile10) {
-  for (const name of LOCKFILES) {
-    const content = await readFile10(name);
-    if (content) {
-      const hash = await sha256(content);
-      return hash.slice(0, 12);
-    }
-  }
-  return "none";
-}
-var LOCKFILES;
 var init_lockfile_hash = __esm({
   "../agent/src/sandbox/lockfile-hash.ts"() {
     "use strict";
-    LOCKFILES = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb"];
   }
 });
 
@@ -6518,12 +5550,12 @@ function frontmatterDescription(text) {
   const line = m2[1].split("\n").find((l) => l.startsWith("description:"));
   return line ? line.slice("description:".length).trim().slice(0, 300) : "";
 }
-async function readOptional(fs6, path12, report) {
+async function readOptional(fs6, path13, report) {
   try {
-    return await fs6.readFile(path12);
+    return await fs6.readFile(path13);
   } catch (err) {
     if (isEnoent(err)) return null;
-    report.errors.push({ path: path12, message: err instanceof Error ? err.message : String(err) });
+    report.errors.push({ path: path13, message: err instanceof Error ? err.message : String(err) });
     return null;
   }
 }
@@ -6554,17 +5586,17 @@ async function readClaudeAssets({ fs: fs6, home, projectDirs }) {
     report.notes.push(`Memory read from ${memDir} (namespaced as "${key}.*")`);
     const seen = /* @__PURE__ */ new Set();
     for (const entry of entries.filter((e) => e.endsWith(".md")).sort()) {
-      const path12 = `${memDir}/${entry}`;
-      const text = await readOptional(fs6, path12, report);
+      const path13 = `${memDir}/${entry}`;
+      const text = await readOptional(fs6, path13, report);
       if (text === null) continue;
       const base = entry === "MEMORY.md" ? "index" : entry.slice(0, -3).replace(/[^A-Za-z0-9._-]/g, "_");
       const name = `${key}.${base}`;
       if (!NAME_RE3.test(name)) {
-        report.errors.push({ path: path12, message: `cannot derive a valid asset name from "${entry}"` });
+        report.errors.push({ path: path13, message: `cannot derive a valid asset name from "${entry}"` });
         continue;
       }
       if (seen.has(name)) {
-        report.errors.push({ path: path12, message: `name collision on "${name}"` });
+        report.errors.push({ path: path13, message: `name collision on "${name}"` });
         continue;
       }
       seen.add(name);
@@ -6573,7 +5605,7 @@ async function readClaudeAssets({ fs: fs6, home, projectDirs }) {
         name,
         description: entry === "MEMORY.md" ? "Memory index" : frontmatterDescription(text),
         content: text,
-        source: path12
+        source: path13
       });
     }
     return report;
@@ -6592,28 +5624,28 @@ async function readCommands(fs6, home, report) {
   }
   const seen = /* @__PURE__ */ new Set();
   for (const entry of [...entries].sort()) {
-    const path12 = `${dir}/${entry}`;
+    const path13 = `${dir}/${entry}`;
     if (!entry.endsWith(".md")) {
-      if (!entry.startsWith(".")) report.notes.push(`Skipped ${path12}: only top-level .md command files are imported (subdirectories are not supported)`);
+      if (!entry.startsWith(".")) report.notes.push(`Skipped ${path13}: only top-level .md command files are imported (subdirectories are not supported)`);
       continue;
     }
     const name = entry.slice(0, -3);
     if (!COMMAND_NAME_RE.test(name)) {
-      report.errors.push({ path: path12, message: `command name "${name}" must start with a letter and use only letters, digits, - and _` });
+      report.errors.push({ path: path13, message: `command name "${name}" must start with a letter and use only letters, digits, - and _` });
       continue;
     }
     if (seen.has(name.toLowerCase())) {
-      report.errors.push({ path: path12, message: `command name collision on "${name}" (names are case-insensitive)` });
+      report.errors.push({ path: path13, message: `command name collision on "${name}" (names are case-insensitive)` });
       continue;
     }
-    const text = await readOptional(fs6, path12, report);
+    const text = await readOptional(fs6, path13, report);
     if (text === null) continue;
     if (Buffer.byteLength(text, "utf8") > MAX_ASSET_BYTES) {
-      report.errors.push({ path: path12, message: `skipped: ${Buffer.byteLength(text, "utf8")} bytes is over the ${MAX_ASSET_BYTES} byte asset limit` });
+      report.errors.push({ path: path13, message: `skipped: ${Buffer.byteLength(text, "utf8")} bytes is over the ${MAX_ASSET_BYTES} byte asset limit` });
       continue;
     }
     seen.add(name.toLowerCase());
-    report.assets.push({ kind: "command", name, description: parseCommandFile(text).description, content: text, source: path12 });
+    report.assets.push({ kind: "command", name, description: parseCommandFile(text).description, content: text, source: path13 });
   }
 }
 async function listFiles(fs6, dir, rel, out, report) {
@@ -6666,8 +5698,8 @@ async function readSkills(fs6, home, report) {
     const siblings = [];
     const slugs = /* @__PURE__ */ new Set();
     for (const rel of files.filter((f) => f !== "SKILL.md")) {
-      const path12 = `${root}/${dir}/${rel}`;
-      const content = await readOptional(fs6, path12, report);
+      const path13 = `${root}/${dir}/${rel}`;
+      const content = await readOptional(fs6, path13, report);
       if (content === null) continue;
       const size = Buffer.byteLength(content, "utf8");
       const name = siblingAssetName(parsed.name, rel);
@@ -6676,33 +5708,33 @@ async function readSkills(fs6, home, report) {
         continue;
       }
       slugs.add(name);
-      siblings.push({ kind: "skill", name, description: `${SIBLING_PREFIX}${rel}`, content, source: path12 });
+      siblings.push({ kind: "skill", name, description: `${SIBLING_PREFIX}${rel}`, content, source: path13 });
     }
     if (siblings.some((s) => isScriptPath(s.description.slice(SIBLING_PREFIX.length)))) report.notes.push(`Skill ${parsed.name}: ships scripts, not runnable until permitted (they run through bash and its permission rules)`);
     report.assets.push({ kind: "skill", name: parsed.name, description: parsed.description, content: text, source: skillPath }, ...siblings);
   }
 }
 async function readMcpServers(fs6, home, projectDirs, report) {
-  const path12 = `${home}/.claude.json`;
-  const text = await readOptional(fs6, path12, report);
+  const path13 = `${home}/.claude.json`;
+  const text = await readOptional(fs6, path13, report);
   if (text === null) return;
   const { servers, errors } = normalizeClaudeJsonMcp(text, projectDirs);
-  for (const e of errors) report.errors.push({ path: path12, message: e });
+  for (const e of errors) report.errors.push({ path: path13, message: e });
   const seen = /* @__PURE__ */ new Set();
   for (const s of servers) {
     if (!NAME_RE3.test(s.name)) {
-      report.errors.push({ path: path12, message: `MCP server name "${s.name}" must use only letters, digits, . _ - (max 100)` });
+      report.errors.push({ path: path13, message: `MCP server name "${s.name}" must use only letters, digits, . _ - (max 100)` });
       continue;
     }
     if (seen.has(s.name.toLowerCase())) {
-      report.errors.push({ path: path12, message: `MCP server name collision on "${s.name}" (names are case-insensitive)` });
+      report.errors.push({ path: path13, message: `MCP server name collision on "${s.name}" (names are case-insensitive)` });
       continue;
     }
     seen.add(s.name.toLowerCase());
     const { literalKeys, ...def } = s;
     const content = JSON.stringify(def, null, 2);
     if (Buffer.byteLength(content, "utf8") > MAX_ASSET_BYTES) {
-      report.errors.push({ path: path12, message: `MCP server "${s.name}" skipped: over the ${MAX_ASSET_BYTES} byte asset limit` });
+      report.errors.push({ path: path13, message: `MCP server "${s.name}" skipped: over the ${MAX_ASSET_BYTES} byte asset limit` });
       continue;
     }
     if (literalKeys.length > 0) {
@@ -6716,7 +5748,7 @@ async function readMcpServers(fs6, home, projectDirs, report) {
       name: s.name,
       description: s.transport === "stdio" ? `stdio: ${s.command}` : `http: ${s.url}`,
       content,
-      source: `${path12} (${s.scope})`
+      source: `${path13} (${s.scope})`
     });
   }
 }
@@ -6739,10 +5771,10 @@ var init_claude_sources = __esm({
 // ../agent/src/import/profile-client.ts
 function createProfileClient({ baseUrl, apiKey, fetch: doFetch, timeoutMs = 8e3 }) {
   const root = baseUrl.replace(/\/+$/, "");
-  async function call(method, path12, init = {}) {
+  async function call(method, path13, init = {}) {
     let res;
     try {
-      res = await doFetch(`${root}/api/profile${path12}`, {
+      res = await doFetch(`${root}/api/profile${path13}`, {
         method,
         headers: { Authorization: `Bearer ${apiKey}`, ...init.body !== void 0 ? { "content-type": "application/json" } : {}, ...init.headers },
         ...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
@@ -6759,7 +5791,7 @@ function createProfileClient({ baseUrl, apiKey, fetch: doFetch, timeoutMs = 8e3
       body = void 0;
     }
     const detail = typeof body === "object" && body !== null && "error" in body ? String(body.error) : res.statusText;
-    throw new ProfileApiError(res.status, `profile ${method} ${path12} -> ${res.status} ${detail}`, body);
+    throw new ProfileApiError(res.status, `profile ${method} ${path13} -> ${res.status} ${detail}`, body);
   }
   const enc = encodeURIComponent;
   return {
@@ -6874,7 +5906,7 @@ function createMemoryReadTool(client, projectKey2) {
     }
   };
 }
-var MEMORY_READ_TOOL, MEMORY_TOOL_DEFINITIONS, SAFE;
+var MEMORY_READ_TOOL, SAFE;
 var init_memory_tool = __esm({
   "../agent/src/import/memory-tool.ts"() {
     "use strict";
@@ -6887,7 +5919,6 @@ var init_memory_tool = __esm({
         required: ["name"]
       }
     };
-    MEMORY_TOOL_DEFINITIONS = [MEMORY_READ_TOOL];
     SAFE = /^[A-Za-z0-9._-]{1,100}$/;
   }
 });
@@ -6969,9 +6000,6 @@ function splitSections(text) {
   const preamble = starts[0] === 0 ? "" : lines2.slice(0, starts[0]).join("\n") + "\n";
   return { preamble, sections: sections2 };
 }
-function joinSections(split) {
-  return split.preamble + split.sections.map((s) => s.text).join("");
-}
 var init_instruction_sections = __esm({
   "../agent/src/import/instruction-sections.ts"() {
     "use strict";
@@ -7140,7 +6168,7 @@ function createInstructionsReadTool(client) {
     }
   };
 }
-var INSTRUCTIONS_READ_TOOL, INSTRUCTIONS_TOOL_DEFINITIONS, SAFE2;
+var INSTRUCTIONS_READ_TOOL, SAFE2;
 var init_instructions_tool = __esm({
   "../agent/src/import/instructions-tool.ts"() {
     "use strict";
@@ -7154,7 +6182,6 @@ var init_instructions_tool = __esm({
         required: ["name"]
       }
     };
-    INSTRUCTIONS_TOOL_DEFINITIONS = [INSTRUCTIONS_READ_TOOL];
     SAFE2 = /^[a-z0-9-]{1,40}$/;
   }
 });
@@ -7255,7 +6282,7 @@ var init_trust = __esm({
 // ../agent/src/import/source-changes.ts
 function fingerprintSources(files, hash) {
   const fingerprint = {};
-  for (const [path12, content] of Object.entries(files)) fingerprint[path12] = hash(content);
+  for (const [path13, content] of Object.entries(files)) fingerprint[path13] = hash(content);
   return fingerprint;
 }
 function diffSources(before, after) {
@@ -7274,6 +6301,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,23 +6380,23 @@ function allOffConfig() {
     models: {}
   };
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parseImportsConfig(text, path12) {
+function parseImportsConfig(text, path13) {
   if (text === null) return { config: allOffConfig() };
-  const fail = (reason) => ({ config: allOffConfig(), error: `${path12}: ${reason}` });
+  const fail = (reason) => ({ config: allOffConfig(), error: `${path13}: ${reason}` });
   let parsed;
   try {
     parsed = JSON.parse(text);
   } 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 +6404,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;
@@ -7323,9 +6414,6 @@ function parseImportsConfig(text, path12) {
   }
   return { config };
 }
-function serializeImportsConfig(config) {
-  return JSON.stringify({ version: 1, categories: config.categories, models: config.models }, null, 2);
-}
 var IMPORT_CATEGORIES, MODEL_KEYS;
 var init_imports_config = __esm({
   "../agent/src/import/imports-config.ts"() {
@@ -7918,135 +7006,6 @@ var init_mcp_client = __esm({
 });
 
 // ../agent/src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AdaptPlanError: () => AdaptPlanError,
-  BASH_TOOL_DEFINITION: () => BASH_TOOL_DEFINITION,
-  BUILD_FEATURE_TOOL: () => BUILD_FEATURE_TOOL,
-  CALL_TIMEOUT_MS: () => CALL_TIMEOUT_MS,
-  CODEGEN_TOOL_DEFINITIONS: () => CODEGEN_TOOL_DEFINITIONS,
-  CONNECT_TIMEOUT_MS: () => CONNECT_TIMEOUT_MS,
-  CREATE_PR_TOOL: () => CREATE_PR_TOOL,
-  CloudHost: () => CloudHost,
-  DEFAULT_MAX_CONTEXT_TOKENS: () => DEFAULT_MAX_CONTEXT_TOKENS,
-  DEFAULT_PROFILE_BUDGET_CHARS: () => DEFAULT_PROFILE_BUDGET_CHARS,
-  EDIT_FILE_TOOL: () => EDIT_FILE_TOOL,
-  FILE_TOOL_DEFINITIONS: () => FILE_TOOL_DEFINITIONS,
-  FileAuditLog: () => FileAuditLog,
-  FileStore: () => FileStore,
-  GITHUB_TOOL_DEFINITIONS: () => GITHUB_TOOL_DEFINITIONS,
-  IMPORT_CATEGORIES: () => IMPORT_CATEGORIES,
-  INSTRUCTIONS_READ_TOOL: () => INSTRUCTIONS_READ_TOOL,
-  INSTRUCTIONS_TOOL_DEFINITIONS: () => INSTRUCTIONS_TOOL_DEFINITIONS,
-  LIST_DIRECTORY_TOOL: () => LIST_DIRECTORY_TOOL,
-  LocalHost: () => LocalHost,
-  MAX_ASSET_BYTES: () => MAX_ASSET_BYTES,
-  MAX_CORE_CHARS: () => MAX_CORE_CHARS,
-  MCP_PROTOCOL_VERSION: () => MCP_PROTOCOL_VERSION,
-  MEMORY_READ_TOOL: () => MEMORY_READ_TOOL,
-  MEMORY_TOOL_DEFINITIONS: () => MEMORY_TOOL_DEFINITIONS,
-  McpProtocolError: () => McpProtocolError,
-  MemoryAuditLog: () => MemoryAuditLog,
-  PERMISSION_MODES: () => PERMISSION_MODES,
-  PREVIEW_TOOL: () => PREVIEW_TOOL,
-  PREVIEW_TOOL_DEFINITIONS: () => PREVIEW_TOOL_DEFINITIONS,
-  PendingRequests: () => PendingRequests,
-  PermissionState: () => PermissionState,
-  PolicyViolation: () => PolicyViolation,
-  ProfileApiError: () => ProfileApiError,
-  READ_FILE_TOOL: () => READ_FILE_TOOL,
-  RESULT_CAP_CHARS: () => RESULT_CAP_CHARS,
-  ReplayBuffer: () => ReplayBuffer,
-  RepoIndexer: () => RepoIndexer,
-  RpcAbortError: () => RpcAbortError,
-  RpcClosedError: () => RpcClosedError,
-  RpcError: () => RpcError,
-  RpcTimeoutError: () => RpcTimeoutError,
-  SEARCH_TOOL: () => SEARCH_TOOL,
-  SENTRY_GET_ISSUE_TOOL: () => SENTRY_GET_ISSUE_TOOL,
-  SENTRY_LIST_ISSUES_TOOL: () => SENTRY_LIST_ISSUES_TOOL,
-  SENTRY_TOOL_DEFINITIONS: () => SENTRY_TOOL_DEFINITIONS,
-  SIBLING_PREFIX: () => SIBLING_PREFIX,
-  SKILLS_BUDGET_CHARS: () => SKILLS_BUDGET_CHARS,
-  SKILL_TOOL: () => SKILL_TOOL,
-  SnapshotManager: () => SnapshotManager,
-  TODO_TOOL: () => TODO_TOOL,
-  TODO_TOOL_DEFINITIONS: () => TODO_TOOL_DEFINITIONS,
-  TOOL_NAME_MAP: () => TOOL_NAME_MAP,
-  TrustError: () => TrustError,
-  TrustStore: () => TrustStore,
-  WRITE_FILE_TOOL: () => WRITE_FILE_TOOL,
-  allOffConfig: () => allOffConfig,
-  applyPlan: () => applyPlan,
-  buildCommandRegistry: () => buildCommandRegistry,
-  buildProfileSection: () => buildProfileSection,
-  buildRuleSet: () => buildRuleSet,
-  buildSkillsSection: () => buildSkillsSection,
-  buildSystemPrompt: () => buildSystemPrompt,
-  buildTranscriptForSummarization: () => buildTranscriptForSummarization,
-  checkCoverage: () => checkCoverage,
-  classifyCommand: () => classifyCommand,
-  classifyRpcMessage: () => classifyRpcMessage,
-  claudeProjectSlug: () => claudeProjectSlug,
-  computeLockfileHash: () => computeLockfileHash,
-  createBashTool: () => createBashTool,
-  createCodegenTools: () => createCodegenTools,
-  createFileTools: () => createFileTools,
-  createGitHubTools: () => createGitHubTools,
-  createHostSearchTool: () => createHostSearchTool,
-  createHostToolExecutor: () => createHostToolExecutor,
-  createInstructionsReadTool: () => createInstructionsReadTool,
-  createMcpClient: () => createMcpClient,
-  createMemoryReadTool: () => createMemoryReadTool,
-  createPreviewTool: () => createPreviewTool,
-  createProfileClient: () => createProfileClient,
-  createProfileSkillSource: () => createProfileSkillSource,
-  createRpcSession: () => createRpcSession,
-  createSearchTool: () => createSearchTool,
-  createSentryTools: () => createSentryTools,
-  createSimpleRouter: () => createSimpleRouter,
-  createSkillTool: () => createSkillTool,
-  createTodoTool: () => createTodoTool,
-  defaultModeFor: () => defaultModeFor,
-  diffSources: () => diffSources,
-  estimateTokens: () => estimateTokens,
-  estimateTotalTokens: () => estimateTotalTokens,
-  expandCommand: () => expandCommand,
-  expandRefs: () => expandRefs,
-  expandServerEnv: () => expandServerEnv,
-  extractRuleLines: () => extractRuleLines,
-  findUnsupported: () => findUnsupported,
-  fingerprintSources: () => fingerprintSources,
-  flattenMessageText: () => flattenMessageText,
-  formatSkillBody: () => formatSkillBody,
-  formatSourceChanges: () => formatSourceChanges,
-  formatToolResult: () => formatToolResult,
-  guardHost: () => guardHost,
-  isReadOnlyCommand: () => isReadOnlyCommand,
-  joinSections: () => joinSections,
-  listMcpSpawns: () => listMcpSpawns,
-  loadProfile: () => loadProfile,
-  normalizeClaudeJsonMcp: () => normalizeClaudeJsonMcp,
-  parseCommandFile: () => parseCommandFile,
-  parseGitStatus: () => parseGitStatus,
-  parseImportsConfig: () => parseImportsConfig,
-  parseSkillFile: () => parseSkillFile,
-  parseTodos: () => parseTodos,
-  prepareAdaptation: () => prepareAdaptation,
-  projectKey: () => projectKey,
-  readClaudeAssets: () => readClaudeAssets,
-  renderProjectCard: () => renderProjectCard,
-  runAgentLoop: () => runAgentLoop,
-  safeSkillPath: () => safeSkillPath,
-  serializeImportsConfig: () => serializeImportsConfig,
-  siblingAssetName: () => siblingAssetName,
-  splitCommand: () => splitCommand,
-  splitSections: () => splitSections,
-  summarizeConversation: () => summarizeConversation,
-  syncAfterBash: () => syncAfterBash,
-  syncBeforeBash: () => syncBeforeBash,
-  translateToolNames: () => translateToolNames
-});
 var init_src = __esm({
   "../agent/src/index.ts"() {
     init_loop();
@@ -8086,6 +7045,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();
@@ -8108,14 +7068,9 @@ var init_src = __esm({
 });
 
 // src/api-key.ts
-var api_key_exports = {};
-__export(api_key_exports, {
-  MISSING_KEY_MESSAGE: () => MISSING_KEY_MESSAGE,
-  resolveApiKey: () => resolveApiKey
-});
 import { join } from "node:path";
 async function resolveApiKey(deps) {
-  const { env: env3, readFile: readFile10, homedir: homedir3 } = deps;
+  const { env: env3, readFile: readFile12, homedir: homedir3 } = deps;
   for (const name of ["SPACECODE_API_KEY", "ANTHROPIC_API_KEY"]) {
     const value = env3[name]?.trim();
     if (value) return value;
@@ -8124,7 +7079,7 @@ async function resolveApiKey(deps) {
   const file = join(dir, "auth.json");
   let raw;
   try {
-    raw = await readFile10(file);
+    raw = await readFile12(file);
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw new Error(`Cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
@@ -8157,26 +7112,26 @@ __export(import_gate_exports, {
   importGateStatus: () => importGateStatus,
   nodeTrustFs: () => nodeTrustFs,
   readRepoSources: () => readRepoSources,
-  sha256: () => sha2562,
+  sha256: () => sha256,
   writeTextAtomic: () => writeTextAtomic
 });
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, readFile, readdir, realpath, rename, writeFile } from "node:fs/promises";
 import { dirname as dirname3, join as join2 } from "node:path";
-async function readOrNull(path12) {
+async function readOrNull(path13) {
   try {
-    return await readFile(path12, "utf8");
+    return await readFile(path13, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
   }
 }
-async function writeTextAtomic(path12, text) {
-  await mkdir(dirname3(path12), { recursive: true });
-  const tmp = `${path12}.${process.pid}.${randomUUID()}.tmp`;
+async function writeTextAtomic(path13, text) {
+  await mkdir(dirname3(path13), { recursive: true });
+  const tmp = `${path13}.${process.pid}.${randomUUID()}.tmp`;
   await writeFile(tmp, text, { mode: 384 });
   await chmod(tmp, 384);
-  await rename(tmp, path12);
+  await rename(tmp, path13);
 }
 async function readRepoSources(cwd2) {
   const files = {};
@@ -8230,7 +7185,7 @@ function nodeTrustFs() {
 function createNodeTrustStore(configDir) {
   let store = trustStores.get(configDir);
   if (!store) {
-    store = new TrustStore({ fs: nodeTrustFs(), path: join2(configDir, "trust.json"), hash: sha2562 });
+    store = new TrustStore({ fs: nodeTrustFs(), path: join2(configDir, "trust.json"), hash: sha256 });
     trustStores.set(configDir, store);
   }
   return store;
@@ -8262,7 +7217,7 @@ async function importGateStatus(deps) {
   }
   return lines2;
 }
-var REPO_SOURCE_FILES, MAX_REPO_SKILL_FILES, MAX_REPO_SKILL_BYTES, sha2562, trustStores;
+var REPO_SOURCE_FILES, MAX_REPO_SKILL_FILES, MAX_REPO_SKILL_BYTES, sha256, trustStores;
 var init_import_gate = __esm({
   "src/import-gate.ts"() {
     "use strict";
@@ -8270,7 +7225,7 @@ var init_import_gate = __esm({
     REPO_SOURCE_FILES = [".mcp.json", ".claude/settings.json", ".claude/settings.local.json", "CLAUDE.local.md"];
     MAX_REPO_SKILL_FILES = 200;
     MAX_REPO_SKILL_BYTES = 256 * 1024;
-    sha2562 = (text) => createHash("sha256").update(text).digest("hex");
+    sha256 = (text) => createHash("sha256").update(text).digest("hex");
     trustStores = /* @__PURE__ */ new Map();
   }
 });
@@ -8456,12 +7411,6 @@ var init_mcp_loader = __esm({
 });
 
 // src/profile-runtime.ts
-var profile_runtime_exports = {};
-__export(profile_runtime_exports, {
-  DEFAULT_BACKEND_URL: () => DEFAULT_BACKEND_URL,
-  backendUrl: () => backendUrl,
-  prepareProfile: () => prepareProfile
-});
 import { join as join5 } from "node:path";
 function backendUrl(env3) {
   return env3.SPACECODE_BACKEND_URL?.trim() || env3.SPACECODE_API_URL?.trim() || DEFAULT_BACKEND_URL;
@@ -8904,6 +7853,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 +7869,95 @@ var init_mcp_manager = __esm({
       beginTurn(signal) {
         this.turnSignal = signal;
       }
-      /** Starts every eligible server in the background. Resolves when all have connected or failed; callers need not await it. */
+      /**
+       * 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 servers in the background. A server whose tools came from the cache is NOT started here: it starts on its first call
+       * (`begin`), so an unused server never spawns. Every other server starts now, because its tools (or why it is skipped) are unknown.
+       * Resolves when those 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.filter((def) => !this.cachedTools.has(def.name)).map((def) => this.begin(def))).then(() => void 0);
         return this.startPromise;
       }
+      /** Starts one server once; later callers share the same attempt. */
+      begin(def) {
+        let p = this.connected.get(def.name);
+        if (!p) {
+          p = this.startOne(def);
+          this.connected.set(def.name, p);
+        }
+        return p;
+      }
+      /** 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 +8008,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 +8021,30 @@ 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 starts its server if it is not running yet, waits for it to connect (bounded by the connect timeout) and then goes through the normal checks. */
+      async callWhenReady(server, tool, input) {
+        const def = this.deps.defs.find((d) => d.name === server);
+        if (def) await this.begin(def);
+        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 +8086,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} not started, ${cached3.length} tools from cache (starts on first use)`);
+            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. */
@@ -9066,13 +8114,9 @@ var init_mcp_manager = __esm({
 });
 
 // src/mcp/approve-mcp.ts
-var approve_mcp_exports = {};
-__export(approve_mcp_exports, {
-  runApproveMcp: () => runApproveMcp
-});
 async function runApproveMcp(deps) {
   const { defs, statusLines } = await loadMcpDefs(deps);
-  for (const l of statusLines) deps.log(l);
+  if (!deps.quiet) for (const l of statusLines) deps.log(l);
   const stdio = defs.filter((d) => d.transport === "stdio");
   const todo = [];
   for (const d of stdio) {
@@ -9080,13 +8124,15 @@ async function runApproveMcp(deps) {
     if (await deps.trust.stdioStatus(key) === "unapproved") todo.push(d);
   }
   if (todo.length === 0) {
-    deps.log(stdio.length === 0 ? "No stdio MCP servers to approve." : "Every stdio MCP server is already approved on this machine.");
+    if (!deps.quiet) deps.log(stdio.length === 0 ? "No stdio MCP servers to approve." : "Every stdio MCP server is already approved on this machine.");
     return 0;
   }
   if (!deps.ask) {
     deps.log(`${todo.length} MCP server(s) need approval, but this is not an interactive terminal: nothing was approved.`);
     return 1;
   }
+  if (deps.quiet) deps.log(`
+${todo.length} imported MCP server(s) want to run a command on this machine. Nothing spawns until you approve it (you can also run \`spacecode approve-mcp\` later).`);
   let approved = 0;
   for (const d of todo) {
     deps.log(`
@@ -9114,19 +8160,65 @@ var init_approve_mcp = __esm({
   }
 });
 
+// src/mcp/approve-mcp-node.ts
+var approve_mcp_node_exports = {};
+__export(approve_mcp_node_exports, {
+  runApproveMcpOnNode: () => runApproveMcpOnNode
+});
+import os from "node:os";
+import path3 from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+async function runApproveMcpOnNode(opts) {
+  const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || path3.join(os.homedir(), ".spacecode");
+  const apiKey = await resolveApiKey({ env: process.env, readFile: (p) => readFile2(p, "utf-8"), homedir: os.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;
+  try {
+    return await runApproveMcp({
+      configDir,
+      cwd: process.cwd(),
+      readFile: (p) => readFile2(p, "utf-8"),
+      client: apiKey ? createProfileClient({ baseUrl: backendUrl(process.env), apiKey, fetch }) : null,
+      trust: createNodeTrustStore(configDir),
+      ...rl ? { ask: async (q2) => {
+        try {
+          return await rl.question(q2);
+        } catch {
+          return null;
+        }
+      } } : {},
+      log: (line) => console.log(line),
+      quiet: opts.quiet
+    });
+  } finally {
+    rl?.close();
+  }
+}
+var init_approve_mcp_node = __esm({
+  "src/mcp/approve-mcp-node.ts"() {
+    "use strict";
+    init_src();
+    init_approve_mcp();
+    init_import_gate();
+    init_api_key();
+    init_profile_runtime();
+  }
+});
+
 // src/repo-trust-prompt.ts
 var repo_trust_prompt_exports = {};
 __export(repo_trust_prompt_exports, {
   describeRepoSources: () => describeRepoSources,
   promptRepoTrust: () => promptRepoTrust
 });
-function ruleLists(path12, text, lines2, warnings) {
+function ruleLists(path13, text, lines2, warnings) {
   let data;
   try {
     data = JSON.parse(text);
   } catch (err) {
     if (!(err instanceof SyntaxError)) throw err;
-    warnings.push(`${path12}: not valid JSON, nothing from it loads`);
+    warnings.push(`${path13}: not valid JSON, nothing from it loads`);
     return;
   }
   const perms = typeof data === "object" && data !== null ? data.permissions : void 0;
@@ -9134,7 +8226,7 @@ function ruleLists(path12, text, lines2, warnings) {
   for (const effect of ["allow", "deny", "ask"]) {
     const list2 = perms[effect];
     if (!Array.isArray(list2)) continue;
-    for (const rule of list2) if (typeof rule === "string") lines2.push(`  ${effect}: ${show2(rule)}  (${path12})`);
+    for (const rule of list2) if (typeof rule === "string") lines2.push(`  ${effect}: ${show2(rule)}  (${path13})`);
   }
 }
 function describeRepoSources(files) {
@@ -9380,7 +8472,7 @@ __export(base_exports, {
   synchronizedOutput: () => synchronizedOutput
 });
 import process2 from "node:process";
-import os from "node:os";
+import os2 from "node:os";
 var ESC, OSC, BEL, SEP, isTerminalApp, isWindows2, isTmux, cwdFunction, wrapOsc, cursorTo, cursorMove, cursorUp, cursorDown, cursorForward, cursorBackward, cursorLeft, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide, cursorShow, eraseLines, eraseEndLine, eraseStartLine, eraseLine, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearViewport, isOldWindows, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beginSynchronizedOutput, endSynchronizedOutput, synchronizedOutput, beep, link, image, iTerm, ConEmu, setCwd;
 var init_base = __esm({
   "../../node_modules/ansi-escapes/base.js"() {
@@ -9463,7 +8555,7 @@ var init_base = __esm({
       if (isBrowser || !isWindows2) {
         return false;
       }
-      const parts = os.release().split(".");
+      const parts = os2.release().split(".");
       const major = Number(parts[0]);
       const build2 = Number(parts[2] ?? 0);
       if (major < 10) {
@@ -31743,10 +30835,10 @@ var require_react_reconciler_development = __commonJS({
         var setErrorHandler = null;
         var setSuspenseHandler = null;
         {
-          var copyWithDeleteImpl = function(obj, path12, index2) {
-            var key = path12[index2];
+          var copyWithDeleteImpl = function(obj, path13, index2) {
+            var key = path13[index2];
             var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-            if (index2 + 1 === path12.length) {
+            if (index2 + 1 === path13.length) {
               if (isArray(updated)) {
                 updated.splice(key, 1);
               } else {
@@ -31754,11 +30846,11 @@ var require_react_reconciler_development = __commonJS({
               }
               return updated;
             }
-            updated[key] = copyWithDeleteImpl(obj[key], path12, index2 + 1);
+            updated[key] = copyWithDeleteImpl(obj[key], path13, index2 + 1);
             return updated;
           };
-          var copyWithDelete = function(obj, path12) {
-            return copyWithDeleteImpl(obj, path12, 0);
+          var copyWithDelete = function(obj, path13) {
+            return copyWithDeleteImpl(obj, path13, 0);
           };
           var copyWithRenameImpl = function(obj, oldPath, newPath, index2) {
             var oldKey = oldPath[index2];
@@ -31796,17 +30888,17 @@ var require_react_reconciler_development = __commonJS({
             }
             return copyWithRenameImpl(obj, oldPath, newPath, 0);
           };
-          var copyWithSetImpl = function(obj, path12, index2, value) {
-            if (index2 >= path12.length) {
+          var copyWithSetImpl = function(obj, path13, index2, value) {
+            if (index2 >= path13.length) {
               return value;
             }
-            var key = path12[index2];
+            var key = path13[index2];
             var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-            updated[key] = copyWithSetImpl(obj[key], path12, index2 + 1, value);
+            updated[key] = copyWithSetImpl(obj[key], path13, index2 + 1, value);
             return updated;
           };
-          var copyWithSet = function(obj, path12, value) {
-            return copyWithSetImpl(obj, path12, 0, value);
+          var copyWithSet = function(obj, path13, value) {
+            return copyWithSetImpl(obj, path13, 0, value);
           };
           var findHook = function(fiber, id) {
             var currentHook2 = fiber.memoizedState;
@@ -31816,10 +30908,10 @@ var require_react_reconciler_development = __commonJS({
             }
             return currentHook2;
           };
-          overrideHookState = function(fiber, id, path12, value) {
+          overrideHookState = function(fiber, id, path13, value) {
             var hook = findHook(fiber, id);
             if (hook !== null) {
-              var newState = copyWithSet(hook.memoizedState, path12, value);
+              var newState = copyWithSet(hook.memoizedState, path13, value);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign({}, fiber.memoizedProps);
@@ -31829,10 +30921,10 @@ var require_react_reconciler_development = __commonJS({
               }
             }
           };
-          overrideHookStateDeletePath = function(fiber, id, path12) {
+          overrideHookStateDeletePath = function(fiber, id, path13) {
             var hook = findHook(fiber, id);
             if (hook !== null) {
-              var newState = copyWithDelete(hook.memoizedState, path12);
+              var newState = copyWithDelete(hook.memoizedState, path13);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign({}, fiber.memoizedProps);
@@ -31855,8 +30947,8 @@ var require_react_reconciler_development = __commonJS({
               }
             }
           };
-          overrideProps = function(fiber, path12, value) {
-            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path12, value);
+          overrideProps = function(fiber, path13, value) {
+            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path13, value);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -31865,8 +30957,8 @@ var require_react_reconciler_development = __commonJS({
               scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
             }
           };
-          overridePropsDeletePath = function(fiber, path12) {
-            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path12);
+          overridePropsDeletePath = function(fiber, path13) {
+            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path13);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -37722,7 +36814,7 @@ var init_ansi_styles2 = __esm({
 
 // ../../node_modules/chalk/source/vendor/supports-color/index.js
 import process4 from "node:process";
-import os2 from "node:os";
+import os3 from "node:os";
 import tty from "node:tty";
 function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process4.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
@@ -37780,7 +36872,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process4.platform === "win32") {
-    const osRelease = os2.release().split(".");
+    const osRelease = os3.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -39571,8 +38663,8 @@ var init_ErrorOverview = __esm({
     init_dist3();
     init_Box();
     init_Text();
-    cleanupPath = (path12) => {
-      return path12?.replace(`file://${cwd()}/`, "");
+    cleanupPath = (path13) => {
+      return path13?.replace(`file://${cwd()}/`, "");
     };
     stackUtils = new import_stack_utils.default({
       cwd: cwd(),
@@ -42811,7 +41903,7 @@ var require_has_flag = __commonJS({
 var require_supports_colors = __commonJS({
   "../../node_modules/@colors/colors/lib/system/supports-colors.js"(exports, module) {
     "use strict";
-    var os6 = __require("os");
+    var os7 = __require("os");
     var hasFlag2 = require_has_flag();
     var env3 = process.env;
     var forceColor = void 0;
@@ -42849,7 +41941,7 @@ var require_supports_colors = __commonJS({
       }
       var min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        var osRelease = os6.release().split(".");
+        var osRelease = os7.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -44353,7 +43445,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 +43749,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 */
@@ -86934,15 +86026,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path12 = [graph[toModel].parent, toModel];
+      const path13 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path12.unshift(graph[cur].parent);
+        path13.unshift(graph[cur].parent);
         fn = link2(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path12;
+      fn.conversion = path13;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -87182,7 +86274,7 @@ var require_has_flag2 = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os6 = __require("os");
+    var os7 = __require("os");
     var tty2 = __require("tty");
     var hasFlag2 = require_has_flag2();
     var { env: env3 } = process;
@@ -87230,7 +86322,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os6.release().split(".");
+        const osRelease = os7.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -102163,9 +101255,9 @@ var init_credential_filter = __esm({
 });
 
 // src/session/session-store.ts
-import { chmod as chmod2, mkdir as mkdir2, open, readdir as readdir2, readFile as readFile2, rename as rename2, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, open, readdir as readdir2, readFile as readFile3, rename as rename2, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
-import path3 from "node:path";
+import path4 from "node:path";
 function redactCredentials(value) {
   if (typeof value === "string") return containsCredential(value) ? REDACTED : value;
   if (Array.isArray(value)) return value.map(redactCredentials);
@@ -102240,7 +101332,7 @@ var init_session_store = __esm({
       }
       fileFor(id) {
         if (!ID.test(id)) throw new SessionError(this.dir, `Invalid session id ${JSON.stringify(id)}`);
-        return path3.join(this.dir, `${id}.jsonl`);
+        return path4.join(this.dir, `${id}.jsonl`);
       }
       async save(session2) {
         const file = this.fileFor(session2.meta.id);
@@ -102269,7 +101361,7 @@ var init_session_store = __esm({
           if (size > MAX_SESSION_BYTES) {
             throw new SessionError(file, `Session is ${size} bytes, over the ${MAX_SESSION_BYTES}-byte cap; not loaded`);
           }
-          text = await readFile2(file, "utf8");
+          text = await readFile3(file, "utf8");
         } catch (err) {
           if (err instanceof SessionError) throw err;
           throw new SessionError(file, `Could not read session: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
@@ -102293,7 +101385,7 @@ var init_session_store = __esm({
           try {
             sessions.push((await this.load(name.slice(0, -".jsonl".length))).meta);
           } catch (err) {
-            errors.push(err instanceof SessionError ? err : new SessionError(path3.join(this.dir, name), String(err), { cause: err }));
+            errors.push(err instanceof SessionError ? err : new SessionError(path4.join(this.dir, name), String(err), { cause: err }));
           }
         }
         sessions.sort((a, b2) => b2.updatedAt.localeCompare(a.updatedAt));
@@ -103367,17 +102459,17 @@ function isSubsequence(needle, hay) {
   for (let j2 = 0; j2 < hay.length && i < needle.length; j2++) if (hay[j2] === needle[i]) i++;
   return i === needle.length;
 }
-function tier(path12, q2) {
-  const base = path12.slice(path12.lastIndexOf("/") + 1);
+function tier(path13, q2) {
+  const base = path13.slice(path13.lastIndexOf("/") + 1);
   if (base.startsWith(q2)) return 0;
   if (base.includes(q2)) return 1;
-  if (path12.includes(q2)) return 2;
+  if (path13.includes(q2)) return 2;
   return 3;
 }
 function rankPaths(paths, query, limit = 8) {
   if (query === "") return paths.slice(0, limit);
   const q2 = query.toLowerCase();
-  return paths.map((path12) => ({ path: path12, lower: path12.toLowerCase() })).filter(({ lower }) => isSubsequence(q2, lower)).map(({ path: path12, lower }) => ({ path: path12, rank: tier(lower, q2) })).sort((a, b2) => a.rank - b2.rank || a.path.length - b2.path.length || (a.path < b2.path ? -1 : a.path > b2.path ? 1 : 0)).slice(0, limit).map((m2) => m2.path);
+  return paths.map((path13) => ({ path: path13, lower: path13.toLowerCase() })).filter(({ lower }) => isSubsequence(q2, lower)).map(({ path: path13, lower }) => ({ path: path13, rank: tier(lower, q2) })).sort((a, b2) => a.rank - b2.rank || a.path.length - b2.path.length || (a.path < b2.path ? -1 : a.path > b2.path ? 1 : 0)).slice(0, limit).map((m2) => m2.path);
 }
 var init_mention_rank = __esm({
   "src/editor/mention-rank.ts"() {
@@ -103394,9 +102486,9 @@ function activeMention(text, cursor) {
   const explicit = token[1] === "!";
   return { start, query: token.slice(explicit ? 2 : 1), explicit };
 }
-function insertMention(text, cursor, mention, path12) {
-  if (/\s/.test(path12)) return { text, cursor };
-  const inserted = `@${mention.explicit ? "!" : ""}${path12}`;
+function insertMention(text, cursor, mention, path13) {
+  if (/\s/.test(path13)) return { text, cursor };
+  const inserted = `@${mention.explicit ? "!" : ""}${path13}`;
   const head = text.slice(0, mention.start) + inserted;
   const next = text[cursor];
   if (next !== void 0 && /\s/.test(next)) return { text: head + text.slice(cursor), cursor: head.length + 1 };
@@ -103766,20 +102858,20 @@ var init_history_store = __esm({
 });
 
 // src/editor/history-file-io.ts
-import { chmod as chmod3, mkdir as mkdir3, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
-import path4 from "node:path";
+import { chmod as chmod3, mkdir as mkdir3, readFile as readFile4, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
+import path5 from "node:path";
 function createFileHistoryIO(file) {
   return {
     async read() {
       try {
-        return await readFile3(file, "utf8");
+        return await readFile4(file, "utf8");
       } catch (err) {
         if (err.code === "ENOENT") return null;
         throw err;
       }
     },
     async write(content) {
-      await mkdir3(path4.dirname(file), { recursive: true, mode: 448 });
+      await mkdir3(path5.dirname(file), { recursive: true, mode: 448 });
       const tmp = `${file}.${process.pid}.tmp`;
       await writeFile3(tmp, content, { mode: 384 });
       await chmod3(tmp, 384);
@@ -103941,10 +103033,10 @@ var init_session_commands = __esm({
 });
 
 // src/local-toolset.ts
-import * as os3 from "node:os";
-import * as path5 from "node:path";
+import * as os4 from "node:os";
+import * as path6 from "node:path";
 function createLocalToolset(opts) {
-  const auditFile = opts.auditFile ?? path5.join(os3.homedir(), ".spacecode", "audit.jsonl");
+  const auditFile = opts.auditFile ?? path6.join(os4.homedir(), ".spacecode", "audit.jsonl");
   const host = guardHost(new LocalHost(opts.cwd), {
     audit: new FileAuditLog(auditFile),
     mode: opts.yolo ? "yolo" : "enforce",
@@ -103974,7 +103066,7 @@ var init_local_toolset = __esm({
 
 // src/project-card-scan.ts
 import { execFile as execFile3 } from "node:child_process";
-import { readdir as readdir3, readFile as readFile4 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 function digestLines(md) {
   return md.split("\n").map((l) => l.trim()).filter((l) => l && !/^#\s/.test(l) && !/^[|\s:-]+$/.test(l) && !/^\|\s*(area|task|priority|date|issue|id)\b/i.test(l)).slice(0, 12);
@@ -104075,13 +103167,13 @@ var init_project_card_scan = __esm({
     MAX_BACKLOG = 6;
     DIGEST_FILES = ["CLAUDE.md", "TODO.md", "BUGS.md", "ISSUES.md", "CHANGELOG.md", "README.md"];
     nodeScanIo = {
-      async readdir(path12) {
-        const entries = await readdir3(path12, { withFileTypes: true });
+      async readdir(path13) {
+        const entries = await readdir3(path13, { withFileTypes: true });
         return entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
       },
-      async readFile(path12) {
+      async readFile(path13) {
         try {
-          return await readFile4(path12, "utf8");
+          return await readFile5(path13, "utf8");
         } catch (err) {
           if (err.code === "ENOENT") return null;
           throw err;
@@ -104434,9 +103526,9 @@ var init_mention_resolver = __esm({
 
 // src/editor/node-mention-fs.ts
 import { open as open2, realpath as realpath2, stat as stat2 } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 function isInside(root, target) {
-  return target === root || target.startsWith(root.endsWith(path6.sep) ? root : root + path6.sep);
+  return target === root || target.startsWith(root.endsWith(path7.sep) ? root : root + path7.sep);
 }
 function createNodeMentionFS(cwd2) {
   let rootPromise;
@@ -104481,10 +103573,10 @@ var init_node_mention_fs = __esm({
 
 // src/editor/node-read-dir.ts
 import { readdir as readdir4 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 function createNodeReadDir(cwd2) {
   return async (rel) => {
-    const entries = await readdir4(path7.join(cwd2, rel), { withFileTypes: true });
+    const entries = await readdir4(path8.join(cwd2, rel), { withFileTypes: true });
     return entries.map((e) => ({ name: e.name, isFile: e.isFile(), isDirectory: e.isDirectory() }));
   };
 }
@@ -104495,11 +103587,11 @@ var init_node_read_dir = __esm({
 });
 
 // src/editor/node-mentions.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import path8 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import path9 from "node:path";
 async function readGitignore(cwd2) {
   try {
-    return createGitignoreMatcher(await readFile5(path8.join(cwd2, ".gitignore"), "utf8"));
+    return createGitignoreMatcher(await readFile6(path9.join(cwd2, ".gitignore"), "utf8"));
   } catch (err) {
     if (err.code === "ENOENT") return () => false;
     throw err;
@@ -104609,7 +103701,7 @@ var init_recording_chunks = __esm({
 
 // src/recording/recorder.ts
 import { createHash as createHash4 } from "node:crypto";
-import { mkdir as mkdir4, readFile as readFile6, rename as rename4, rm as rm2, writeFile as writeFile4, readdir as readdir5, stat as stat3 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile7, rename as rename4, rm as rm2, writeFile as writeFile4, readdir as readdir5, stat as stat3 } from "node:fs/promises";
 import { join as join9 } from "node:path";
 function projectHash(root) {
   return createHash4("sha256").update(root).digest("hex");
@@ -104633,7 +103725,7 @@ function createRecorder(deps) {
     if (cached3) return cached3;
     let st;
     try {
-      st = JSON.parse(await readFile6(stateFile(sessionId), "utf8"));
+      st = JSON.parse(await readFile7(stateFile(sessionId), "utf8"));
     } catch (e) {
       if (e.code !== "ENOENT") {
         const bad = join9(deps.dir, "bad");
@@ -104828,15 +103920,15 @@ var init_recorder = __esm({
 });
 
 // src/recording/recording-runtime.ts
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile5, stat as stat4 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile5, stat as stat4 } from "node:fs/promises";
 import { join as join10, sep as sep2 } from "node:path";
 function matchesExclude(pattern, root) {
   const re3 = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, `[^${sep2 === "\\" ? "\\\\" : "/"}]*`).replace(/\u0000/g, ".*");
   return new RegExp(`^${re3}(?:[/\\\\].*)?$`).test(root);
 }
-async function exists(path12) {
+async function exists(path13) {
   try {
-    await stat4(path12);
+    await stat4(path13);
     return true;
   } catch (e) {
     if (e.code === "ENOENT") return false;
@@ -104853,7 +103945,7 @@ function createRecordingRuntime(deps) {
     if (deps.env.SPACECODE_RECORD?.trim().toLowerCase() === "off") return "SPACECODE_RECORD=off";
     let cfg = {};
     try {
-      cfg = JSON.parse(await readFile7(join10(deps.configDir, "config.json"), "utf8"));
+      cfg = JSON.parse(await readFile8(join10(deps.configDir, "config.json"), "utf8"));
     } catch (e) {
       if (e.code !== "ENOENT") return `~/.spacecode/config.json is unreadable (${e instanceof Error ? e.message : String(e)}); fix it to record`;
     }
@@ -105001,12 +104093,37 @@ var init_skills_command = __esm({
   }
 });
 
-// src/permission-rules-loader.ts
-import { readFile as readFile8 } from "node:fs/promises";
+// src/mcp/tool-cache-file.ts
+import { readFile as readFile9 } from "node:fs/promises";
 import { join as join11 } from "node:path";
-async function readOrNull2(path12) {
+function nodeToolCache(configDir) {
+  const path13 = join11(configDir, "mcp-tools-cache.json");
+  return {
+    read: async () => {
+      try {
+        return await readFile9(path13, "utf8");
+      } catch (err) {
+        if (err.code === "ENOENT") return null;
+        throw err;
+      }
+    },
+    write: (text) => writeTextAtomic(path13, text),
+    hash: sha256
+  };
+}
+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 readFile10 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+async function readOrNull2(path13) {
   try {
-    return await readFile8(path12, "utf8");
+    return await readFile10(path13, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -105014,7 +104131,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 +104140,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) {
@@ -105073,7 +104190,7 @@ var init_permission_rules_loader = __esm({
 // src/import-reload.ts
 async function checkRepoSources(deps, loaded) {
   const files = await readRepoSources(deps.cwd);
-  const current = fingerprintSources(files, sha2562);
+  const current = fingerprintSources(files, sha256);
   const status = Object.keys(files).length === 0 ? "untrusted" : await createNodeTrustStore(deps.configDir).repoStatus(deps.cwd, files);
   return { current, changes: diffSources(loaded, current), trusted: status === "trusted" || status === "session" };
 }
@@ -105094,7 +104211,7 @@ async function describeReload(deps, loaded) {
 async function trustCurrentSources(deps) {
   const files = await readRepoSources(deps.cwd);
   await createNodeTrustStore(deps.configDir).setRepo(deps.cwd, files, "trusted");
-  return fingerprintSources(files, sha2562);
+  return fingerprintSources(files, sha256);
 }
 var init_import_reload = __esm({
   "src/import-reload.ts"() {
@@ -105106,7 +104223,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 +104278,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 +104311,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 readFile11, 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 +104336,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) => readFile11(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 +104352,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) => readFile11(p, "utf-8"), homedir: homedir2 }).catch(() => null),
     log: (m2) => console.error(`[agent-ui] ${m2}`)
   });
   const resumeListRef = (0, import_react30.useRef)([]);
@@ -105263,10 +104380,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) => readFile11(p, "utf-8"),
       homedir: homedir2,
       fetch,
       builtins: SLASH_COMMANDS.map((c) => c.name)
@@ -105484,7 +104601,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") {
@@ -105492,12 +104609,12 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
             return;
           }
           try {
-            const baseline = loadedSourcesRef.current ?? fingerprintSources(await readRepoSources(process.cwd()), sha2562);
+            const baseline = loadedSourcesRef.current ?? fingerprintSources(await readRepoSources(process.cwd()), sha256);
             if (rest[0] === "trust") {
               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) => readFile11(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 +104694,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) => readFile11(p, "utf-8"), homedir: homedir2 });
             if (!apiKey2) {
               notice(MISSING_KEY_MESSAGE);
               return;
@@ -105599,7 +104716,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) => readFile11(p, "utf-8"), homedir: homedir2 });
             if (!apiKey2) {
               notice(MISSING_KEY_MESSAGE);
               return;
@@ -105634,7 +104751,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) => readFile11(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 +104773,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) => readFile11(p, "utf-8"),
         homedir: homedir2
       });
     } catch (err) {
@@ -105692,7 +104809,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 +104826,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) => readFile11(p, "utf-8"),
         writeFile: (p, d) => writeFile6(p, d, { encoding: "utf-8", mode: 384 }),
         mkdir: async (p) => {
           await mkdir6(p, { recursive: true });
@@ -105719,8 +104836,8 @@ ${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 fingerprint = fingerprintSources(await readRepoSources(process.cwd()), sha2562);
+          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join14(homedir2(), ".spacecode");
+          const fingerprint = fingerprintSources(await readRepoSources(process.cwd()), sha256);
           const gate = await importGateStatus({ configDir, cwd: process.cwd(), interactive: Boolean(process.stdin.isTTY) });
           const loaded = await loadPermissionRules({ configDir, homeDir: homedir2(), cwd: process.cwd() });
           rulesRef.current = loaded.rules;
@@ -105731,7 +104848,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 +104858,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 +105001,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();
@@ -106013,12 +105133,12 @@ var init_TurnViewer = __esm({
 });
 
 // src/render/resume-rows.ts
-import path9 from "node:path";
+import path10 from "node:path";
 function orderSessions(sessions, projectRoot) {
   return [...sessions.filter((s) => s.projectRoot === projectRoot), ...sessions.filter((s) => s.projectRoot !== projectRoot)];
 }
 function formatResumeRow(meta, now, columns, sep3 = "\xB7", ellipsis = "\u2026") {
-  const project = path9.basename(meta.projectRoot) || meta.projectRoot;
+  const project = path10.basename(meta.projectRoot) || meta.projectRoot;
   const tail = [meta.turns !== void 0 ? `${meta.turns} turn${meta.turns === 1 ? "" : "s"}` : null, formatCost(estimateCostUsd(meta.tokens.input, meta.tokens.output))].filter(Boolean).join(` ${sep3} `);
   const head = `${formatAge(meta.updatedAt, now)} ${sep3} ${project} ${sep3} `;
   const fixed = head.length + 2 + ` ${sep3} ${tail}`.length;
@@ -106163,14 +105283,14 @@ var App_exports = {};
 __export(App_exports, {
   App: () => App2
 });
-import os4 from "node:os";
-import path10 from "node:path";
+import os5 from "node:os";
+import path11 from "node:path";
 function App2({ repoName: repoName2, onboardingMode: onboardingMode2, launchCount: launchCount2, yolo: yolo2, history, sessions, resumeLatest: resumeLatest2, git: gitRunner, interactivePicker = true, fullscreen: fullscreen2 = false }) {
   const promptHistory = (0, import_react34.useMemo)(
-    () => history ?? new PromptHistory(createFileHistoryIO(path10.join(os4.homedir(), ".spacecode", "history"))),
+    () => history ?? new PromptHistory(createFileHistoryIO(path11.join(os5.homedir(), ".spacecode", "history"))),
     [history]
   );
-  const sessionStore = (0, import_react34.useMemo)(() => sessions ?? new SessionStore(path10.join(os4.homedir(), ".spacecode", "sessions")), [sessions]);
+  const sessionStore = (0, import_react34.useMemo)(() => sessions ?? new SessionStore(path11.join(os5.homedir(), ".spacecode", "sessions")), [sessions]);
   const runGit = (0, import_react34.useMemo)(() => gitRunner ?? createNodeGitRunner(process.cwd()), [gitRunner]);
   const startedAtRef = (0, import_react34.useRef)(Date.now());
   const [viewingRaw, setViewing] = (0, import_react34.useState)(false);
@@ -106260,7 +105380,7 @@ function App2({ repoName: repoName2, onboardingMode: onboardingMode2, launchCoun
       viewing && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(TurnViewer, { turns: viewerTurns, steps: turnSteps, rows: rows - 2, columns, onClose: () => setViewing(false), onEscape: swallowEsc }),
       picking && resumeFound && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ResumePicker, { sessions: resumeFound.sessions, errors: resumeFound.errors, projectRoot: process.cwd(), now: /* @__PURE__ */ new Date(), rows: rows - 2, columns, preview: resume.preview, onResume: resume.load, onDelete: resume.remove, onClose: () => setResumeFound(null), onEscape: swallowEsc }),
       /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(Box_default, { flexDirection: "column", flexGrow: 1, display: hidden ? "none" : "flex", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Box_default, { flexShrink: 0, children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Header, { project: repoName2 ?? path10.basename(process.cwd()), git: gitState, turns: turns.length, elapsedMs: Date.now() - startedAtRef.current, columns }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Box_default, { flexShrink: 0, children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Header, { project: repoName2 ?? path11.basename(process.cwd()), git: gitState, turns: turns.length, elapsedMs: Date.now() - startedAtRef.current, columns }) }),
         /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(Transcript, { scroll, onMeasure, children: [
           notices.map((n, i) => typeof n === "string" ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { ...paint("action"), children: n }, i) : /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ErrorBlock, { view: n.error }, i)),
           /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(WelcomeBanner, { repoName: repoName2, onboardingMode: onboardingMode2, launchCount: launchCount2 }),
@@ -106290,7 +105410,7 @@ function App2({ repoName: repoName2, onboardingMode: onboardingMode2, launchCoun
     ] });
   }
   return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(Box_default, { flexDirection: "column", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Header, { project: repoName2 ?? path10.basename(process.cwd()), git: gitState, turns: turns.length, elapsedMs: Date.now() - startedAtRef.current, columns }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Header, { project: repoName2 ?? path11.basename(process.cwd()), git: gitState, turns: turns.length, elapsedMs: Date.now() - startedAtRef.current, columns }),
     notices.map((n, i) => typeof n === "string" ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Text, { ...paint("action"), children: n }, i) : /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ErrorBlock, { view: n.error }, i)),
     /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Static, { items: [BANNER, ...turns], children: (turn) => typeof turn === "symbol" ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(WelcomeBanner, { repoName: repoName2, onboardingMode: onboardingMode2, launchCount: launchCount2 }, "banner") : /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(Box_default, { flexDirection: "column", children: [
       /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(Text, { ...paint("secondary"), children: [
@@ -106384,8 +105504,8 @@ init_color_policy();
 applyColorPolicy(process.env, Boolean(process.stdout.isTTY));
 
 // src/index.tsx
-import os5 from "node:os";
-import path11 from "node:path";
+import os6 from "node:os";
+import path12 from "node:path";
 import fs5 from "node:fs";
 import util2 from "node:util";
 
@@ -106471,7 +105591,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: readFile12, 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,9 +105599,9 @@ 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"),
-    homedir: os5.homedir,
+    fs: { readFile: (p) => readFile12(p, "utf-8"), readdir: (p) => readdir6(p) },
+    readFile: (p) => readFile12(p, "utf-8"),
+    homedir: os6.homedir,
     cwd: process.cwd(),
     gitRoot,
     fetch,
@@ -106500,37 +105620,8 @@ if (process.argv[2] === "import-claude") {
   process.exit(code);
 }
 if (process.argv[2] === "approve-mcp") {
-  const { runApproveMcp: runApproveMcp2 } = await Promise.resolve().then(() => (init_approve_mcp(), approve_mcp_exports));
-  const { createNodeTrustStore: createNodeTrustStore2 } = await Promise.resolve().then(() => (init_import_gate(), import_gate_exports));
-  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 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 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;
-  try {
-    const code = await runApproveMcp2({
-      configDir,
-      cwd: process.cwd(),
-      readFile: (p) => readFile10(p, "utf-8"),
-      client: apiKey ? createProfileClient2({ baseUrl: backendUrl2(process.env), apiKey, fetch }) : null,
-      trust: createNodeTrustStore2(configDir),
-      ...rl ? { ask: async (q2) => {
-        try {
-          return await rl.question(q2);
-        } catch {
-          return null;
-        }
-      } } : {},
-      log: (line) => console.log(line)
-    });
-    process.exitCode = code;
-  } finally {
-    rl?.close();
-  }
+  const { runApproveMcpOnNode: runApproveMcpOnNode2 } = await Promise.resolve().then(() => (init_approve_mcp_node(), approve_mcp_node_exports));
+  process.exitCode = await runApproveMcpOnNode2({ quiet: false });
   process.exit(process.exitCode ?? 0);
 }
 var repoName = process.env.REPO_NAME || process.cwd().split("/").pop() || void 0;
@@ -106547,7 +105638,7 @@ if (process.stdin.isTTY && process.stdout.isTTY) {
     const { promptRepoTrust: promptRepoTrust2 } = await Promise.resolve().then(() => (init_repo_trust_prompt(), repo_trust_prompt_exports));
     const files = await readRepoSources2(process.cwd());
     if (Object.keys(files).length > 0) {
-      const store = createNodeTrustStore2(process.env.SPACECODE_CONFIG_DIR?.trim() || path11.join(os5.homedir(), ".spacecode"));
+      const store = createNodeTrustStore2(process.env.SPACECODE_CONFIG_DIR?.trim() || path12.join(os6.homedir(), ".spacecode"));
       if (await store.repoStatus(process.cwd(), files) === "untrusted") {
         const { createInterface } = await import("node:readline/promises");
         const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -106575,6 +105666,15 @@ if (process.stdin.isTTY && process.stdout.isTTY) {
 `);
   }
 }
+if (process.stdin.isTTY && process.stdout.isTTY) {
+  try {
+    const { runApproveMcpOnNode: runApproveMcpOnNode2 } = await Promise.resolve().then(() => (init_approve_mcp_node(), approve_mcp_node_exports));
+    await runApproveMcpOnNode2({ quiet: true });
+  } catch (err) {
+    process.stderr.write(`MCP approval check failed (${err instanceof Error ? err.message : String(err)}); imported MCP servers stay unapproved.
+`);
+  }
+}
 var restoreCiVariables = hideCiVariables(process.env, Boolean(process.stdout.isTTY));
 var render3;
 var App3;
@@ -106586,9 +105686,9 @@ try {
 var fullscreen = shouldUseFullscreen(process.env, process.stdout, Boolean(process.stdin.isTTY));
 var session;
 if (fullscreen) {
-  const dir = path11.join(os5.homedir(), ".spacecode");
+  const dir = path12.join(os6.homedir(), ".spacecode");
   fs5.mkdirSync(dir, { recursive: true });
-  const restoreConsole = redirectConsole(path11.join(dir, "repl.log"));
+  const restoreConsole = redirectConsole(path12.join(dir, "repl.log"));
   session = enterFullscreen(process.stdout, process);
   session.onLeave(restoreConsole);
   session.onLeave(clearOnResize(process.stdout));