@contextstream/mcp-server 0.4.67 → 0.4.71

package/dist/index.js

@@ -733,7 +733,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path20, checkUnignored, mode) {
+      test(path21, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -742,7 +742,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path20);
+          const matched = rule[mode].test(path21);
           if (!matched) {
             return;
           }
@@ -763,17 +763,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path20, originalPath, doThrow) => {
-      if (!isString(path20)) {
+    var checkPath = (path21, originalPath, doThrow) => {
+      if (!isString(path21)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path20) {
+      if (!path21) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path20)) {
+      if (checkPath.isNotRelative(path21)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -782,7 +782,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path20) => REGEX_TEST_INVALID_PATH.test(path20);
+    var isNotRelative = (path21) => REGEX_TEST_INVALID_PATH.test(path21);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -812,19 +812,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path20 = originalPath && checkPath.convert(originalPath);
+        const path21 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path20,
+          path21,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path20, cache, checkUnignored, slices);
+        return this._t(path21, cache, checkUnignored, slices);
       }
-      checkIgnore(path20) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path20)) {
-          return this.test(path20);
+      checkIgnore(path21) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path21)) {
+          return this.test(path21);
         }
-        const slices = path20.split(SLASH).filter(Boolean);
+        const slices = path21.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -837,18 +837,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path20, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path21, false, MODE_CHECK_IGNORE);
       }
-      _t(path20, cache, checkUnignored, slices) {
-        if (path20 in cache) {
-          return cache[path20];
+      _t(path21, cache, checkUnignored, slices) {
+        if (path21 in cache) {
+          return cache[path21];
         }
         if (!slices) {
-          slices = path20.split(SLASH).filter(Boolean);
+          slices = path21.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path20] = this._rules.test(path20, checkUnignored, MODE_IGNORE);
+          return cache[path21] = this._rules.test(path21, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -856,29 +856,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path20] = parent.ignored ? parent : this._rules.test(path20, checkUnignored, MODE_IGNORE);
+        return cache[path21] = parent.ignored ? parent : this._rules.test(path21, checkUnignored, MODE_IGNORE);
       }
-      ignores(path20) {
-        return this._test(path20, this._ignoreCache, false).ignored;
+      ignores(path21) {
+        return this._test(path21, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path20) => !this.ignores(path20);
+        return (path21) => !this.ignores(path21);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path20) {
-        return this._test(path20, this._testCache, true);
+      test(path21) {
+        return this._test(path21, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path20) => checkPath(path20 && checkPath.convert(path20), path20, RETURN_FALSE);
+    var isPathValid = (path21) => checkPath(path21 && checkPath.convert(path21), path21, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path20) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path20) || isNotRelative(path20);
+      checkPath.isNotRelative = (path21) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path21) || isNotRelative(path21);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -3778,7 +3778,7 @@ memory(
 
 - Do not store trivial file reads or command output as memory
 - Do not skip \`context(...)\` on later turns
-- Do not use local file scanning before \`search(...)\` unless search returns 0 results
+- Do not use local file scanning before \`search(...)\`; for stale/not-indexed projects, wait ~20s for refresh and retry first, then local fallback is allowed
 - Do not use editor-only task lists as the persistent record; mirror important work in ContextStream
 `;
 }
@@ -3960,7 +3960,7 @@ Use \`context()\` by default to get task-specific rules, lessons from past mista
 2. **PreToolUse blocking** - If you try to use Glob/Grep/Search/Explore:
    - Hook returns error: \`STOP: Use mcp__contextstream__search(mode="auto") instead\`
    - **You MUST use the suggested ContextStream tool instead**
-   - Local tools are only allowed if project is not indexed or ContextStream returns 0 results
+  - For stale/not-indexed projects, wait for background refresh (up to ~20s), retry search, then allow local tools only after the grace window
 
 3. **PostToolUse indexing** - After Edit/Write operations:
    - Changed files are automatically re-indexed
@@ -3997,7 +3997,7 @@ STOP \u2192 Call search(mode="auto", query="...") FIRST
 
 \u2705 **ALWAYS DO THIS:**
 1. \`search(mode="auto", query="what you're looking for")\`
-2. Only use local tools (Glob/Grep/Read) if ContextStream returns **0 results**
+2. Only use local tools (Glob/Grep/Read) after stale/not-indexed refresh grace window elapses (~20s) or ContextStream still returns **0 results** after retry
 3. Use Read ONLY for exact file edits after you know the file path
 
 This applies to **EVERY search** throughout the **ENTIRE conversation**, not just the first message.
@@ -4260,7 +4260,7 @@ session(action="capture", event_type="session_snapshot", title="Pre-compaction s
 
 ### Search & Code Intelligence (ContextStream-first)
 
-\u26A0\uFE0F **STOP: Before using Search/Glob/Grep/Read/Explore** \u2192 Call \`search(mode="auto")\` FIRST. Use local tools ONLY if ContextStream returns 0 results.
+\u26A0\uFE0F **STOP: Before using Search/Glob/Grep/Read/Explore** \u2192 Call \`search(mode="auto")\` FIRST. For stale/not-indexed projects, wait ~20s for background refresh and retry search before local fallback.
 
 **\u274C WRONG workflow (wastes tokens, slow):**
 \`\`\`
@@ -4279,7 +4279,7 @@ search(mode="auto", query="function implementation") \u2192 done (results includ
 2. \`search(mode="auto", query="...", limit=3)\` or \`search(mode="keyword", query="<filename>", limit=3)\`
 3. \`project(action="files")\` - file tree/list (only when needed)
 4. \`graph(action="dependencies", ...)\` - code structure
-5. Local repo scans (rg/ls/find) - ONLY if ContextStream returns no results, errors, or the user explicitly asks
+5. Local repo scans (rg/ls/find) - ONLY after refresh grace window/retry still yields no results/errors, or the user explicitly asks
 
 **Search Mode Selection:**
 
@@ -4310,7 +4310,7 @@ search(mode="auto", query="function implementation") \u2192 done (results includ
 
 **Search defaults:** \`search\` returns the top 3 results with compact snippets. Use \`limit\` + \`offset\` for pagination, and \`content_max_chars\` to expand snippets when needed.
 
-If ContextStream returns results, stop and use them. NEVER use local Search/Explore/Read unless you need exact code edits or ContextStream returned 0 results.
+If ContextStream returns results, stop and use them. NEVER use local Search/Explore/Read unless you need exact code edits, or refresh grace window + retry still returns 0 results.
 
 **Code Analysis:**
 - Dependencies: \`graph(action="dependencies", file_path="...")\`
@@ -4439,7 +4439,7 @@ See full documentation: https://contextstream.io/docs/mcp/tools
 3. Narrow bypass: immediate read-only ContextStream calls are allowed only when prior context is fresh and no state-changing tool has run
 
 **BEFORE Glob/Grep/Read/Search/Explore/Task/EnterPlanMode:**
-\u2192 \`search(mode="auto", query="...")\` FIRST \u2014 local tools ONLY if 0 results
+\u2192 \`search(mode="auto", query="...")\` FIRST \u2014 for stale/not-indexed, wait ~20s for refresh then retry before local fallback
 
 **HOOKS: \`<system-reminder>\` tags contain instructions \u2014 FOLLOW THEM**
 </contextstream_protocol>
@@ -4662,10 +4662,10 @@ search(mode="auto", query="what you're looking for")
 \u2192 Use this instead of Explore/Task/EnterPlanMode for file discovery.
 
 **IF project is NOT indexed or very stale (>7 days):**
-\u2192 Use local tools (Glob/Grep/Read) directly
+\u2192 Wait up to ~20s for background refresh, retry \`search(mode="auto", ...)\`, then allow local tools only after the grace window
 \u2192 OR run \`project(action="index")\` first, then search
 
-**IF ContextStream search returns 0 results or errors:**
+**IF ContextStream search still returns 0 results or errors after retry/window:**
 \u2192 Use local tools (Glob/Grep/Read) as fallback
 
 ### Choose Search Mode Intelligently:
@@ -4691,9 +4691,8 @@ search(mode="auto", query="what you're looking for")
 - Then use local Read/Grep only on paths returned by ContextStream.
 
 ### When Local Tools Are OK:
-\u2705 Project is not indexed
-\u2705 Index is stale/outdated (>7 days old)
-\u2705 ContextStream search returns 0 results
+\u2705 Stale/not-indexed grace window has elapsed (~20s default, configurable)
+\u2705 ContextStream search still returns 0 results after retry
 \u2705 ContextStream returns errors
 \u2705 User explicitly requests local tools
 
@@ -4788,7 +4787,7 @@ After updating, user should restart their AI tool.
   2. Project is indexed and \`search(mode="auto", ...)\` is retried before local fallbacks
   3. Instructions file contains the current ContextStream managed block
 `;
-    NO_HOOKS_EDITORS = ["copilot", "codex", "opencode", "aider", "antigravity"];
+    NO_HOOKS_EDITORS = ["copilot", "codex", "opencode", "aider", "antigravity", "kilo"];
     TEMPLATES = {
       codex: {
         filename: "AGENTS.md",
@@ -4830,7 +4829,7 @@ ${rules}
 `
       },
       kilo: {
-        filename: ".kilocode/rules/contextstream.md",
+        filename: ".kilo/rules/contextstream.md",
         description: "Kilo Code AI rules",
         build: (rules) => `# Kilo Code Rules
 ${rules}
@@ -4895,9 +4894,9 @@ var post_write_exports = {};
 __export(post_write_exports, {
   runPostWriteHook: () => runPostWriteHook
 });
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
-import { homedir as homedir7 } from "node:os";
+import * as fs9 from "node:fs";
+import * as path10 from "node:path";
+import { homedir as homedir8 } from "node:os";
 function extractFilePath(input) {
   if (input.tool_input) {
     const filePath = input.tool_input.file_path || input.tool_input.notebook_path || input.tool_input.path;
@@ -4922,17 +4921,17 @@ function extractCwd(input) {
   return process.cwd();
 }
 function findLocalConfig(startDir) {
-  let currentDir = path9.resolve(startDir);
+  let currentDir = path10.resolve(startDir);
   for (let i = 0; i < 10; i++) {
-    const configPath = path9.join(currentDir, ".contextstream", "config.json");
-    if (fs8.existsSync(configPath)) {
+    const configPath = path10.join(currentDir, ".contextstream", "config.json");
+    if (fs9.existsSync(configPath)) {
       try {
-        const content = fs8.readFileSync(configPath, "utf-8");
+        const content = fs9.readFileSync(configPath, "utf-8");
         return JSON.parse(content);
       } catch {
       }
     }
-    const parentDir = path9.dirname(currentDir);
+    const parentDir = path10.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -4944,12 +4943,12 @@ function loadApiConfig(startDir) {
   if (apiKey) {
     return { apiUrl, apiKey };
   }
-  let currentDir = path9.resolve(startDir);
+  let currentDir = path10.resolve(startDir);
   for (let i = 0; i < 10; i++) {
-    const mcpPath = path9.join(currentDir, ".mcp.json");
-    if (fs8.existsSync(mcpPath)) {
+    const mcpPath = path10.join(currentDir, ".mcp.json");
+    if (fs9.existsSync(mcpPath)) {
       try {
-        const content = fs8.readFileSync(mcpPath, "utf-8");
+        const content = fs9.readFileSync(mcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -4962,15 +4961,15 @@ function loadApiConfig(startDir) {
       } catch {
       }
     }
-    const parentDir = path9.dirname(currentDir);
+    const parentDir = path10.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
   if (!apiKey) {
-    const homeMcpPath = path9.join(homedir7(), ".mcp.json");
-    if (fs8.existsSync(homeMcpPath)) {
+    const homeMcpPath = path10.join(homedir8(), ".mcp.json");
+    if (fs9.existsSync(homeMcpPath)) {
       try {
-        const content = fs8.readFileSync(homeMcpPath, "utf-8");
+        const content = fs9.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -4986,15 +4985,15 @@ function loadApiConfig(startDir) {
   return { apiUrl, apiKey };
 }
 function shouldIndexFile(filePath) {
-  const ext = path9.extname(filePath).toLowerCase();
+  const ext = path10.extname(filePath).toLowerCase();
   if (!INDEXABLE_EXTENSIONS.has(ext)) {
-    const basename5 = path9.basename(filePath).toLowerCase();
+    const basename5 = path10.basename(filePath).toLowerCase();
     if (!["dockerfile", "makefile", "rakefile", "gemfile", "procfile"].includes(basename5)) {
       return false;
     }
   }
   try {
-    const stats = fs8.statSync(filePath);
+    const stats = fs9.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE2) {
       return false;
     }
@@ -5004,7 +5003,7 @@ function shouldIndexFile(filePath) {
   return true;
 }
 function detectLanguage2(filePath) {
-  const ext = path9.extname(filePath).toLowerCase();
+  const ext = path10.extname(filePath).toLowerCase();
   const langMap = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -5073,8 +5072,8 @@ function detectLanguage2(filePath) {
   return langMap[ext] || "text";
 }
 async function indexFile(filePath, projectId, apiUrl, apiKey, projectRoot) {
-  const content = fs8.readFileSync(filePath, "utf-8");
-  const relativePath = path9.relative(projectRoot, filePath);
+  const content = fs9.readFileSync(filePath, "utf-8");
+  const relativePath = path10.relative(projectRoot, filePath);
   const payload = {
     files: [
       {
@@ -5106,13 +5105,13 @@ async function indexFile(filePath, projectId, apiUrl, apiKey, projectRoot) {
   }
 }
 function findProjectRoot(filePath) {
-  let currentDir = path9.dirname(path9.resolve(filePath));
+  let currentDir = path10.dirname(path10.resolve(filePath));
   for (let i = 0; i < 10; i++) {
-    const configPath = path9.join(currentDir, ".contextstream", "config.json");
-    if (fs8.existsSync(configPath)) {
+    const configPath = path10.join(currentDir, ".contextstream", "config.json");
+    if (fs9.existsSync(configPath)) {
       return currentDir;
     }
-    const parentDir = path9.dirname(currentDir);
+    const parentDir = path10.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -5140,8 +5139,8 @@ async function runPostWriteHook() {
     process.exit(0);
   }
   const cwd = extractCwd(input);
-  const absolutePath = path9.isAbsolute(filePath) ? filePath : path9.resolve(cwd, filePath);
-  if (!fs8.existsSync(absolutePath) || !shouldIndexFile(absolutePath)) {
+  const absolutePath = path10.isAbsolute(filePath) ? filePath : path10.resolve(cwd, filePath);
+  if (!fs9.existsSync(absolutePath) || !shouldIndexFile(absolutePath)) {
     process.exit(0);
   }
   const projectRoot = findProjectRoot(absolutePath);
@@ -5245,12 +5244,12 @@ var init_post_write = __esm({
 });
 
 // src/hooks/common.ts
-import * as fs9 from "node:fs";
-import * as path10 from "node:path";
-import { homedir as homedir8 } from "node:os";
+import * as fs10 from "node:fs";
+import * as path11 from "node:path";
+import { homedir as homedir9 } from "node:os";
 function readHookInput() {
   try {
-    return JSON.parse(fs9.readFileSync(0, "utf8"));
+    return JSON.parse(fs10.readFileSync(0, "utf8"));
   } catch {
     return {};
   }
@@ -5279,13 +5278,13 @@ function loadHookConfig(cwd) {
   let jwt = process.env.CONTEXTSTREAM_JWT || "";
   let workspaceId = process.env.CONTEXTSTREAM_WORKSPACE_ID || null;
   let projectId = process.env.CONTEXTSTREAM_PROJECT_ID || null;
-  let searchDir = path10.resolve(cwd);
+  let searchDir = path11.resolve(cwd);
   for (let i = 0; i < 6; i++) {
     if (!apiKey && !jwt) {
-      const mcpPath = path10.join(searchDir, ".mcp.json");
-      if (fs9.existsSync(mcpPath)) {
+      const mcpPath = path11.join(searchDir, ".mcp.json");
+      if (fs10.existsSync(mcpPath)) {
         try {
-          const config = JSON.parse(fs9.readFileSync(mcpPath, "utf8"));
+          const config = JSON.parse(fs10.readFileSync(mcpPath, "utf8"));
           const env = config.mcpServers?.contextstream?.env;
           if (env?.CONTEXTSTREAM_API_KEY) apiKey = env.CONTEXTSTREAM_API_KEY;
           if (env?.CONTEXTSTREAM_JWT) jwt = env.CONTEXTSTREAM_JWT;
@@ -5297,25 +5296,25 @@ function loadHookConfig(cwd) {
       }
     }
     if (!workspaceId || !projectId) {
-      const localConfigPath = path10.join(searchDir, ".contextstream", "config.json");
-      if (fs9.existsSync(localConfigPath)) {
+      const localConfigPath = path11.join(searchDir, ".contextstream", "config.json");
+      if (fs10.existsSync(localConfigPath)) {
         try {
-          const localConfig = JSON.parse(fs9.readFileSync(localConfigPath, "utf8"));
+          const localConfig = JSON.parse(fs10.readFileSync(localConfigPath, "utf8"));
           if (localConfig.workspace_id && !workspaceId) workspaceId = localConfig.workspace_id;
           if (localConfig.project_id && !projectId) projectId = localConfig.project_id;
         } catch {
         }
       }
     }
-    const parentDir = path10.dirname(searchDir);
+    const parentDir = path11.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!apiKey && !jwt) {
-    const homeMcpPath = path10.join(homedir8(), ".mcp.json");
-    if (fs9.existsSync(homeMcpPath)) {
+    const homeMcpPath = path11.join(homedir9(), ".mcp.json");
+    if (fs10.existsSync(homeMcpPath)) {
       try {
-        const config = JSON.parse(fs9.readFileSync(homeMcpPath, "utf8"));
+        const config = JSON.parse(fs10.readFileSync(homeMcpPath, "utf8"));
         const env = config.mcpServers?.contextstream?.env;
         if (env?.CONTEXTSTREAM_API_KEY) apiKey = env.CONTEXTSTREAM_API_KEY;
         if (env?.CONTEXTSTREAM_JWT) jwt = env.CONTEXTSTREAM_JWT;
@@ -5475,9 +5474,9 @@ var post_tool_use_failure_exports = {};
 __export(post_tool_use_failure_exports, {
   runPostToolUseFailureHook: () => runPostToolUseFailureHook
 });
-import * as fs10 from "node:fs";
-import * as path11 from "node:path";
-import { homedir as homedir9 } from "node:os";
+import * as fs11 from "node:fs";
+import * as path12 from "node:path";
+import { homedir as homedir10 } from "node:os";
 function extractErrorText(input) {
   return typeof input.error === "string" && input.error || typeof input.tool_error === "string" && input.tool_error || typeof input.stderr === "string" && input.stderr || "Tool execution failed";
 }
@@ -5488,13 +5487,13 @@ function failureFingerprint(toolName, errorText) {
 function incrementFailureCounter(fingerprint) {
   let counters = {};
   try {
-    counters = JSON.parse(fs10.readFileSync(FAILURE_COUNTERS_FILE, "utf8"));
+    counters = JSON.parse(fs11.readFileSync(FAILURE_COUNTERS_FILE, "utf8"));
   } catch {
     counters = {};
   }
   counters[fingerprint] = (counters[fingerprint] || 0) + 1;
-  fs10.mkdirSync(path11.dirname(FAILURE_COUNTERS_FILE), { recursive: true });
-  fs10.writeFileSync(FAILURE_COUNTERS_FILE, JSON.stringify(counters, null, 2), "utf8");
+  fs11.mkdirSync(path12.dirname(FAILURE_COUNTERS_FILE), { recursive: true });
+  fs11.writeFileSync(FAILURE_COUNTERS_FILE, JSON.stringify(counters, null, 2), "utf8");
   return counters[fingerprint];
 }
 async function runPostToolUseFailureHook() {
@@ -5547,7 +5546,7 @@ var init_post_tool_use_failure = __esm({
   "src/hooks/post-tool-use-failure.ts"() {
     "use strict";
     init_common();
-    FAILURE_COUNTERS_FILE = path11.join(homedir9(), ".contextstream", "hook-failure-counts.json");
+    FAILURE_COUNTERS_FILE = path12.join(homedir10(), ".contextstream", "hook-failure-counts.json");
     isDirectRun2 = process.argv[1]?.includes("post-tool-use-failure") || process.argv[2] === "post-tool-use-failure";
     if (isDirectRun2) {
       runPostToolUseFailureHook().catch(() => process.exit(0));
@@ -5713,10 +5712,10 @@ var subagent_stop_exports = {};
 __export(subagent_stop_exports, {
   runSubagentStopHook: () => runSubagentStopHook
 });
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 function parseTranscript(transcriptPath) {
   try {
-    const content = fs11.readFileSync(transcriptPath, "utf8");
+    const content = fs12.readFileSync(transcriptPath, "utf8");
     const assistantMessages = [];
     let toolCallCount = 0;
     for (const rawLine of content.split("\n")) {
@@ -5778,7 +5777,7 @@ async function runSubagentStopHook() {
   const agentType = typeof input.agent_type === "string" && input.agent_type || typeof input.subagent_type === "string" && input.subagent_type || "unknown";
   const agentId = typeof input.agent_id === "string" && input.agent_id || "unknown";
   const transcriptPath = typeof input.agent_transcript_path === "string" && input.agent_transcript_path || typeof input.transcript_path === "string" && input.transcript_path || "";
-  const transcript = transcriptPath && fs11.existsSync(transcriptPath) ? parseTranscript(transcriptPath) : { assistantMessages: [], toolCallCount: 0 };
+  const transcript = transcriptPath && fs12.existsSync(transcriptPath) ? parseTranscript(transcriptPath) : { assistantMessages: [], toolCallCount: 0 };
   const summaryText = transcript.assistantMessages.join("\n\n") || typeof input.summary === "string" && input.summary || "(No assistant output found in subagent transcript.)";
   if (agentType.toLowerCase() === "plan") {
     const suppliedPlanId = typeof input.plan_id === "string" && input.plan_id || typeof input.planId === "string" && input.planId || null;
@@ -6002,9 +6001,9 @@ var init_teammate_idle = __esm({
 });
 
 // src/hooks/prompt-state.ts
-import * as fs12 from "node:fs";
-import * as path12 from "node:path";
-import { homedir as homedir10 } from "node:os";
+import * as fs13 from "node:fs";
+import * as path13 from "node:path";
+import { homedir as homedir11 } from "node:os";
 function defaultState() {
   return { workspaces: {} };
 }
@@ -6013,13 +6012,13 @@ function nowIso() {
 }
 function ensureStateDir() {
   try {
-    fs12.mkdirSync(path12.dirname(STATE_PATH), { recursive: true });
+    fs13.mkdirSync(path13.dirname(STATE_PATH), { recursive: true });
   } catch {
   }
 }
 function normalizePath(input) {
   try {
-    return path12.resolve(input);
+    return path13.resolve(input);
   } catch {
     return input;
   }
@@ -6027,11 +6026,11 @@ function normalizePath(input) {
 function workspacePathsMatch(a, b) {
   const left = normalizePath(a);
   const right = normalizePath(b);
-  return left === right || left.startsWith(`${right}${path12.sep}`) || right.startsWith(`${left}${path12.sep}`);
+  return left === right || left.startsWith(`${right}${path13.sep}`) || right.startsWith(`${left}${path13.sep}`);
 }
 function readState() {
   try {
-    const content = fs12.readFileSync(STATE_PATH, "utf8");
+    const content = fs13.readFileSync(STATE_PATH, "utf8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || !parsed.workspaces) {
       return defaultState();
@@ -6044,7 +6043,7 @@ function readState() {
 function writeState(state) {
   try {
     ensureStateDir();
-    fs12.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+    fs13.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), "utf8");
   } catch {
   }
 }
@@ -6062,6 +6061,8 @@ function getOrCreateEntry(state, cwd) {
     require_init: false,
     last_context_at: void 0,
     last_state_change_at: void 0,
+    index_wait_started_at: void 0,
+    index_wait_until: void 0,
     updated_at: nowIso()
   };
   state.workspaces[cwd] = created;
@@ -6100,6 +6101,8 @@ function clearContextRequired(cwd) {
   if (!target) return;
   target.entry.require_context = false;
   target.entry.last_context_at = nowIso();
+  target.entry.index_wait_started_at = void 0;
+  target.entry.index_wait_until = void 0;
   target.entry.updated_at = nowIso();
   writeState(state);
 }
@@ -6160,11 +6163,49 @@ function isContextFreshAndClean(cwd, maxAgeSeconds) {
   }
   return true;
 }
+function startIndexWaitWindow(cwd, waitSeconds) {
+  if (!cwd.trim() || waitSeconds <= 0) return;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  if (!target) return;
+  const now = Date.now();
+  const existingUntil = target.entry.index_wait_until ? new Date(target.entry.index_wait_until).getTime() : NaN;
+  if (!Number.isNaN(existingUntil) && existingUntil > now) {
+    target.entry.updated_at = nowIso();
+    writeState(state);
+    return;
+  }
+  target.entry.index_wait_started_at = new Date(now).toISOString();
+  target.entry.index_wait_until = new Date(now + waitSeconds * 1e3).toISOString();
+  target.entry.updated_at = nowIso();
+  writeState(state);
+}
+function clearIndexWaitWindow(cwd) {
+  if (!cwd.trim()) return;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  if (!target) return;
+  target.entry.index_wait_started_at = void 0;
+  target.entry.index_wait_until = void 0;
+  target.entry.updated_at = nowIso();
+  writeState(state);
+}
+function indexWaitRemainingSeconds(cwd) {
+  if (!cwd.trim()) return null;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  if (!target?.entry.index_wait_until) return null;
+  const until = new Date(target.entry.index_wait_until).getTime();
+  if (Number.isNaN(until)) return null;
+  const remainingMs = until - Date.now();
+  if (remainingMs <= 0) return null;
+  return Math.ceil(remainingMs / 1e3);
+}
 var STATE_PATH;
 var init_prompt_state = __esm({
   "src/hooks/prompt-state.ts"() {
     "use strict";
-    STATE_PATH = path12.join(homedir10(), ".contextstream", "prompt-state.json");
+    STATE_PATH = path13.join(homedir11(), ".contextstream", "prompt-state.json");
   }
 });
 
@@ -6173,9 +6214,9 @@ var pre_tool_use_exports = {};
 __export(pre_tool_use_exports, {
   runPreToolUseHook: () => runPreToolUseHook
 });
-import * as fs13 from "node:fs";
-import * as path13 from "node:path";
-import { homedir as homedir11 } from "node:os";
+import * as fs14 from "node:fs";
+import * as path14 from "node:path";
+import { homedir as homedir12 } from "node:os";
 function isDiscoveryGlob(pattern) {
   const patternLower = pattern.toLowerCase();
   for (const p of DISCOVERY_PATTERNS) {
@@ -6200,23 +6241,50 @@ function isDiscoveryGrep(filePath) {
   }
   return false;
 }
+function configuredIndexWaitSeconds() {
+  const parsed = Number.parseInt(process.env.CONTEXTSTREAM_INDEX_WAIT_SECONDS ?? "", 10);
+  if (Number.isNaN(parsed)) return DEFAULT_INDEX_WAIT_SECONDS;
+  return Math.min(MAX_INDEX_WAIT_SECONDS, Math.max(MIN_INDEX_WAIT_SECONDS, parsed));
+}
+function isLocalDiscoveryToolDuringIndexWait(tool, toolInput) {
+  if (tool === "Glob" || tool === "Explore" || tool === "SemanticSearch" || tool === "codebase_search") {
+    return true;
+  }
+  if (tool === "Task") {
+    const subagentTypeRaw = toolInput?.subagent_type || toolInput?.subagentType || "";
+    return subagentTypeRaw.toLowerCase().includes("explore");
+  }
+  if (tool === "Grep" || tool === "Search" || tool === "grep_search" || tool === "code_search") {
+    const filePath = toolInput?.path || "";
+    return isDiscoveryGrep(filePath);
+  }
+  if (tool === "Read" || tool === "ReadFile" || tool === "read_file") {
+    const filePath = toolInput?.file_path || toolInput?.path || toolInput?.file || toolInput?.target_file || "";
+    return isDiscoveryGrep(filePath);
+  }
+  if (tool === "list_files" || tool === "search_files" || tool === "search_files_content" || tool === "find_files" || tool === "find_by_name") {
+    const pattern = toolInput?.path || toolInput?.regex || toolInput?.pattern || toolInput?.query || "";
+    return !pattern || isDiscoveryGlob(pattern) || isDiscoveryGrep(pattern);
+  }
+  return false;
+}
 function isProjectIndexed(cwd) {
-  if (!fs13.existsSync(INDEX_STATUS_FILE)) {
+  if (!fs14.existsSync(INDEX_STATUS_FILE)) {
     return { isIndexed: false, isStale: false };
   }
   let data;
   try {
-    const content = fs13.readFileSync(INDEX_STATUS_FILE, "utf-8");
+    const content = fs14.readFileSync(INDEX_STATUS_FILE, "utf-8");
     data = JSON.parse(content);
   } catch {
     return { isIndexed: false, isStale: false };
   }
   const projects = data.projects || {};
-  const cwdPath = path13.resolve(cwd);
+  const cwdPath = path14.resolve(cwd);
   for (const [projectPath, info] of Object.entries(projects)) {
     try {
-      const indexedPath = path13.resolve(projectPath);
-      if (cwdPath === indexedPath || cwdPath.startsWith(indexedPath + path13.sep)) {
+      const indexedPath = path14.resolve(projectPath);
+      if (cwdPath === indexedPath || cwdPath.startsWith(indexedPath + path14.sep)) {
         const indexedAt = info.indexed_at;
         if (indexedAt) {
           try {
@@ -6348,7 +6416,7 @@ function blockClaudeCode(message) {
       additionalContext: `[CONTEXTSTREAM] ${message}`
     }
   };
-  fs13.appendFileSync(DEBUG_FILE, `[PreToolUse] REDIRECT (additionalContext): ${JSON.stringify(response)}
+  fs14.appendFileSync(DEBUG_FILE, `[PreToolUse] REDIRECT (additionalContext): ${JSON.stringify(response)}
 `);
   console.log(JSON.stringify(response));
   process.exit(0);
@@ -6405,11 +6473,11 @@ function detectEditorFormat(input) {
   return "claude";
 }
 async function runPreToolUseHook() {
-  fs13.appendFileSync(DEBUG_FILE, `[PreToolUse] Hook invoked at ${(/* @__PURE__ */ new Date()).toISOString()}
+  fs14.appendFileSync(DEBUG_FILE, `[PreToolUse] Hook invoked at ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   console.error("[PreToolUse] Hook invoked at", (/* @__PURE__ */ new Date()).toISOString());
   if (!ENABLED2) {
-    fs13.appendFileSync(DEBUG_FILE, "[PreToolUse] Hook disabled, exiting\n");
+    fs14.appendFileSync(DEBUG_FILE, "[PreToolUse] Hook disabled, exiting\n");
     console.error("[PreToolUse] Hook disabled, exiting");
     process.exit(0);
   }
@@ -6439,7 +6507,7 @@ async function runPreToolUseHook() {
     isContextstreamCall,
     normalizedContextstreamTool
   );
-  fs13.appendFileSync(DEBUG_FILE, `[PreToolUse] tool=${tool}, cwd=${cwd}, editorFormat=${editorFormat}
+  fs14.appendFileSync(DEBUG_FILE, `[PreToolUse] tool=${tool}, cwd=${cwd}, editorFormat=${editorFormat}
 `);
   cleanupStale(180);
   if (isInitRequired(cwd)) {
@@ -6461,21 +6529,31 @@ async function runPreToolUseHook() {
       blockWithMessage(editorFormat, msg);
     }
   }
-  const { isIndexed } = isProjectIndexed(cwd);
-  fs13.appendFileSync(DEBUG_FILE, `[PreToolUse] isIndexed=${isIndexed}
-`);
-  if (!isIndexed) {
-    fs13.appendFileSync(DEBUG_FILE, `[PreToolUse] Project not indexed, allowing
+  const { isIndexed, isStale } = isProjectIndexed(cwd);
+  fs14.appendFileSync(DEBUG_FILE, `[PreToolUse] isIndexed=${isIndexed}, isStale=${isStale}
 `);
+  if (isIndexed && !isStale) {
+    clearIndexWaitWindow(cwd);
+  } else {
+    const waitSeconds = configuredIndexWaitSeconds();
+    if (isLocalDiscoveryToolDuringIndexWait(tool, toolInput)) {
+      startIndexWaitWindow(cwd, waitSeconds);
+      const remaining = indexWaitRemainingSeconds(cwd);
+      if (remaining && remaining > 0) {
+        const msg = `Index refresh grace window is active (${remaining}s remaining). Keep ContextStream search-first flow: mcp__contextstream__search(mode="auto", query="..."). Do not use local discovery tools yet for stale/not-indexed projects. Retry after refresh; local fallback is allowed only after ~${waitSeconds}s if index is still unavailable.`;
+        blockWithMessage(editorFormat, msg);
+      }
+      allowTool(editorFormat, cwd, recordStateChange);
+    }
     allowTool(editorFormat, cwd, recordStateChange);
   }
   if (tool === "Glob") {
     const pattern = toolInput?.pattern || "";
-    fs13.appendFileSync(DEBUG_FILE, `[PreToolUse] Glob pattern=${pattern}, isDiscovery=${isDiscoveryGlob(pattern)}
+    fs14.appendFileSync(DEBUG_FILE, `[PreToolUse] Glob pattern=${pattern}, isDiscovery=${isDiscoveryGlob(pattern)}
 `);
     if (isDiscoveryGlob(pattern)) {
       const msg = `This project index is current. Use mcp__contextstream__search(mode="auto", query="${pattern}") instead of Glob for faster, richer code results.`;
-      fs13.appendFileSync(DEBUG_FILE, `[PreToolUse] Intercepting discovery glob: ${msg}
+      fs14.appendFileSync(DEBUG_FILE, `[PreToolUse] Intercepting discovery glob: ${msg}
 `);
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
@@ -6558,16 +6636,19 @@ async function runPreToolUseHook() {
   }
   allowTool(editorFormat, cwd, recordStateChange);
 }
-var ENABLED2, INDEX_STATUS_FILE, DEBUG_FILE, STALE_THRESHOLD_DAYS, CONTEXT_FRESHNESS_SECONDS, DISCOVERY_PATTERNS, isDirectRun9;
+var ENABLED2, INDEX_STATUS_FILE, DEBUG_FILE, STALE_THRESHOLD_DAYS, CONTEXT_FRESHNESS_SECONDS, DEFAULT_INDEX_WAIT_SECONDS, MIN_INDEX_WAIT_SECONDS, MAX_INDEX_WAIT_SECONDS, DISCOVERY_PATTERNS, isDirectRun9;
 var init_pre_tool_use = __esm({
   "src/hooks/pre-tool-use.ts"() {
     "use strict";
     init_prompt_state();
     ENABLED2 = process.env.CONTEXTSTREAM_HOOK_ENABLED !== "false";
-    INDEX_STATUS_FILE = path13.join(homedir11(), ".contextstream", "indexed-projects.json");
+    INDEX_STATUS_FILE = path14.join(homedir12(), ".contextstream", "indexed-projects.json");
     DEBUG_FILE = "/tmp/pretooluse-hook-debug.log";
     STALE_THRESHOLD_DAYS = 7;
     CONTEXT_FRESHNESS_SECONDS = 120;
+    DEFAULT_INDEX_WAIT_SECONDS = 20;
+    MIN_INDEX_WAIT_SECONDS = 15;
+    MAX_INDEX_WAIT_SECONDS = 20;
     DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"];
     isDirectRun9 = process.argv[1]?.includes("pre-tool-use") || process.argv[2] === "pre-tool-use";
     if (isDirectRun9) {
@@ -6581,17 +6662,17 @@ var user_prompt_submit_exports = {};
 __export(user_prompt_submit_exports, {
   runUserPromptSubmitHook: () => runUserPromptSubmitHook
 });
-import * as fs14 from "node:fs";
-import * as path14 from "node:path";
-import { homedir as homedir12 } from "node:os";
+import * as fs15 from "node:fs";
+import * as path15 from "node:path";
+import { homedir as homedir13 } from "node:os";
 function loadConfigFromMcpJson(cwd) {
-  let searchDir = path14.resolve(cwd);
+  let searchDir = path15.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY2) {
-      const mcpPath = path14.join(searchDir, ".mcp.json");
-      if (fs14.existsSync(mcpPath)) {
+      const mcpPath = path15.join(searchDir, ".mcp.json");
+      if (fs15.existsSync(mcpPath)) {
         try {
-          const content = fs14.readFileSync(mcpPath, "utf-8");
+          const content = fs15.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -6608,10 +6689,10 @@ function loadConfigFromMcpJson(cwd) {
       }
     }
     if (!WORKSPACE_ID || !PROJECT_ID) {
-      const csConfigPath = path14.join(searchDir, ".contextstream", "config.json");
-      if (fs14.existsSync(csConfigPath)) {
+      const csConfigPath = path15.join(searchDir, ".contextstream", "config.json");
+      if (fs15.existsSync(csConfigPath)) {
         try {
-          const content = fs14.readFileSync(csConfigPath, "utf-8");
+          const content = fs15.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id && !WORKSPACE_ID) {
             WORKSPACE_ID = csConfig.workspace_id;
@@ -6623,15 +6704,15 @@ function loadConfigFromMcpJson(cwd) {
         }
       }
     }
-    const parentDir = path14.dirname(searchDir);
+    const parentDir = path15.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY2) {
-    const homeMcpPath = path14.join(homedir12(), ".mcp.json");
-    if (fs14.existsSync(homeMcpPath)) {
+    const homeMcpPath = path15.join(homedir13(), ".mcp.json");
+    if (fs15.existsSync(homeMcpPath)) {
       try {
-        const content = fs14.readFileSync(homeMcpPath, "utf-8");
+        const content = fs15.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -6647,7 +6728,7 @@ function loadConfigFromMcpJson(cwd) {
 }
 function readTranscriptFile(transcriptPath) {
   try {
-    const content = fs14.readFileSync(transcriptPath, "utf-8");
+    const content = fs15.readFileSync(transcriptPath, "utf-8");
     const lines = content.trim().split("\n");
     const messages = [];
     for (const line of lines) {
@@ -6987,23 +7068,22 @@ Returns: \`indexed\` (true/false), \`last_indexed_at\`, \`file_count\`
 \u2192 Use \`search(mode="auto", query="...")\`
 
 **IF indexed=false OR last_indexed_at is stale (>7 days):**
-\u2192 Use local tools (Glob/Grep/Read) directly
-\u2192 OR run \`project(action="index")\` first, then search
+\u2192 Wait up to ~20s for background refresh, retry \`search(mode="auto", query="...")\`
+\u2192 After grace window: local tools are allowed if search still misses
 
-**IF search returns 0 results or errors:**
+**IF search still returns 0 results or errors after retry/window:**
 \u2192 Fallback to local tools (Glob/Grep/Read)
 
 ### \u2705 When Local Tools (Glob/Grep/Read) Are OK:
-- Project is NOT indexed
-- Index is stale/outdated (>7 days)
-- ContextStream search returns 0 results
+- Stale/not-indexed grace window has elapsed (~20s default, configurable)
+- ContextStream search still returns 0 results after retry
 - ContextStream returns errors
 - User explicitly requests local tools
 
 ### On Session Start:
 1. Call \`init(folder_path="...")\` - triggers initial indexing
 2. Check \`project(action="index_status")\` before searching
-3. If not indexed: use local tools OR wait for indexing
+3. If not indexed: wait for background refresh (~20s), retry search, then use local tools only after the grace window
 
 ### After File Changes (Edit/Write/Create):
 Files are NOT auto-indexed. You MUST:
@@ -7138,13 +7218,12 @@ COMMON MEMORY CALLS: list docs via memory(action="list_docs"), list lessons via
 2. FOR CODE SEARCH: Check index status, then search appropriately
    \u26A0\uFE0F BEFORE searching: mcp__contextstream__project(action="index_status")
    \u2705 IF indexed & fresh: Use mcp__contextstream__search(mode="auto", query="...") BEFORE Glob/Grep/Read/Explore/Task/EnterPlanMode
-   \u2705 IF NOT indexed OR stale: Use local tools (Glob/Grep/Read) directly
-   \u2705 IF search returns 0 results: Fallback to local tools (Glob/Grep/Read)
+   \u2705 IF NOT indexed OR stale: wait for background refresh up to ~20s, retry mcp__contextstream__search(mode="auto", query="..."), then allow local tools only after the grace window
+   \u2705 IF search still returns 0 results after retry/window: fallback to local tools (Glob/Grep/Read)
 
 3. WHEN LOCAL TOOLS (Glob/Grep/Read) ARE OK:
-   \u2705 Project is NOT indexed (index_status.indexed=false)
-   \u2705 Index is stale/outdated (>7 days old)
-   \u2705 ContextStream search returns 0 results or errors
+   \u2705 Stale/not-indexed grace window has elapsed (~20s default, configurable)
+   \u2705 ContextStream search still returns 0 results or errors after retry
    \u2705 User explicitly requests local tools
 
 4. FOR PLANS & TASKS: Use ContextStream, not file-based plans
@@ -7190,17 +7269,17 @@ var pre_compact_exports = {};
 __export(pre_compact_exports, {
   runPreCompactHook: () => runPreCompactHook
 });
-import * as fs15 from "node:fs";
-import * as path15 from "node:path";
-import { homedir as homedir13 } from "node:os";
+import * as fs16 from "node:fs";
+import * as path16 from "node:path";
+import { homedir as homedir14 } from "node:os";
 function loadConfigFromMcpJson2(cwd) {
-  let searchDir = path15.resolve(cwd);
+  let searchDir = path16.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY3) {
-      const mcpPath = path15.join(searchDir, ".mcp.json");
-      if (fs15.existsSync(mcpPath)) {
+      const mcpPath = path16.join(searchDir, ".mcp.json");
+      if (fs16.existsSync(mcpPath)) {
         try {
-          const content = fs15.readFileSync(mcpPath, "utf-8");
+          const content = fs16.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -7214,10 +7293,10 @@ function loadConfigFromMcpJson2(cwd) {
       }
     }
     if (!WORKSPACE_ID2) {
-      const csConfigPath = path15.join(searchDir, ".contextstream", "config.json");
-      if (fs15.existsSync(csConfigPath)) {
+      const csConfigPath = path16.join(searchDir, ".contextstream", "config.json");
+      if (fs16.existsSync(csConfigPath)) {
         try {
-          const content = fs15.readFileSync(csConfigPath, "utf-8");
+          const content = fs16.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID2 = csConfig.workspace_id;
@@ -7226,15 +7305,15 @@ function loadConfigFromMcpJson2(cwd) {
         }
       }
     }
-    const parentDir = path15.dirname(searchDir);
+    const parentDir = path16.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY3) {
-    const homeMcpPath = path15.join(homedir13(), ".mcp.json");
-    if (fs15.existsSync(homeMcpPath)) {
+    const homeMcpPath = path16.join(homedir14(), ".mcp.json");
+    if (fs16.existsSync(homeMcpPath)) {
       try {
-        const content = fs15.readFileSync(homeMcpPath, "utf-8");
+        const content = fs16.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -7256,7 +7335,7 @@ function parseTranscript2(transcriptPath) {
   let startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let firstTimestamp = true;
   try {
-    const content = fs15.readFileSync(transcriptPath, "utf-8");
+    const content = fs16.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       if (!line.trim()) continue;
@@ -7457,7 +7536,7 @@ async function runPreCompactHook() {
     messages: [],
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (transcriptPath && fs15.existsSync(transcriptPath)) {
+  if (transcriptPath && fs16.existsSync(transcriptPath)) {
     transcriptData = parseTranscript2(transcriptPath);
   }
   let autoSaveStatus = "";
@@ -7513,17 +7592,17 @@ var post_compact_exports = {};
 __export(post_compact_exports, {
   runPostCompactHook: () => runPostCompactHook
 });
-import * as fs16 from "node:fs";
-import * as path16 from "node:path";
-import { homedir as homedir14 } from "node:os";
+import * as fs17 from "node:fs";
+import * as path17 from "node:path";
+import { homedir as homedir15 } from "node:os";
 function loadConfigFromMcpJson3(cwd) {
-  let searchDir = path16.resolve(cwd);
+  let searchDir = path17.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY4) {
-      const mcpPath = path16.join(searchDir, ".mcp.json");
-      if (fs16.existsSync(mcpPath)) {
+      const mcpPath = path17.join(searchDir, ".mcp.json");
+      if (fs17.existsSync(mcpPath)) {
         try {
-          const content = fs16.readFileSync(mcpPath, "utf-8");
+          const content = fs17.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -7537,10 +7616,10 @@ function loadConfigFromMcpJson3(cwd) {
       }
     }
     if (!WORKSPACE_ID3) {
-      const csConfigPath = path16.join(searchDir, ".contextstream", "config.json");
-      if (fs16.existsSync(csConfigPath)) {
+      const csConfigPath = path17.join(searchDir, ".contextstream", "config.json");
+      if (fs17.existsSync(csConfigPath)) {
         try {
-          const content = fs16.readFileSync(csConfigPath, "utf-8");
+          const content = fs17.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID3 = csConfig.workspace_id;
@@ -7549,15 +7628,15 @@ function loadConfigFromMcpJson3(cwd) {
         }
       }
     }
-    const parentDir = path16.dirname(searchDir);
+    const parentDir = path17.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY4) {
-    const homeMcpPath = path16.join(homedir14(), ".mcp.json");
-    if (fs16.existsSync(homeMcpPath)) {
+    const homeMcpPath = path17.join(homedir15(), ".mcp.json");
+    if (fs17.existsSync(homeMcpPath)) {
       try {
-        const content = fs16.readFileSync(homeMcpPath, "utf-8");
+        const content = fs17.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -7691,17 +7770,17 @@ var session_init_exports = {};
 __export(session_init_exports, {
   runSessionInitHook: () => runSessionInitHook
 });
-import * as fs17 from "node:fs";
-import * as path17 from "node:path";
-import { homedir as homedir15 } from "node:os";
+import * as fs18 from "node:fs";
+import * as path18 from "node:path";
+import { homedir as homedir16 } from "node:os";
 function loadConfigFromMcpJson4(cwd) {
-  let searchDir = path17.resolve(cwd);
+  let searchDir = path18.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY5) {
-      const mcpPath = path17.join(searchDir, ".mcp.json");
-      if (fs17.existsSync(mcpPath)) {
+      const mcpPath = path18.join(searchDir, ".mcp.json");
+      if (fs18.existsSync(mcpPath)) {
         try {
-          const content = fs17.readFileSync(mcpPath, "utf-8");
+          const content = fs18.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -7718,10 +7797,10 @@ function loadConfigFromMcpJson4(cwd) {
       }
     }
     if (!WORKSPACE_ID4 || !PROJECT_ID2) {
-      const csConfigPath = path17.join(searchDir, ".contextstream", "config.json");
-      if (fs17.existsSync(csConfigPath)) {
+      const csConfigPath = path18.join(searchDir, ".contextstream", "config.json");
+      if (fs18.existsSync(csConfigPath)) {
         try {
-          const content = fs17.readFileSync(csConfigPath, "utf-8");
+          const content = fs18.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id && !WORKSPACE_ID4) {
             WORKSPACE_ID4 = csConfig.workspace_id;
@@ -7733,15 +7812,15 @@ function loadConfigFromMcpJson4(cwd) {
         }
       }
     }
-    const parentDir = path17.dirname(searchDir);
+    const parentDir = path18.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY5) {
-    const homeMcpPath = path17.join(homedir15(), ".mcp.json");
-    if (fs17.existsSync(homeMcpPath)) {
+    const homeMcpPath = path18.join(homedir16(), ".mcp.json");
+    if (fs18.existsSync(homeMcpPath)) {
       try {
-        const content = fs17.readFileSync(homeMcpPath, "utf-8");
+        const content = fs18.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -7860,10 +7939,10 @@ function regenerateRuleFiles(folderPath) {
   for (const editor of editors) {
     const rule = generateRuleContent(editor, { mode: "bootstrap" });
     if (!rule) continue;
-    const filePath = path17.join(folderPath, rule.filename);
-    if (!fs17.existsSync(filePath)) continue;
+    const filePath = path18.join(folderPath, rule.filename);
+    if (!fs18.existsSync(filePath)) continue;
     try {
-      const existing = fs17.readFileSync(filePath, "utf8");
+      const existing = fs18.readFileSync(filePath, "utf8");
       const startIdx = existing.indexOf(CONTEXTSTREAM_START_MARKER3);
       const endIdx = existing.indexOf(CONTEXTSTREAM_END_MARKER3);
       if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) continue;
@@ -7873,7 +7952,7 @@ function regenerateRuleFiles(folderPath) {
 ${rule.content.trim()}
 ${CONTEXTSTREAM_END_MARKER3}`;
       const merged = [before, newBlock, after].filter((p) => p.length > 0).join("\n\n");
-      fs17.writeFileSync(filePath, merged.trim() + "\n", "utf8");
+      fs18.writeFileSync(filePath, merged.trim() + "\n", "utf8");
       updated++;
     } catch {
     }
@@ -7995,17 +8074,17 @@ var session_end_exports = {};
 __export(session_end_exports, {
   runSessionEndHook: () => runSessionEndHook
 });
-import * as fs18 from "node:fs";
-import * as path18 from "node:path";
-import { homedir as homedir16 } from "node:os";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
+import { homedir as homedir17 } from "node:os";
 function loadConfigFromMcpJson5(cwd) {
-  let searchDir = path18.resolve(cwd);
+  let searchDir = path19.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY6) {
-      const mcpPath = path18.join(searchDir, ".mcp.json");
-      if (fs18.existsSync(mcpPath)) {
+      const mcpPath = path19.join(searchDir, ".mcp.json");
+      if (fs19.existsSync(mcpPath)) {
         try {
-          const content = fs18.readFileSync(mcpPath, "utf-8");
+          const content = fs19.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -8019,10 +8098,10 @@ function loadConfigFromMcpJson5(cwd) {
       }
     }
     if (!WORKSPACE_ID5 || !PROJECT_ID3) {
-      const csConfigPath = path18.join(searchDir, ".contextstream", "config.json");
-      if (fs18.existsSync(csConfigPath)) {
+      const csConfigPath = path19.join(searchDir, ".contextstream", "config.json");
+      if (fs19.existsSync(csConfigPath)) {
         try {
-          const content = fs18.readFileSync(csConfigPath, "utf-8");
+          const content = fs19.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id && !WORKSPACE_ID5) {
             WORKSPACE_ID5 = csConfig.workspace_id;
@@ -8034,15 +8113,15 @@ function loadConfigFromMcpJson5(cwd) {
         }
       }
     }
-    const parentDir = path18.dirname(searchDir);
+    const parentDir = path19.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY6) {
-    const homeMcpPath = path18.join(homedir16(), ".mcp.json");
-    if (fs18.existsSync(homeMcpPath)) {
+    const homeMcpPath = path19.join(homedir17(), ".mcp.json");
+    if (fs19.existsSync(homeMcpPath)) {
       try {
-        const content = fs18.readFileSync(homeMcpPath, "utf-8");
+        const content = fs19.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -8065,11 +8144,11 @@ function parseTranscriptStats(transcriptPath) {
     messages: [],
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (!transcriptPath || !fs18.existsSync(transcriptPath)) {
+  if (!transcriptPath || !fs19.existsSync(transcriptPath)) {
     return stats;
   }
   try {
-    const content = fs18.readFileSync(transcriptPath, "utf-8");
+    const content = fs19.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
     let firstTimestamp = null;
     let lastTimestamp = null;
@@ -8427,9 +8506,9 @@ __export(verify_key_exports, {
   runVerifyKey: () => runVerifyKey,
   validateApiKey: () => validateApiKey
 });
-import * as fs19 from "node:fs";
-import * as path19 from "node:path";
-import { homedir as homedir17 } from "node:os";
+import * as fs20 from "node:fs";
+import * as path20 from "node:path";
+import { homedir as homedir18 } from "node:os";
 function maskApiKey2(key) {
   if (!key || key.length < 8) return "***";
   const prefixMatch = key.match(/^([a-z]{2,3}_)/i);
@@ -8462,11 +8541,11 @@ function extractFromMcpConfig(config) {
 function getClaudeDesktopConfigPath() {
   const platform2 = process.platform;
   if (platform2 === "darwin") {
-    return path19.join(homedir17(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return path20.join(homedir18(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   } else if (platform2 === "win32") {
-    return path19.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+    return path20.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
   } else {
-    return path19.join(homedir17(), ".config", "Claude", "claude_desktop_config.json");
+    return path20.join(homedir18(), ".config", "Claude", "claude_desktop_config.json");
   }
 }
 function loadApiKey() {
@@ -8483,10 +8562,10 @@ function loadApiKey() {
   }
   let searchDir = process.cwd();
   for (let i = 0; i < 5; i++) {
-    const projectMcpPath = path19.join(searchDir, ".mcp.json");
-    if (fs19.existsSync(projectMcpPath)) {
+    const projectMcpPath = path20.join(searchDir, ".mcp.json");
+    if (fs20.existsSync(projectMcpPath)) {
       try {
-        const content = fs19.readFileSync(projectMcpPath, "utf-8");
+        const content = fs20.readFileSync(projectMcpPath, "utf-8");
         const config = JSON.parse(content);
         const extracted = extractFromMcpConfig(config);
         if (extracted.apiKey) {
@@ -8500,14 +8579,14 @@ function loadApiKey() {
       } catch {
       }
     }
-    const parentDir = path19.dirname(searchDir);
+    const parentDir = path20.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  const globalMcpPath = path19.join(homedir17(), ".mcp.json");
-  if (fs19.existsSync(globalMcpPath)) {
+  const globalMcpPath = path20.join(homedir18(), ".mcp.json");
+  if (fs20.existsSync(globalMcpPath)) {
     try {
-      const content = fs19.readFileSync(globalMcpPath, "utf-8");
+      const content = fs20.readFileSync(globalMcpPath, "utf-8");
       const config = JSON.parse(content);
       const extracted = extractFromMcpConfig(config);
       if (extracted.apiKey) {
@@ -8522,13 +8601,13 @@ function loadApiKey() {
     }
   }
   const cursorPaths = [
-    path19.join(process.cwd(), ".cursor", "mcp.json"),
-    path19.join(homedir17(), ".cursor", "mcp.json")
+    path20.join(process.cwd(), ".cursor", "mcp.json"),
+    path20.join(homedir18(), ".cursor", "mcp.json")
   ];
   for (const cursorPath of cursorPaths) {
-    if (fs19.existsSync(cursorPath)) {
+    if (fs20.existsSync(cursorPath)) {
       try {
-        const content = fs19.readFileSync(cursorPath, "utf-8");
+        const content = fs20.readFileSync(cursorPath, "utf-8");
         const config = JSON.parse(content);
         const extracted = extractFromMcpConfig(config);
         if (extracted.apiKey) {
@@ -8544,9 +8623,9 @@ function loadApiKey() {
     }
   }
   const claudeDesktopPath = getClaudeDesktopConfigPath();
-  if (fs19.existsSync(claudeDesktopPath)) {
+  if (fs20.existsSync(claudeDesktopPath)) {
     try {
-      const content = fs19.readFileSync(claudeDesktopPath, "utf-8");
+      const content = fs20.readFileSync(claudeDesktopPath, "utf-8");
       const config = JSON.parse(content);
       const extracted = extractFromMcpConfig(config);
       if (extracted.apiKey) {
@@ -8561,14 +8640,14 @@ function loadApiKey() {
     }
   }
   const vscodePaths = [
-    path19.join(homedir17(), ".vscode", "mcp.json"),
-    path19.join(homedir17(), ".codeium", "windsurf", "mcp_config.json"),
-    path19.join(homedir17(), ".continue", "config.json")
+    path20.join(homedir18(), ".vscode", "mcp.json"),
+    path20.join(homedir18(), ".codeium", "windsurf", "mcp_config.json"),
+    path20.join(homedir18(), ".continue", "config.json")
   ];
   for (const vsPath of vscodePaths) {
-    if (fs19.existsSync(vsPath)) {
+    if (fs20.existsSync(vsPath)) {
       try {
-        const content = fs19.readFileSync(vsPath, "utf-8");
+        const content = fs20.readFileSync(vsPath, "utf-8");
         const config = JSON.parse(content);
         const extracted = extractFromMcpConfig(config);
         if (extracted.apiKey) {
@@ -8583,10 +8662,10 @@ function loadApiKey() {
       }
     }
   }
-  const credentialsPath = path19.join(homedir17(), ".contextstream", "credentials.json");
-  if (fs19.existsSync(credentialsPath)) {
+  const credentialsPath = path20.join(homedir18(), ".contextstream", "credentials.json");
+  if (fs20.existsSync(credentialsPath)) {
     try {
-      const content = fs19.readFileSync(credentialsPath, "utf-8");
+      const content = fs20.readFileSync(credentialsPath, "utf-8");
       const creds = JSON.parse(content);
       if (creds.api_key) {
         apiKey = creds.api_key;
@@ -9184,8 +9263,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path20, errorMaps, issueData } = params;
-  const fullPath = [...path20, ...issueData.path || []];
+  const { data, path: path21, errorMaps, issueData } = params;
+  const fullPath = [...path21, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -9301,11 +9380,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path20, key) {
+  constructor(parent, value, path21, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path20;
+    this._path = path21;
     this._key = key;
   }
   get path() {
@@ -12874,12 +12953,12 @@ var BASE_DELAY = 1e3;
 async function sleep(ms) {
   return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
-async function request(config, path20, options = {}) {
+async function request(config, path21, options = {}) {
   const { apiUrl, userAgent } = config;
   const authOverride = getAuthOverride();
   const apiKey = authOverride?.apiKey ?? config.apiKey;
   const jwt = authOverride?.jwt ?? config.jwt;
-  const rawPath = path20.startsWith("/") ? path20 : `/${path20}`;
+  const rawPath = path21.startsWith("/") ? path21 : `/${path21}`;
   const apiPath = rawPath.startsWith("/api/") ? rawPath : `/api/v1${rawPath}`;
   const unauthenticatedEndpoints = ["/api/v1/auth/device/start", "/api/v1/auth/device/token"];
   const isUnauthenticatedEndpoint = unauthenticatedEndpoints.some(
@@ -13034,9 +13113,9 @@ function extractErrorCode(payload) {
   if (typeof payload.code === "string" && payload.code.trim()) return payload.code.trim();
   return null;
 }
-function detectIntegrationProvider(path20) {
-  if (/\/github(\/|$)/i.test(path20)) return "github";
-  if (/\/slack(\/|$)/i.test(path20)) return "slack";
+function detectIntegrationProvider(path21) {
+  if (/\/github(\/|$)/i.test(path21)) return "github";
+  if (/\/slack(\/|$)/i.test(path21)) return "slack";
   return null;
 }
 function rewriteNotFoundMessage(input) {
@@ -13056,7 +13135,70 @@ import * as fs3 from "fs";
 import * as path3 from "path";
 var CONFIG_DIR = ".contextstream";
 var CONFIG_FILE = "config.json";
+var MODERN_GLOBAL_DIR = ".contextstream";
+var MODERN_GLOBAL_MAPPINGS_FILE = "mappings.json";
 var GLOBAL_MAPPINGS_FILE = ".contextstream-mappings.json";
+function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+function readMappingsFile(filePath) {
+  try {
+    if (!fs3.existsSync(filePath)) return null;
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) {
+      return { mappings: parsed };
+    }
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      const mappings = Array.isArray(obj.mappings) ? obj.mappings : [];
+      const fallback = obj.fallback_workspace && typeof obj.fallback_workspace === "object" ? obj.fallback_workspace : void 0;
+      return { mappings, fallback_workspace: fallback };
+    }
+  } catch (e) {
+    console.error(`Failed to read global mappings from ${filePath}:`, e);
+  }
+  return null;
+}
+function writeMappingsFile(filePath, store) {
+  try {
+    const dir = path3.dirname(filePath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+    fs3.writeFileSync(filePath, JSON.stringify(store, null, 2));
+    return true;
+  } catch (e) {
+    console.error(`Failed to write global mappings to ${filePath}:`, e);
+    return false;
+  }
+}
+function readGlobalStore() {
+  const homeDir = getHomeDir();
+  if (!homeDir) return { mappings: [] };
+  const modernPath = path3.join(homeDir, MODERN_GLOBAL_DIR, MODERN_GLOBAL_MAPPINGS_FILE);
+  const legacyPath = path3.join(homeDir, GLOBAL_MAPPINGS_FILE);
+  const modern = readMappingsFile(modernPath);
+  if (modern) return modern;
+  const legacy = readMappingsFile(legacyPath);
+  if (!legacy) return { mappings: [] };
+  writeMappingsFile(modernPath, legacy);
+  return legacy;
+}
+function writeGlobalStore(store) {
+  const homeDir = getHomeDir();
+  if (!homeDir) return false;
+  const modernPath = path3.join(homeDir, MODERN_GLOBAL_DIR, MODERN_GLOBAL_MAPPINGS_FILE);
+  const legacyPath = path3.join(homeDir, GLOBAL_MAPPINGS_FILE);
+  const okModern = writeMappingsFile(modernPath, store);
+  let okLegacy = true;
+  try {
+    fs3.writeFileSync(legacyPath, JSON.stringify(store.mappings, null, 2));
+  } catch {
+    okLegacy = false;
+  }
+  return okModern && okLegacy;
+}
 function readLocalConfig(repoPath) {
   const configPath = path3.join(repoPath, CONFIG_DIR, CONFIG_FILE);
   try {
@@ -13084,35 +13226,29 @@ function writeLocalConfig(repoPath, config) {
   }
 }
 function readGlobalMappings() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const mappingsPath = path3.join(homeDir, GLOBAL_MAPPINGS_FILE);
-  try {
-    if (fs3.existsSync(mappingsPath)) {
-      const content = fs3.readFileSync(mappingsPath, "utf-8");
-      return JSON.parse(content);
-    }
-  } catch (e) {
-    console.error(`Failed to read global mappings:`, e);
-  }
-  return [];
-}
-function writeGlobalMappings(mappings) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const mappingsPath = path3.join(homeDir, GLOBAL_MAPPINGS_FILE);
-  try {
-    fs3.writeFileSync(mappingsPath, JSON.stringify(mappings, null, 2));
-    return true;
-  } catch (e) {
-    console.error(`Failed to write global mappings:`, e);
-    return false;
-  }
+  return readGlobalStore().mappings;
 }
 function addGlobalMapping(mapping) {
   const normalizedPattern = path3.normalize(mapping.pattern);
-  const mappings = readGlobalMappings();
+  const store = readGlobalStore();
+  const mappings = store.mappings;
   const filtered = mappings.filter((m) => path3.normalize(m.pattern) !== normalizedPattern);
   filtered.push({ ...mapping, pattern: normalizedPattern });
-  return writeGlobalMappings(filtered);
+  return writeGlobalStore({ ...store, mappings: filtered });
+}
+function getGlobalFallbackWorkspace() {
+  return readGlobalStore().fallback_workspace ?? null;
+}
+function setGlobalFallbackWorkspace(fallback) {
+  const store = readGlobalStore();
+  return writeGlobalStore({
+    ...store,
+    fallback_workspace: {
+      workspace_id: fallback.workspace_id,
+      workspace_name: fallback.workspace_name,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
 }
 function findMatchingMapping(repoPath) {
   const mappings = readGlobalMappings();
@@ -13308,6 +13444,12 @@ function extractEventTags(item) {
   return tags;
 }
 function extractEffectiveEventType(item) {
+  const topLevel = item.event_type;
+  const isNormalized = typeof topLevel === "string" && topLevel.trim() === "manual_note";
+  if (isNormalized) {
+    const orig = item.metadata?.original_type;
+    if (typeof orig === "string" && orig.trim()) return orig.trim();
+  }
   for (const field of ["event_type", "node_type", "type"]) {
     const val = item[field];
     if (typeof val === "string" && val.trim()) return val.trim();
@@ -13327,6 +13469,13 @@ function isLessonResult(item) {
   if (content.includes("### Prevention") && content.includes("### Trigger")) return true;
   return false;
 }
+function isDecisionResult(item) {
+  const effectiveType = extractEffectiveEventType(item);
+  if (effectiveType === "decision") return true;
+  const tags = extractEventTags(item);
+  if (tags.includes("decision")) return true;
+  return false;
+}
 function pickString(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -13352,6 +13501,8 @@ var INGEST_BENEFITS = [
   "Allow the AI assistant to find relevant code without manual file navigation",
   "Build a searchable knowledge base of your codebase structure"
 ];
+var GLOBAL_FALLBACK_WORKSPACE_NAME = ".contextstream-global";
+var GLOBAL_FALLBACK_WORKSPACE_DESCRIPTION = "Auto-managed fallback workspace for ad-hoc directories outside explicit project mappings.";
 var AUTO_INDEX_FILE_CAP = 1e4;
 var PROJECT_MARKERS = [
   ".git",
@@ -13367,10 +13518,10 @@ var PROJECT_MARKERS = [
 ];
 function isMultiProjectFolder(folderPath) {
   try {
-    const fs20 = __require("fs");
+    const fs21 = __require("fs");
     const pathModule = __require("path");
-    const rootHasGit = fs20.existsSync(pathModule.join(folderPath, ".git"));
-    const entries = fs20.readdirSync(folderPath, { withFileTypes: true });
+    const rootHasGit = fs21.existsSync(pathModule.join(folderPath, ".git"));
+    const entries = fs21.readdirSync(folderPath, { withFileTypes: true });
     const subdirs = entries.filter(
       (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules"
     );
@@ -13378,7 +13529,7 @@ function isMultiProjectFolder(folderPath) {
     for (const subdir of subdirs) {
       const subdirPath = pathModule.join(folderPath, subdir.name);
       for (const marker of PROJECT_MARKERS) {
-        if (fs20.existsSync(pathModule.join(subdirPath, marker))) {
+        if (fs21.existsSync(pathModule.join(subdirPath, marker))) {
           projectSubdirs.push(subdir.name);
           break;
         }
@@ -13464,6 +13615,39 @@ var ContextStreamClient = class _ContextStreamClient {
     const message = String(error.message || "").toLowerCase();
     return message.includes("deserialize") || message.includes("deserial");
   }
+  async ensureGlobalFallbackWorkspace() {
+    const persisted = getGlobalFallbackWorkspace();
+    if (persisted?.workspace_id) {
+      try {
+        const wsResponse = await this.getWorkspace(persisted.workspace_id);
+        const workspace = unwrapApiResponse(wsResponse);
+        const workspaceId = typeof workspace.id === "string" ? workspace.id : persisted.workspace_id;
+        const workspaceName = typeof workspace.name === "string" && workspace.name.trim() ? workspace.name : persisted.workspace_name || GLOBAL_FALLBACK_WORKSPACE_NAME;
+        setGlobalFallbackWorkspace({
+          workspace_id: workspaceId,
+          workspace_name: workspaceName
+        });
+        return { id: workspaceId, name: workspaceName, source: "global_fallback_cache" };
+      } catch {
+      }
+    }
+    try {
+      const created = await this.createWorkspace({
+        name: GLOBAL_FALLBACK_WORKSPACE_NAME,
+        description: GLOBAL_FALLBACK_WORKSPACE_DESCRIPTION
+      });
+      if (typeof created.id === "string") {
+        const workspaceName = typeof created.name === "string" && created.name.trim() ? created.name : GLOBAL_FALLBACK_WORKSPACE_NAME;
+        setGlobalFallbackWorkspace({
+          workspace_id: created.id,
+          workspace_name: workspaceName
+        });
+        return { id: created.id, name: workspaceName, source: "global_fallback_created" };
+      }
+    } catch {
+    }
+    return null;
+  }
   // Auth
   me() {
     return request(this.config, "/auth/me");
@@ -13638,13 +13822,18 @@ var ContextStreamClient = class _ContextStreamClient {
     uuidSchema.parse(projectId);
     return request(this.config, `/projects/${projectId}/index`, { body: {} });
   }
-  // Search - each method adds required search_type and filters fields
-  // Optional params: context_lines (like grep -C), exact_match_boost (boost for exact matches)
-  searchSemantic(body) {
-    return request(this.config, "/search/semantic", {
+  async searchWithCache(endpoint, searchType, body) {
+    const hintSig = (body.hot_paths_hint?.entries || []).slice(0, 4).map((entry) => `${entry.path}:${entry.score.toFixed(2)}`).join("|");
+    const cacheKey = `${CacheKeys.search(
+      body.query,
+      body.workspace_id
+    )}:${body.project_id || ""}:${searchType}:${body.limit || ""}:${body.offset || ""}:${hintSig}`;
+    const cached = globalCache.get(cacheKey);
+    if (cached) return cached;
+    const result = await request(this.config, endpoint, {
       body: {
         ...this.withDefaults(body),
-        search_type: "semantic",
+        search_type: searchType,
         output_format: body.output_format,
         filters: body.workspace_id ? {} : {
           file_types: [],
@@ -13656,57 +13845,22 @@ var ContextStreamClient = class _ContextStreamClient {
         }
       }
     });
+    globalCache.set(cacheKey, result, CacheTTL.SEARCH);
+    return result;
+  }
+  // Search - each method adds required search_type and filters fields
+  // Optional params: context_lines (like grep -C), exact_match_boost (boost for exact matches)
+  searchSemantic(body) {
+    return this.searchWithCache("/search/semantic", "semantic", body);
   }
   searchHybrid(body) {
-    return request(this.config, "/search/hybrid", {
-      body: {
-        ...this.withDefaults(body),
-        search_type: "hybrid",
-        output_format: body.output_format,
-        filters: body.workspace_id ? {} : {
-          file_types: [],
-          languages: [],
-          file_paths: [],
-          exclude_paths: [],
-          content_types: [],
-          tags: []
-        }
-      }
-    });
+    return this.searchWithCache("/search/hybrid", "hybrid", body);
   }
   searchKeyword(body) {
-    return request(this.config, "/search/keyword", {
-      body: {
-        ...this.withDefaults(body),
-        search_type: "keyword",
-        output_format: body.output_format,
-        filters: body.workspace_id ? {} : {
-          file_types: [],
-          languages: [],
-          file_paths: [],
-          exclude_paths: [],
-          content_types: [],
-          tags: []
-        }
-      }
-    });
+    return this.searchWithCache("/search/keyword", "keyword", body);
   }
   searchPattern(body) {
-    return request(this.config, "/search/pattern", {
-      body: {
-        ...this.withDefaults(body),
-        search_type: "pattern",
-        output_format: body.output_format,
-        filters: body.workspace_id ? {} : {
-          file_types: [],
-          languages: [],
-          file_paths: [],
-          exclude_paths: [],
-          content_types: [],
-          tags: []
-        }
-      }
-    });
+    return this.searchWithCache("/search/pattern", "pattern", body);
   }
   /**
    * Exhaustive search returns ALL matches from the index.
@@ -13714,21 +13868,7 @@ var ContextStreamClient = class _ContextStreamClient {
    * Includes index_freshness to indicate result trustworthiness.
    */
   searchExhaustive(body) {
-    return request(this.config, "/search/exhaustive", {
-      body: {
-        ...this.withDefaults(body),
-        search_type: "exhaustive",
-        output_format: body.output_format,
-        filters: body.workspace_id ? {} : {
-          file_types: [],
-          languages: [],
-          file_paths: [],
-          exclude_paths: [],
-          content_types: [],
-          tags: []
-        }
-      }
-    });
+    return this.searchWithCache("/search/exhaustive", "exhaustive", body);
   }
   /**
    * Refactor search optimized for find-replace operations.
@@ -13736,41 +13876,13 @@ var ContextStreamClient = class _ContextStreamClient {
    * Returns matches grouped by file with line/col positions.
    */
   searchRefactor(body) {
-    return request(this.config, "/search/refactor", {
-      body: {
-        ...this.withDefaults(body),
-        search_type: "refactor",
-        output_format: body.output_format,
-        filters: body.workspace_id ? {} : {
-          file_types: [],
-          languages: [],
-          file_paths: [],
-          exclude_paths: [],
-          content_types: [],
-          tags: []
-        }
-      }
-    });
+    return this.searchWithCache("/search/refactor", "refactor", body);
   }
   /**
    * Crawl search uses deep multi-modal retrieval with a larger candidate pool.
    */
   searchCrawl(body) {
-    return request(this.config, "/search/crawl", {
-      body: {
-        ...this.withDefaults(body),
-        search_type: "crawl",
-        output_format: body.output_format,
-        filters: body.workspace_id ? {} : {
-          file_types: [],
-          languages: [],
-          file_paths: [],
-          exclude_paths: [],
-          content_types: [],
-          tags: []
-        }
-      }
-    });
+    return this.searchWithCache("/search/crawl", "crawl", body);
   }
   // Flash / instruction cache
   async flashBootstrap(params) {
@@ -14709,8 +14821,12 @@ var ContextStreamClient = class _ContextStreamClient {
    * ensuring cross-project decisions and memory are available.
    */
   async initSession(params, ideRoots = []) {
-    let workspaceId = params.workspace_id || this.config.defaultWorkspaceId;
-    let projectId = params.project_id || this.config.defaultProjectId;
+    const explicitWorkspaceId = params.workspace_id;
+    const explicitProjectId = params.project_id;
+    const defaultWorkspaceId = this.config.defaultWorkspaceId;
+    const defaultProjectId = this.config.defaultProjectId;
+    let workspaceId = explicitWorkspaceId || defaultWorkspaceId;
+    let projectId = explicitProjectId || defaultProjectId;
     let workspaceName;
     const context = {
       session_id: params.session_id || randomUUID(),
@@ -14718,102 +14834,90 @@ var ContextStreamClient = class _ContextStreamClient {
     };
     this.sessionStartTime = Date.now();
     const rootPath = ideRoots.length > 0 ? ideRoots[0] : void 0;
-    if (!workspaceId && rootPath) {
+    if (rootPath && !explicitWorkspaceId) {
       const resolved = resolveWorkspace(rootPath);
-      if (resolved.config) {
+      if (resolved.config?.workspace_id) {
+        const previousWorkspaceId = workspaceId;
         workspaceId = resolved.config.workspace_id;
         workspaceName = resolved.config.workspace_name;
-        projectId = resolved.config.project_id || projectId;
+        if (!explicitProjectId && resolved.config.project_id) {
+          projectId = resolved.config.project_id;
+        }
         context.workspace_source = resolved.source;
         context.workspace_resolved_from = resolved.source === "local_config" ? `${rootPath}/.contextstream/config.json` : "parent_folder_mapping";
+        if (previousWorkspaceId && previousWorkspaceId !== workspaceId) {
+          context.workspace_scope_overridden = true;
+          context.workspace_scope_override_reason = "folder mapping takes precedence over cached session defaults";
+        }
+      }
+    }
+    if (!workspaceId && rootPath) {
+      const fallback = await this.ensureGlobalFallbackWorkspace();
+      if (fallback) {
+        workspaceId = fallback.id;
+        workspaceName = fallback.name;
+        context.workspace_source = fallback.source;
+        context.workspace_only_mode = true;
+        context.project_skipped_reason = "No project mapping found for this folder; using global fallback workspace context.";
       } else {
         const folderName = rootPath ? path5.basename(rootPath).toLowerCase() : "";
         try {
           const workspaces = await this.listWorkspaces({ page_size: 50 });
-          if (workspaces.items && workspaces.items.length > 0) {
-            let matchedWorkspace;
-            let matchSource;
-            matchedWorkspace = workspaces.items.find((w) => w.name.toLowerCase() === folderName);
-            if (matchedWorkspace) {
-              matchSource = "workspace_name_exact";
-            }
-            if (!matchedWorkspace) {
-              matchedWorkspace = workspaces.items.find(
-                (w) => w.name.toLowerCase().includes(folderName) || folderName.includes(w.name.toLowerCase())
-              );
-              if (matchedWorkspace) {
-                matchSource = "workspace_name_partial";
-              }
-            }
-            if (!matchedWorkspace) {
-              for (const ws of workspaces.items) {
-                try {
-                  const projects = await this.listProjects({
-                    workspace_id: ws.id,
-                    page_size: 50
-                  });
-                  const matchingProject = projects.items?.find(
-                    (p) => p.name.toLowerCase() === folderName || p.name.toLowerCase().includes(folderName) || folderName.includes(p.name.toLowerCase())
-                  );
-                  if (matchingProject) {
-                    matchedWorkspace = ws;
-                    matchSource = "project_name_match";
-                    projectId = matchingProject.id;
-                    context.project_source = "matched_existing";
-                    break;
-                  }
-                } catch {
-                }
-              }
-            }
-            if (matchedWorkspace) {
-              workspaceId = matchedWorkspace.id;
-              workspaceName = matchedWorkspace.name;
-              context.workspace_source = matchSource;
-              context.workspace_auto_matched = true;
-              writeLocalConfig(rootPath, {
-                workspace_id: matchedWorkspace.id,
-                workspace_name: matchedWorkspace.name,
-                associated_at: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            } else {
-              context.status = "requires_workspace_selection";
-              context.workspace_candidates = workspaces.items.map((w) => ({
-                id: w.id,
-                name: w.name,
-                description: w.description
-              }));
-              context.message = `New folder detected: "${rootPath ? path5.basename(rootPath) : "this folder"}". Please select which workspace this belongs to, or create a new one.`;
-              context.ide_roots = ideRoots;
-              context.folder_name = rootPath ? path5.basename(rootPath) : void 0;
-              return context;
-            }
-          } else {
-            const folderDisplayName = rootPath ? path5.basename(rootPath) || "this folder" : "this folder";
-            context.status = "requires_workspace_name";
-            context.workspace_source = "none_found";
+          const items = Array.isArray(workspaces.items) ? workspaces.items : [];
+          if (items.length > 0) {
+            context.status = "requires_workspace_selection";
+            context.workspace_candidates = items.map((w) => ({
+              id: w.id,
+              name: w.name,
+              description: w.description
+            }));
+            context.message = `New folder detected: "${folderName || "this folder"}". Please select which workspace this belongs to, or create a new one.`;
             context.ide_roots = ideRoots;
-            context.folder_name = folderDisplayName;
-            context.folder_path = rootPath;
-            context.suggested_project_name = folderDisplayName;
-            context.message = `No workspaces found for this account. Ask the user for a name for a new workspace, then create a project for "${folderDisplayName}".`;
+            context.folder_name = rootPath ? path5.basename(rootPath) : void 0;
             return context;
           }
+          context.status = "requires_workspace_name";
+          context.workspace_source = "none_found";
+          context.ide_roots = ideRoots;
+          context.folder_name = rootPath ? path5.basename(rootPath) || "this folder" : "this folder";
+          context.folder_path = rootPath;
+          context.suggested_project_name = context.folder_name;
+          context.message = `No workspaces found for this account and fallback workspace creation failed. Ask the user for a workspace name to continue.`;
+          return context;
         } catch (e) {
           context.workspace_error = String(e);
         }
       }
     }
     if (!workspaceId && !rootPath) {
-      try {
-        const workspaces = await this.listWorkspaces({ page_size: 1 });
-        if (workspaces.items && workspaces.items.length > 0) {
-          workspaceId = workspaces.items[0].id;
-          workspaceName = workspaces.items[0].name;
-          context.workspace_source = "fallback_first";
+      const fallback = await this.ensureGlobalFallbackWorkspace();
+      if (fallback) {
+        workspaceId = fallback.id;
+        workspaceName = fallback.name;
+        context.workspace_source = fallback.source;
+        context.workspace_only_mode = true;
+        context.project_skipped_reason = "No folder context available; using global fallback workspace context.";
+      } else {
+        try {
+          const workspaces = await this.listWorkspaces({ page_size: 1 });
+          if (workspaces.items && workspaces.items.length > 0) {
+            workspaceId = workspaces.items[0].id;
+            workspaceName = workspaces.items[0].name;
+            context.workspace_source = "fallback_first";
+          }
+        } catch (e) {
+          context.workspace_error = String(e);
         }
-      } catch (e) {
-        context.workspace_error = String(e);
+      }
+    }
+    if (!workspaceId && !params.allow_no_workspace) {
+      const fallback = await this.ensureGlobalFallbackWorkspace();
+      if (fallback) {
+        workspaceId = fallback.id;
+        workspaceName = fallback.name;
+        context.workspace_source = fallback.source;
+        context.workspace_only_mode = true;
+        context.project_skipped_reason = "No explicit workspace/project mapping found; using global fallback workspace context.";
       }
     }
     if (!workspaceId && !params.allow_no_workspace) {
@@ -14987,6 +15091,14 @@ var ContextStreamClient = class _ContextStreamClient {
     context.workspace_name = workspaceName;
     context.project_id = projectId;
     context.ide_roots = ideRoots;
+    if (!projectId && workspaceId) {
+      context.workspace_only_mode = true;
+      context.project_scope_hint = {
+        reason: "No project is associated with the current folder context.",
+        create_project_command: rootPath && rootPath.trim() ? `project(action="create", name="${path5.basename(rootPath) || "default-project"}", workspace_id="${workspaceId}", folder_path="${rootPath}")` : `project(action="create", name="default-project", workspace_id="${workspaceId}")`,
+        continue_workspace_only_command: 'context(user_message="...")'
+      };
+    }
     this.sessionProjectId = projectId;
     this.sessionRootPath = rootPath;
     if (!workspaceId) {
@@ -15309,15 +15421,15 @@ var ContextStreamClient = class _ContextStreamClient {
       case "preference":
       case "note":
       case "implementation":
-        apiEventType = "manual_note";
+        apiEventType = params.event_type;
         tags.push(params.event_type);
         break;
-      // Lesson system types - all stored as manual_note with specific tags
+      // Lesson system types — store with original type + lesson_system tag
       case "correction":
       case "lesson":
       case "warning":
       case "frustration":
-        apiEventType = "manual_note";
+        apiEventType = params.event_type;
         tags.push(params.event_type);
         if (!tags.includes("lesson_system")) {
           tags.push("lesson_system");
@@ -15784,9 +15896,9 @@ var ContextStreamClient = class _ContextStreamClient {
           candidateParts.push("## Relevant Code\n");
           currentChars += 18;
           const codeEntries = code.results.map((c) => {
-            const path20 = c.file_path || "file";
+            const path21 = c.file_path || "file";
             const content = c.content?.slice(0, 150) || "";
-            return { path: path20, entry: `\u2022 ${path20}: ${content}...
+            return { path: path21, entry: `\u2022 ${path21}: ${content}...
 ` };
           });
           for (const c of codeEntries) {
@@ -16702,7 +16814,7 @@ ${context}`;
     if (!withDefaults.workspace_id) {
       throw new Error("workspace_id is required for integrations status");
     }
-    const result = await request(this.config, `/integrations/workspaces/${withDefaults.workspace_id}/integrations/status`, {
+    const result = await request(this.config, `/integrations/workspaces/${withDefaults.workspace_id}/status`, {
       method: "GET"
     });
     return unwrapApiResponse(result);
@@ -16719,7 +16831,7 @@ ${context}`;
     if (params?.days) query.set("days", String(params.days));
     if (params?.repo) query.set("repo", params.repo);
     const suffix = query.toString() ? `?${query.toString()}` : "";
-    return request(this.config, `/github/summary${suffix}`, { method: "GET" });
+    return request(this.config, `/integrations/workspaces/${withDefaults.workspace_id}/github/summary${suffix}`, { method: "GET" });
   }
   /**
    * Get Slack summary for a workspace
@@ -16733,7 +16845,7 @@ ${context}`;
     if (params?.days) query.set("days", String(params.days));
     if (params?.channel) query.set("channel", params.channel);
     const suffix = query.toString() ? `?${query.toString()}` : "";
-    return request(this.config, `/slack/summary${suffix}`, { method: "GET" });
+    return request(this.config, `/integrations/workspaces/${withDefaults.workspace_id}/slack/summary${suffix}`, { method: "GET" });
   }
   /**
    * Cross-source search across all integrations
@@ -17660,10 +17772,10 @@ ${context}`;
 };
 
 // src/tools.ts
-import * as fs5 from "node:fs";
-import * as path6 from "node:path";
+import * as fs6 from "node:fs";
+import * as path7 from "node:path";
 import { execFile } from "node:child_process";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { promisify as promisify2 } from "node:util";
 init_files();
 init_rules_templates();
@@ -18245,6 +18357,148 @@ function resolveTodoCompletionUpdate(input) {
   };
 }
 
+// src/hot-paths.ts
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
+import { homedir as homedir4 } from "node:os";
+var STORE_VERSION = 1;
+var STORE_DIR = path6.join(homedir4(), ".contextstream");
+var STORE_FILE = path6.join(STORE_DIR, "hot-paths.json");
+var MAX_PATHS_PER_SCOPE = 400;
+var HALF_LIFE_MS = 3 * 24 * 60 * 60 * 1e3;
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function normalizePathKey(input) {
+  return input.replace(/\\/g, "/").trim();
+}
+function toScopeKey(input) {
+  const workspace = input.workspace_id || "none";
+  const project = input.project_id || "none";
+  return `${workspace}:${project}`;
+}
+function signalWeight(signal) {
+  switch (signal) {
+    case "search_result":
+      return 1.8;
+    case "activity_edit":
+      return 1.4;
+    case "activity_focus":
+      return 1.2;
+    case "activity_read":
+    default:
+      return 1;
+  }
+}
+function looksBroadQuery(query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  if (q.length <= 2) return true;
+  if (/^\*+$/.test(q) || q === "all files" || q === "everything") return true;
+  const tokens = q.split(/\s+/).filter(Boolean);
+  return tokens.length > 12;
+}
+var HotPathStore = class {
+  constructor() {
+    this.data = { version: STORE_VERSION, scopes: {} };
+    this.load();
+  }
+  recordPaths(scope, paths, signal) {
+    if (paths.length === 0) return;
+    const now = Date.now();
+    const scopeKey = toScopeKey(scope);
+    const profile = this.ensureScope(scopeKey);
+    const weight = signalWeight(signal);
+    for (const raw of paths) {
+      const pathKey = normalizePathKey(raw);
+      if (!pathKey) continue;
+      const current = profile.paths[pathKey] || { score: 0, last_seen: now, hits: 0 };
+      const decayed = this.decayedScore(current.score, current.last_seen, now);
+      profile.paths[pathKey] = {
+        score: decayed + weight,
+        last_seen: now,
+        hits: current.hits + 1
+      };
+    }
+    profile.updated_at = now;
+    this.pruneScope(profile);
+    this.persist();
+  }
+  buildHint(input) {
+    const scopeKey = toScopeKey(input);
+    const profile = this.data.scopes[scopeKey];
+    if (!profile) return void 0;
+    const now = Date.now();
+    const baseEntries = Object.entries(profile.paths).map(([filePath, entry]) => ({
+      path: filePath,
+      score: this.decayedScore(entry.score, entry.last_seen, now)
+    })).filter((entry) => entry.score > 0.05).sort((a, b) => b.score - a.score);
+    const active = (input.active_paths || []).map(normalizePathKey).filter(Boolean);
+    const merged = /* @__PURE__ */ new Map();
+    for (const entry of baseEntries.slice(0, Math.max(12, input.limit || 8))) {
+      merged.set(entry.path, {
+        path: entry.path,
+        score: Number(entry.score.toFixed(4)),
+        source: "history"
+      });
+    }
+    for (const activePath of active) {
+      const existing = merged.get(activePath);
+      if (existing) {
+        existing.score = Number((existing.score + 0.9).toFixed(4));
+      } else {
+        merged.set(activePath, { path: activePath, score: 0.9, source: "active" });
+      }
+    }
+    const limit = clamp(input.limit ?? 8, 1, 12);
+    const entries = [...merged.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+    if (entries.length === 0) return void 0;
+    const scoreSum = entries.reduce((sum, item) => sum + item.score, 0);
+    const normalized = clamp(scoreSum / (limit * 2.5), 0, 1);
+    const confidencePenalty = looksBroadQuery(input.query) ? 0.55 : 1;
+    const confidence = Number((normalized * confidencePenalty).toFixed(3));
+    return {
+      entries,
+      confidence,
+      generated_at: new Date(now).toISOString(),
+      profile_version: STORE_VERSION
+    };
+  }
+  decayedScore(score, lastSeenMs, nowMs) {
+    const elapsed = Math.max(0, nowMs - lastSeenMs);
+    const decay = Math.pow(0.5, elapsed / HALF_LIFE_MS);
+    return score * decay;
+  }
+  ensureScope(scopeKey) {
+    if (!this.data.scopes[scopeKey]) {
+      this.data.scopes[scopeKey] = { paths: {}, updated_at: Date.now() };
+    }
+    return this.data.scopes[scopeKey];
+  }
+  pruneScope(profile) {
+    const entries = Object.entries(profile.paths);
+    if (entries.length <= MAX_PATHS_PER_SCOPE) return;
+    entries.sort((a, b) => b[1].score - a[1].score).slice(MAX_PATHS_PER_SCOPE).forEach(([key]) => delete profile.paths[key]);
+  }
+  load() {
+    try {
+      if (!fs5.existsSync(STORE_FILE)) return;
+      const parsed = JSON.parse(fs5.readFileSync(STORE_FILE, "utf-8"));
+      if (parsed?.version !== STORE_VERSION || !parsed.scopes) return;
+      this.data = parsed;
+    } catch {
+    }
+  }
+  persist() {
+    try {
+      fs5.mkdirSync(STORE_DIR, { recursive: true });
+      fs5.writeFileSync(STORE_FILE, JSON.stringify(this.data));
+    } catch {
+    }
+  }
+};
+var globalHotPathStore = new HotPathStore();
+
 // src/tools.ts
 var execFileAsync = promisify2(execFile);
 function parseBoolEnvDefault(raw, fallback) {
@@ -18546,17 +18800,17 @@ var CONTEXTSTREAM_END_MARKER = "<!-- END ContextStream -->";
 var RULES_PROJECT_FILES = {
   codex: "AGENTS.md",
   claude: "CLAUDE.md",
-  copilot: path6.join(".github", "copilot-instructions.md"),
+  copilot: path7.join(".github", "copilot-instructions.md"),
   cursor: ".cursorrules",
   cline: ".clinerules",
-  kilo: path6.join(".kilocode", "rules", "contextstream.md"),
-  roo: path6.join(".roo", "rules", "contextstream.md"),
+  kilo: path7.join(".kilocode", "rules", "contextstream.md"),
+  roo: path7.join(".roo", "rules", "contextstream.md"),
   aider: ".aider.conf.yml"
 };
 var RULES_GLOBAL_FILES = {
-  codex: [path6.join(homedir4(), ".codex", "AGENTS.md")],
-  kilo: [path6.join(homedir4(), ".kilocode", "rules", "contextstream.md")],
-  roo: [path6.join(homedir4(), ".roo", "rules", "contextstream.md")]
+  codex: [path7.join(homedir5(), ".codex", "AGENTS.md")],
+  kilo: [path7.join(homedir5(), ".kilocode", "rules", "contextstream.md")],
+  roo: [path7.join(homedir5(), ".roo", "rules", "contextstream.md")]
 };
 var rulesNoticeCache = /* @__PURE__ */ new Map();
 function compareVersions2(v1, v2) {
@@ -18608,7 +18862,7 @@ function resolveRulesCandidatePaths(folderPath, editorKey) {
     if (!folderPath) return;
     const rel = RULES_PROJECT_FILES[key];
     if (rel) {
-      candidates.add(path6.join(folderPath, rel));
+      candidates.add(path7.join(folderPath, rel));
     }
   };
   const addGlobal = (key) => {
@@ -18640,7 +18894,7 @@ function resolveFolderPath(inputPath, sessionManager) {
   const indicators = [".git", "package.json", "Cargo.toml", "pyproject.toml", ".contextstream"];
   const hasIndicator = indicators.some((entry) => {
     try {
-      return fs5.existsSync(path6.join(cwd, entry));
+      return fs6.existsSync(path7.join(cwd, entry));
     } catch {
       return false;
     }
@@ -18659,7 +18913,7 @@ function getRulesNotice(folderPath, clientName) {
     return cached.notice;
   }
   const candidates = resolveRulesCandidatePaths(folderPath, editorKey);
-  const existing = candidates.filter((filePath) => fs5.existsSync(filePath));
+  const existing = candidates.filter((filePath) => fs6.existsSync(filePath));
   if (existing.length === 0) {
     const updateCommand2 = "generate_rules()";
     const notice2 = {
@@ -18681,7 +18935,7 @@ function getRulesNotice(folderPath, clientName) {
   const versions = [];
   for (const filePath of existing) {
     try {
-      const content = fs5.readFileSync(filePath, "utf-8");
+      const content = fs6.readFileSync(filePath, "utf-8");
       const version = extractRulesVersion(content);
       if (!version) {
         filesMissingVersion.push(filePath);
@@ -18873,32 +19127,32 @@ function replaceContextStreamBlock(existing, content) {
   return { content: appended, status: "appended" };
 }
 async function upsertRuleFile(filePath, content, writeMode = "contextstream_block") {
-  await fs5.promises.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs6.promises.mkdir(path7.dirname(filePath), { recursive: true });
   if (writeMode === "full_file") {
     let existing2 = "";
     try {
-      existing2 = await fs5.promises.readFile(filePath, "utf8");
+      existing2 = await fs6.promises.readFile(filePath, "utf8");
     } catch {
     }
-    await fs5.promises.writeFile(filePath, content.trimEnd() + "\n", "utf8");
+    await fs6.promises.writeFile(filePath, content.trimEnd() + "\n", "utf8");
     return existing2 ? "updated" : "created";
   }
   const wrappedContent = wrapWithMarkers(content);
   let existing = "";
   try {
-    existing = await fs5.promises.readFile(filePath, "utf8");
+    existing = await fs6.promises.readFile(filePath, "utf8");
   } catch {
   }
   if (!existing) {
-    await fs5.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
+    await fs6.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "created";
   }
   if (!existing.trim()) {
-    await fs5.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
+    await fs6.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "updated";
   }
   const replaced = replaceContextStreamBlock(existing, content);
-  await fs5.promises.writeFile(filePath, replaced.content, "utf8");
+  await fs6.promises.writeFile(filePath, replaced.content, "utf8");
   return replaced.status;
 }
 async function writeEditorRules(options) {
@@ -18917,8 +19171,8 @@ async function writeEditorRules(options) {
       continue;
     }
     for (const rule of ruleFiles) {
-      const filePath = path6.join(options.folderPath, rule.filename);
-      if (fs5.existsSync(filePath) && !options.overwriteExisting) {
+      const filePath = path7.join(options.folderPath, rule.filename);
+      if (fs6.existsSync(filePath) && !options.overwriteExisting) {
         results.push({ editor, filename: rule.filename, status: "skipped (exists)" });
         continue;
       }
@@ -18975,7 +19229,7 @@ async function writeGlobalRules(options) {
       continue;
     }
     for (const filePath of globalPaths) {
-      if (fs5.existsSync(filePath) && !options.overwriteExisting) {
+      if (fs6.existsSync(filePath) && !options.overwriteExisting) {
         results.push({ editor, filename: filePath, status: "skipped (exists)", scope: "global" });
         continue;
       }
@@ -19068,9 +19322,9 @@ function humanizeKey(raw) {
   const withSpaces = raw.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ");
   return withSpaces.toLowerCase();
 }
-function buildParamDescription(key, path20) {
+function buildParamDescription(key, path21) {
   const normalized = key in DEFAULT_PARAM_DESCRIPTIONS ? key : key.toLowerCase();
-  const parent = path20[path20.length - 1];
+  const parent = path21[path21.length - 1];
   if (parent === "target") {
     if (key === "id") return "Target identifier (module path, function id, etc.).";
     if (key === "type") return "Target type (module, file, function, type, variable).";
@@ -19101,7 +19355,7 @@ function getDescription(schema) {
   if (def?.description && def.description.trim()) return def.description;
   return void 0;
 }
-function applyParamDescriptions(schema, path20 = []) {
+function applyParamDescriptions(schema, path21 = []) {
   if (!(schema instanceof external_exports.ZodObject)) {
     return schema;
   }
@@ -19112,7 +19366,7 @@ function applyParamDescriptions(schema, path20 = []) {
     let nextField = field;
     const existingDescription = getDescription(field);
     if (field instanceof external_exports.ZodObject) {
-      const nested = applyParamDescriptions(field, [...path20, key]);
+      const nested = applyParamDescriptions(field, [...path21, key]);
       if (nested !== field) {
         nextField = nested;
         changed = true;
@@ -19124,7 +19378,7 @@ function applyParamDescriptions(schema, path20 = []) {
         changed = true;
       }
     } else {
-      nextField = nextField.describe(buildParamDescription(key, path20));
+      nextField = nextField.describe(buildParamDescription(key, path21));
       changed = true;
     }
     nextShape[key] = nextField;
@@ -19773,8 +20027,10 @@ var CONSOLIDATED_TOOLS = /* @__PURE__ */ new Set([
   // Consolidates media indexing, search, and clip retrieval for Remotion/FFmpeg
   "skill",
   // Skill management: list, get, create, update, run, delete, import, export, share
-  "help"
+  "help",
   // Consolidates session_tools, auth_me, mcp_server_version, etc.
+  "vcs"
+  // Version control: status, diff, log, blame, branches, stash_list
 ]);
 function mapToolToConsolidatedDomain(toolName) {
   if (CONSOLIDATED_TOOLS.has(toolName)) return toolName;
@@ -19882,6 +20138,29 @@ function formatContent(data, forceFormat) {
   const usePretty = forceFormat === "pretty" || !forceFormat && !COMPACT_OUTPUT;
   return usePretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
 }
+var GHOST_TITLE_PATTERNS = [
+  /\(No assistant output found/i,
+  /^\s*\(no title\)\s*$/i,
+  /^\s*undefined\s*$/i,
+  /^\s*null\s*$/i
+];
+function sanitizeTitle(title, fallbackPrefix = "Untitled") {
+  if (!title || typeof title !== "string") return `${fallbackPrefix} item`;
+  const trimmed = title.trim();
+  if (!trimmed) return `${fallbackPrefix} item`;
+  for (const pat of GHOST_TITLE_PATTERNS) {
+    if (pat.test(trimmed)) return `${fallbackPrefix} plan`;
+  }
+  return trimmed;
+}
+function sanitizeItemTitles(items, prefix = "Untitled") {
+  return items.map((item) => {
+    if (item && typeof item === "object" && "title" in item) {
+      return { ...item, title: sanitizeTitle(item.title, prefix) };
+    }
+    return item;
+  });
+}
 function toStructured(data) {
   if (data && typeof data === "object" && !Array.isArray(data)) {
     return data;
@@ -20676,6 +20955,16 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
       typeof ctx?.project_id === "string" ? ctx.project_id : void 0
     );
   }
+  function projectScopeRequiredResult(action, workspaceId, folderPath) {
+    const suggestedProjectName = folderPath ? path7.basename(folderPath) || "default-project" : "default-project";
+    const createCommand = workspaceId ? folderPath ? `project(action="create", name="${suggestedProjectName}", workspace_id="${workspaceId}", folder_path="${folderPath}")` : `project(action="create", name="${suggestedProjectName}", workspace_id="${workspaceId}")` : folderPath ? `init(folder_path="${folderPath}")` : `init(folder_path="<your_project_path>")`;
+    const scopeHint = workspaceId ? "Workspace-only fallback is active for this folder, but this action requires a project scope." : "No workspace/project scope is currently resolved for this folder.";
+    return errorResult(
+      `${action} requires a project scope.
+${scopeHint}
+Next step: ${createCommand}`
+    );
+  }
   function isNotFoundError(error) {
     return error instanceof HttpError && error.status === 404;
   }
@@ -20688,6 +20977,53 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
   function appendNote(existing, extra) {
     return existing ? `${existing} ${extra}` : extra;
   }
+  function containsCodeIdentifiers(query) {
+    const tokens = query.split(/\s+/);
+    return tokens.some(
+      (t) => /[A-Z][a-z]/.test(t) || t.includes("_") || t.includes(".") || t.includes("::")
+    );
+  }
+  async function runLocalRipgrep(query, cwd, limit = 10) {
+    try {
+      const pattern = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const { stdout: stdout2 } = await execFileAsync("rg", [
+        "--json",
+        "--max-count",
+        "3",
+        "--max-filesize",
+        "512K",
+        "-i",
+        pattern,
+        cwd
+      ], { timeout: 5e3, maxBuffer: 1024 * 1024 });
+      const results = [];
+      for (const line of stdout2.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.type === "match" && parsed.data) {
+            const filePath = parsed.data.path?.text || "";
+            const lineNum = parsed.data.line_number || 0;
+            const text = parsed.data.lines?.text?.trim() || "";
+            if (filePath && text) {
+              const relative2 = filePath.startsWith(cwd) ? filePath.slice(cwd.length).replace(/^\//, "") : filePath;
+              results.push({
+                file_path: relative2,
+                line: lineNum,
+                content: text.slice(0, 200),
+                score: 0.5
+              });
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+      return results.slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
   function extractSearchEnvelope(result) {
     const data = result?.data ?? result ?? {};
     const results = Array.isArray(data?.results) ? data.results : [];
@@ -20824,6 +21160,12 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
         reason: "Detected identifier-like query; refactor mode is more precise."
       };
     }
+    if (wordCount >= 2 && containsCodeIdentifiers(trimmed)) {
+      return {
+        mode: "hybrid",
+        reason: "Multi-word query contains code identifiers (camelCase/snake_case); hybrid provides better coverage than pure semantic."
+      };
+    }
     if (QUESTION_WORDS.some((w) => lower.startsWith(w)) || trimmed.endsWith("?") || wordCount >= 3) {
       return {
         mode: "semantic",
@@ -21016,11 +21358,11 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
   async function indexedProjectIdForFolder(folderPath) {
     const status = await readIndexStatus();
     const projects = status.projects ?? {};
-    const resolvedFolder = path6.resolve(folderPath);
+    const resolvedFolder = path7.resolve(folderPath);
     let bestMatch;
     for (const [projectPath, info] of Object.entries(projects)) {
-      const resolvedProjectPath = path6.resolve(projectPath);
-      const matches = resolvedFolder === resolvedProjectPath || resolvedFolder.startsWith(`${resolvedProjectPath}${path6.sep}`) || resolvedProjectPath.startsWith(`${resolvedFolder}${path6.sep}`);
+      const resolvedProjectPath = path7.resolve(projectPath);
+      const matches = resolvedFolder === resolvedProjectPath || resolvedFolder.startsWith(`${resolvedProjectPath}${path7.sep}`) || resolvedProjectPath.startsWith(`${resolvedFolder}${path7.sep}`);
       if (!matches) continue;
       if (!info?.indexed_at) continue;
       const indexedAt = new Date(info.indexed_at);
@@ -21050,7 +21392,15 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
       case "exhaustive":
         return client.searchExhaustive(params);
       case "refactor":
-        return client.searchRefactor(params);
+        try {
+          return await client.searchRefactor(params);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("404") || msg.includes("not found") || msg.includes("Not Found")) {
+            return client.searchKeyword(params);
+          }
+          throw err;
+        }
       case "crawl":
         return client.searchCrawl(params);
       default:
@@ -21058,10 +21408,10 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
     }
   }
   async function validateReadableDirectory(inputPath) {
-    const resolvedPath = path6.resolve(inputPath);
+    const resolvedPath = path7.resolve(inputPath);
     let stats;
     try {
-      stats = await fs5.promises.stat(resolvedPath);
+      stats = await fs6.promises.stat(resolvedPath);
     } catch (error) {
       if (error?.code === "ENOENT") {
         return { ok: false, error: `Error: path does not exist: ${inputPath}` };
@@ -21075,7 +21425,7 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
       return { ok: false, error: `Error: path is not a directory: ${inputPath}` };
     }
     try {
-      await fs5.promises.access(resolvedPath, fs5.constants.R_OK | fs5.constants.X_OK);
+      await fs6.promises.access(resolvedPath, fs6.constants.R_OK | fs6.constants.X_OK);
     } catch (error) {
       return {
         ok: false,
@@ -22077,17 +22427,17 @@ Access: Free`,
       let rulesSkipped = [];
       if (input.folder_path && projectData.id) {
         try {
-          const configDir = path6.join(input.folder_path, ".contextstream");
-          const configPath = path6.join(configDir, "config.json");
-          if (!fs5.existsSync(configDir)) {
-            fs5.mkdirSync(configDir, { recursive: true });
+          const configDir = path7.join(input.folder_path, ".contextstream");
+          const configPath = path7.join(configDir, "config.json");
+          if (!fs6.existsSync(configDir)) {
+            fs6.mkdirSync(configDir, { recursive: true });
           }
           const config = {
             workspace_id: workspaceId,
             project_id: projectData.id,
             project_name: input.name
           };
-          fs5.writeFileSync(configPath, JSON.stringify(config, null, 2));
+          fs6.writeFileSync(configPath, JSON.stringify(config, null, 2));
           if (input.generate_editor_rules) {
             const ruleResults = await writeEditorRules({
               folderPath: input.folder_path,
@@ -22168,9 +22518,9 @@ Access: Free`,
     async (input) => {
       const projectId = resolveProjectId(input.project_id);
       if (!projectId) {
-        return errorResult(
-          "Error: project_id is required. Please call session_init first or provide project_id explicitly."
-        );
+        const folderPath = resolveFolderPath(void 0, sessionManager) || void 0;
+        const workspaceId = resolveWorkspaceId(void 0);
+        return projectScopeRequiredResult("index", workspaceId, folderPath);
       }
       const result = await client.indexProject(projectId);
       return {
@@ -22201,7 +22551,8 @@ Access: Free`,
       content_max_chars: contentMax,
       context_lines: contextLines,
       exact_match_boost: exactMatchBoost,
-      output_format: input.output_format
+      output_format: input.output_format,
+      hot_paths_hint: input.hot_paths_hint
     };
   }
   function getSearchAuthError() {
@@ -23587,7 +23938,7 @@ This does semantic search on the first message. You only need context on subsequ
           formatContent(result)
         ].join("\n");
       } else if (status === "requires_workspace_selection") {
-        const folderName = typeof result.folder_name === "string" ? result.folder_name : typeof input.folder_path === "string" ? path6.basename(input.folder_path) || "this folder" : "this folder";
+        const folderName = typeof result.folder_name === "string" ? result.folder_name : typeof input.folder_path === "string" ? path7.basename(input.folder_path) || "this folder" : "this folder";
         const candidates = Array.isArray(result.workspace_candidates) ? result.workspace_candidates : [];
         const lines = [];
         lines.push(
@@ -23840,7 +24191,7 @@ Behavior:
           "Error: folder_path is required. Provide folder_path or run from a project directory."
         );
       }
-      const folderName = path6.basename(folderPath) || "My Project";
+      const folderName = path7.basename(folderPath) || "My Project";
       let newWorkspace;
       try {
         newWorkspace = await client.createWorkspace({
@@ -26569,9 +26920,22 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             };
           }
           const dispatchMode = mode === "hybrid" ? "hybrid" : mode;
-          let result = await executeSearchMode(dispatchMode, baseParams2);
+          let result;
           let executedMode = dispatchMode;
           let fallbackNote;
+          try {
+            result = await executeSearchMode(dispatchMode, baseParams2);
+          } catch (execError) {
+            const execMsg = execError instanceof Error ? execError.message : String(execError);
+            const isEmbedTimeout = execMsg.toLowerCase().includes("embedding timed out") || execMsg.toLowerCase().includes("embedding timeout");
+            if (isEmbedTimeout && dispatchMode !== "keyword" && dispatchMode !== "exhaustive") {
+              result = await executeSearchMode("keyword", baseParams2);
+              executedMode = "keyword";
+              fallbackNote = `${dispatchMode} mode failed with embedding timeout; fell back to keyword search.`;
+            } else {
+              throw execError;
+            }
+          }
           if (shouldRetrySemanticFallback(input.query, dispatchMode, result)) {
             try {
               const semanticResult = await executeSearchMode("semantic", baseParams2);
@@ -26719,10 +27083,19 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
         };
         let selected;
         let explicitScopeHadNoResults = false;
+        const activePaths = sessionManager?.getActiveFiles?.() || [];
+        const hotPathsHint = globalHotPathStore.buildHint({
+          workspace_id: workspaceId,
+          project_id: explicitProjectId || resolvedFolderProjectId || localIndexProjectId || sessionProjectId,
+          query: input.query,
+          active_paths: activePaths,
+          limit: 8
+        });
         const baseParams = normalizeSearchParams({
           ...input,
           workspace_id: workspaceId,
           project_id: void 0,
+          hot_paths_hint: hotPathsHint,
           output_format: input.output_format || suggestOutputFormat(input.query, requestedMode === "team" ? "hybrid" : requestedMode)
         });
         if (requestedMode === "team") {
@@ -26778,6 +27151,36 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               if (isNotFoundError(error)) {
                 continue;
               }
+              const errMsg = error instanceof Error ? error.message : String(error);
+              const isEmbeddingTimeout = errMsg.toLowerCase().includes("embedding timed out") || errMsg.toLowerCase().includes("embedding timeout");
+              if (isEmbeddingTimeout && requestedMode !== "keyword" && requestedMode !== "exhaustive") {
+                try {
+                  const keywordFallback = await runSearchForMode("keyword", paramsForCandidate);
+                  const kwEnvelope = extractSearchEnvelope(keywordFallback.result);
+                  selected = {
+                    index,
+                    project_id: candidateProjectId,
+                    result: keywordFallback.result,
+                    executedMode: "keyword",
+                    fallbackNote: appendNote(
+                      keywordFallback.fallbackNote,
+                      `${requestedMode} mode failed with embedding timeout; fell back to keyword search.`
+                    )
+                  };
+                  if (kwEnvelope.results.length > 0) break;
+                } catch {
+                  if (!selected) {
+                    selected = {
+                      index,
+                      project_id: candidateProjectId,
+                      result: { data: { results: [], total: 0 } },
+                      executedMode: "keyword",
+                      fallbackNote: "Embedding timed out and keyword fallback also failed."
+                    };
+                  }
+                }
+                continue;
+              }
               throw error;
             }
           }
@@ -26820,7 +27223,32 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
         }
         const docsFallback = requestedMode !== "team" && isDocLookupQuery(input.query) && extractSearchEnvelope(selected.result).results.length === 0 ? await findDocsFallback(workspaceId, candidateProjectIds, input.query, input.limit) : void 0;
         const roundTripMs = Date.now() - startTime;
-        const { results, total } = extractSearchEnvelope(selected.result);
+        let { results, total } = extractSearchEnvelope(selected.result);
+        if (results.length === 0 && folderPath) {
+          const rgResults = await runLocalRipgrep(input.query, folderPath, input.limit || 10);
+          if (rgResults.length > 0) {
+            results = rgResults.map((r) => ({
+              file_path: r.file_path,
+              start_line: r.line,
+              content: r.content,
+              score: r.score,
+              source: "local_ripgrep"
+            }));
+            total = results.length;
+            modeFallbackNote = appendNote(
+              modeFallbackNote,
+              `API search returned no results; found ${results.length} local match(es) via ripgrep.`
+            );
+          }
+        }
+        const resultPaths = results.map((item) => typeof item?.file_path === "string" ? item.file_path : "").filter(Boolean);
+        if (resultPaths.length > 0) {
+          globalHotPathStore.recordPaths(
+            { workspace_id: workspaceId, project_id: selected.project_id || sessionProjectId },
+            resultPaths.slice(0, 20),
+            "search_result"
+          );
+        }
         const lines = [];
         if (SHOW_TIMING) {
           lines.push(`\u2713 ${total} results in ${roundTripMs}ms`);
@@ -26833,6 +27261,14 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
         if (modeFallbackNote) {
           lines.push(modeFallbackNote);
         }
+        if (hotPathsHint?.entries?.length) {
+          lines.push(
+            `Hot-path hint active (${hotPathsHint.entries.length} paths, confidence ${(hotPathsHint.confidence * 100).toFixed(0)}%).`
+          );
+          lines.push(
+            "Hot-path weighting is bounded and additive only; if hotspot paths do not match this query, baseline search ranking is used."
+          );
+        }
         if (results.length > 0) {
           lines.push("");
           results.forEach((r, i) => {
@@ -26863,7 +27299,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               `Use memory(action="get_doc", doc_id="...") to open a specific doc or memory(action="list_docs") to browse more.`
             );
           } else {
-            lines.push("No results found. Try a different query or search mode.");
+            lines.push("No results found. Try a different query, search mode, or broader scope (remove project_id to search workspace-wide).");
             if (isDocLookupQuery(input.query)) {
               lines.push(
                 `This query appears to target saved docs. Try memory(action="list_docs") and then memory(action="get_doc", doc_id="...").`
@@ -26897,6 +27333,20 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             count: docsFallback.docs.length
           };
         }
+        if (hotPathsHint?.entries?.length) {
+          structuredData.hot_path_hint = {
+            active: true,
+            path_count: hotPathsHint.entries.length,
+            confidence: hotPathsHint.confidence,
+            guardrail: "bounded_additive_prior",
+            fallback_behavior: "if no affinity match, baseline ranking remains unchanged"
+          };
+        } else {
+          structuredData.hot_path_hint = {
+            active: false,
+            fallback_behavior: "baseline ranking only"
+          };
+        }
         const resultWithMeta = {
           ...selected.result,
           data: structuredData
@@ -27129,7 +27579,18 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               context_hint: input.query,
               limit: input.limit
             });
-            const lessons = result?.data?.lessons || result?.lessons || [];
+            let lessons = result?.data?.lessons || result?.lessons || [];
+            if (Array.isArray(lessons) && lessons.length > 1) {
+              const seen = /* @__PURE__ */ new Set();
+              lessons = lessons.filter((lesson) => {
+                const key = (lesson.title || "").trim().toLowerCase().replace(/\s+/g, " ");
+                if (!key || seen.has(key)) return false;
+                seen.add(key);
+                return true;
+              });
+              if (result?.data?.lessons) result.data.lessons = lessons;
+              else if (result?.lessons) result.lessons = lessons;
+            }
             const resultWithHint = Array.isArray(lessons) && lessons.length === 0 ? { ...result, hint: getEmptyStateHint("get_lessons") } : result;
             return {
               content: [{ type: "text", text: formatContent(resultWithHint) }]
@@ -27146,8 +27607,11 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               include_related: input.include_related,
               include_decisions: input.include_decisions
             });
-            const recallResults = result?.data?.results || result?.results || [];
-            const recallWithHint = Array.isArray(recallResults) && recallResults.length === 0 ? { ...result, hint: getEmptyStateHint("recall") } : result;
+            const r = result;
+            const recallResults = r?.data?.results || r?.results || [];
+            const memoryResults = r?.memory_results?.data?.results || r?.memory_results?.results || [];
+            const hasAnyResults = Array.isArray(recallResults) && recallResults.length > 0 || Array.isArray(memoryResults) && memoryResults.length > 0;
+            const recallWithHint = hasAnyResults ? result : { ...result, hint: getEmptyStateHint("recall") };
             const outputText = formatContent(recallWithHint);
             trackToolTokenSavings(client, "session_recall", outputText, {
               workspace_id: workspaceId,
@@ -27191,6 +27655,32 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               project_id: projectId,
               max_tokens: input.max_tokens
             });
+            const summaryObj = result;
+            if (summaryObj && (summaryObj.decision_count === 0 || summaryObj.memory_count === 0)) {
+              const events = await client.listMemoryEvents({
+                workspace_id: workspaceId,
+                project_id: projectId,
+                limit: 100
+              }).catch(() => null);
+              if (events?.items && Array.isArray(events.items)) {
+                let decisionCount = 0;
+                let lessonCount = 0;
+                let memoryCount = events.items.length;
+                for (const item of events.items) {
+                  if (isDecisionResult(item)) decisionCount++;
+                  if (isLessonResult(item)) lessonCount++;
+                }
+                if (decisionCount > 0 && summaryObj.decision_count === 0) {
+                  summaryObj.decision_count = decisionCount;
+                }
+                if (summaryObj.memory_count === 0) {
+                  summaryObj.memory_count = memoryCount;
+                }
+                if (lessonCount > 0 && !summaryObj.lesson_count) {
+                  summaryObj.lesson_count = lessonCount;
+                }
+              }
+            }
             const outputText = formatContent(result);
             trackToolTokenSavings(client, "session_summary", outputText, {
               workspace_id: workspaceId,
@@ -27252,16 +27742,43 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             if (!input.query) {
               return errorResult("decision_trace requires: query");
             }
-            const result = await client.decisionTrace({
-              workspace_id: workspaceId,
-              project_id: projectId,
-              query: input.query,
-              include_impact: input.include_impact,
-              limit: input.limit
-            });
-            return {
-              content: [{ type: "text", text: formatContent(result) }]
-            };
+            try {
+              const result = await client.decisionTrace({
+                workspace_id: workspaceId,
+                project_id: projectId,
+                query: input.query,
+                include_impact: input.include_impact,
+                limit: input.limit
+              });
+              return {
+                content: [{ type: "text", text: formatContent(result) }]
+              };
+            } catch (err) {
+              const isTimeout = err?.message?.toLowerCase().includes("timeout") || err?.message?.toLowerCase().includes("embedding timed out");
+              if (!isTimeout) throw err;
+              const events = await client.listMemoryEvents({
+                workspace_id: workspaceId,
+                project_id: projectId,
+                limit: 50
+              }).catch(() => ({ items: [] }));
+              const decisions = (events?.items || []).filter((item) => isDecisionResult(item));
+              const queryLower = input.query.toLowerCase();
+              const matched = decisions.filter((d) => {
+                const text = `${d.title || ""} ${d.content || ""}`.toLowerCase();
+                return queryLower.split(/\s+/).some((w) => w.length > 2 && text.includes(w));
+              }).slice(0, input.limit || 10);
+              return {
+                content: [{
+                  type: "text",
+                  text: formatContent({
+                    decisions: matched,
+                    total: matched.length,
+                    fallback_reason: "embedding_timeout",
+                    hint: "Decision trace fell back to keyword search due to embedding timeout."
+                  })
+                }]
+              };
+            }
           }
           // Plan actions
           case "capture_plan": {
@@ -27336,7 +27853,12 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               is_personal: input.is_personal
             });
             const plans = result?.data?.plans || result?.plans || result?.data?.items || result?.items || [];
-            const resultWithHint = plans.length === 0 ? { ...result, hint: getEmptyStateHint("list_plans") } : result;
+            const sanitized = sanitizeItemTitles(plans, "Untitled");
+            if (result?.data?.plans) result.data.plans = sanitized;
+            else if (result?.plans) result.plans = sanitized;
+            else if (result?.data?.items) result.data.items = sanitized;
+            else if (result?.items) result.items = sanitized;
+            const resultWithHint = sanitized.length === 0 ? { ...result, hint: getEmptyStateHint("list_plans") } : result;
             return {
               content: [{ type: "text", text: formatContent(resultWithHint) }]
             };
@@ -27920,8 +28442,32 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             const result = await client.listMemoryEvents({
               workspace_id: workspaceId,
               project_id: projectId,
-              limit: input.limit
+              limit: input.limit,
+              tags: input.tags,
+              event_type: input.event_type
             });
+            const items = result?.data?.items || result?.items || [];
+            if (Array.isArray(items)) {
+              let filtered = items;
+              if (input.tags && input.tags.length > 0) {
+                const requiredTags = input.tags;
+                filtered = filtered.filter((item) => {
+                  const itemTags = extractEventTags(item);
+                  return requiredTags.every((tag) => itemTags.includes(tag));
+                });
+              }
+              if (input.event_type) {
+                const targetType = input.event_type.toLowerCase();
+                filtered = filtered.filter((item) => {
+                  const effective = extractEffectiveEventType(item).toLowerCase();
+                  return effective === targetType;
+                });
+              }
+              if (filtered.length !== items.length) {
+                if (result?.data?.items) result.data.items = filtered;
+                else if (result?.items) result.items = filtered;
+              }
+            }
             const events = result?.data?.items || result?.items || result?.data || [];
             const resultWithHint = Array.isArray(events) && events.length === 0 ? { ...result, hint: getEmptyStateHint("list_events") } : result;
             return {
@@ -28753,6 +29299,15 @@ ${formatContent({
               limit: input.limit
             });
             const transcripts = result?.data?.items || result?.items || result?.data || [];
+            if (Array.isArray(transcripts)) {
+              for (const t of transcripts) {
+                if (t && (!t.title || /^\s*\(no title\)\s*$/i.test(t.title))) {
+                  const typeStr = t.client_name || t.type || "session";
+                  const dateStr = t.started_at ? new Date(t.started_at).toLocaleDateString() : "unknown date";
+                  t.title = `${typeStr} transcript \u2014 ${dateStr}`;
+                }
+              }
+            }
             const resultWithHint = Array.isArray(transcripts) && transcripts.length === 0 ? { ...result, hint: "No transcripts found. Enable save_exchange in context() calls to save conversations." } : result;
             return {
               content: [{ type: "text", text: formatContent(resultWithHint) }]
@@ -28947,6 +29502,20 @@ ${formatContent({
               project_id: projectId,
               limit: input.limit
             });
+            const graphData = result?.data || result;
+            const graphItems = Array.isArray(graphData) ? graphData : graphData?.items || graphData?.results || [];
+            if (Array.isArray(graphItems) && graphItems.length === 0) {
+              const memFallback = await client.memoryDecisions({
+                workspace_id: workspaceId,
+                project_id: projectId,
+                limit: input.limit
+              }).catch(() => null);
+              if (memFallback) {
+                return {
+                  content: [{ type: "text", text: formatContent(memFallback) }]
+                };
+              }
+            }
             return {
               content: [{ type: "text", text: formatContent(result) }]
             };
@@ -28976,10 +29545,7 @@ ${formatContent({
             };
           }
           case "contradictions": {
-            if (!input.node_id) {
-              return errorResult("contradictions requires: node_id");
-            }
-            const result = await client.findContradictions(input.node_id);
+            const result = input.node_id ? await client.findContradictions(input.node_id) : { contradictions: [], hint: "Pass node_id to check a specific node for contradictions." };
             return {
               content: [{ type: "text", text: formatContent(result) }]
             };
@@ -29059,6 +29625,17 @@ ${formatContent({
         const explicitProjectId = normalizeUuid(input.project_id);
         let projectId = explicitProjectId || resolveProjectId(void 0);
         const folderPath = input.folder_path || input.path || resolveFolderPath(void 0, sessionManager) || void 0;
+        if (folderPath) {
+          const mapping = resolveWorkspace(folderPath);
+          const mappedWorkspaceId = normalizeUuid(mapping.config?.workspace_id);
+          const mappedProjectId = normalizeUuid(mapping.config?.project_id);
+          if (!input.workspace_id && mappedWorkspaceId) {
+            workspaceId = mappedWorkspaceId;
+          }
+          if (!explicitProjectId && mappedProjectId) {
+            projectId = mappedProjectId;
+          }
+        }
         switch (input.action) {
           case "list": {
             const result = await client.listProjects({
@@ -29072,7 +29649,7 @@ ${formatContent({
           }
           case "get": {
             if (!projectId) {
-              return errorResult("get requires: project_id");
+              return projectScopeRequiredResult("get", workspaceId, folderPath);
             }
             const result = await client.getProject(projectId);
             return {
@@ -29094,7 +29671,7 @@ ${formatContent({
           }
           case "update": {
             if (!projectId) {
-              return errorResult("update requires: project_id");
+              return projectScopeRequiredResult("update", workspaceId, folderPath);
             }
             const result = await client.updateProject(projectId, {
               name: input.name,
@@ -29106,7 +29683,7 @@ ${formatContent({
           }
           case "delete": {
             if (!projectId) {
-              return errorResult("delete requires: project_id");
+              return projectScopeRequiredResult("delete", workspaceId, folderPath);
             }
             const result = await client.deleteProject(projectId);
             const normalized = result && typeof result === "object" ? result : {
@@ -29122,7 +29699,7 @@ ${formatContent({
           }
           case "index": {
             if (!projectId) {
-              return errorResult("index requires: project_id");
+              return projectScopeRequiredResult("index", workspaceId, folderPath);
             }
             try {
               const result = await client.indexProject(projectId);
@@ -29171,7 +29748,7 @@ ${formatContent({
           }
           case "overview": {
             if (!projectId) {
-              return errorResult("overview requires: project_id");
+              return projectScopeRequiredResult("overview", workspaceId, folderPath);
             }
             const result = await client.projectOverview(projectId);
             return {
@@ -29180,7 +29757,7 @@ ${formatContent({
           }
           case "statistics": {
             if (!projectId) {
-              return errorResult("statistics requires: project_id");
+              return projectScopeRequiredResult("statistics", workspaceId, folderPath);
             }
             const result = await client.projectStatistics(projectId);
             return {
@@ -29189,7 +29766,7 @@ ${formatContent({
           }
           case "files": {
             if (!projectId) {
-              return errorResult("files requires: project_id");
+              return projectScopeRequiredResult("files", workspaceId, folderPath);
             }
             const result = await client.projectFiles(projectId);
             return {
@@ -29317,7 +29894,7 @@ ${formatContent(response)}` }],
           }
           case "index_history": {
             if (!projectId) {
-              return errorResult("index_history requires: project_id");
+              return projectScopeRequiredResult("index_history", workspaceId, folderPath);
             }
             const result = await client.projectIndexHistory(projectId, {
               machine_id: input.machine_id,
@@ -29360,7 +29937,7 @@ ${formatContent(response)}`
               return errorResult("ingest_local requires: path");
             }
             if (!projectId) {
-              return errorResult("ingest_local requires: project_id");
+              return projectScopeRequiredResult("ingest_local", workspaceId, ingestPath);
             }
             const validPath = await validateReadableDirectory(ingestPath);
             if (!validPath.ok) {
@@ -29413,13 +29990,9 @@ ${formatContent(response)}`
             };
           }
           case "recent_changes": {
-            if (!folderPath) {
-              return errorResult(
-                "recent_changes requires: folder_path (or path). Call init(...) first or pass a repo path explicitly."
-              );
-            }
+            const recentChangesPath = folderPath || process.cwd();
             try {
-              const changes = await getRecentProjectChanges(folderPath, input.limit ?? 10, input.since);
+              const changes = await getRecentProjectChanges(recentChangesPath, input.limit ?? 10, input.since);
               let text = "";
               if (changes.commits.length === 0) {
                 text = "No recent commits found.";
@@ -30420,13 +30993,13 @@ Example workflow:
               );
             }
             if (input.file_path) {
-              const fs20 = await import("fs/promises");
+              const fs21 = await import("fs/promises");
               const pathModule = await import("path");
               const filePath = input.file_path.startsWith("~") ? input.file_path.replace("~", process.env.HOME || "") : input.file_path;
               const resolvedPath = pathModule.resolve(filePath);
               let fileStats;
               try {
-                fileStats = await fs20.stat(resolvedPath);
+                fileStats = await fs21.stat(resolvedPath);
               } catch {
                 return errorResult(`File not found: ${resolvedPath}`);
               }
@@ -30473,7 +31046,7 @@ Example workflow:
                   mime_type: mimeType,
                   tags: input.tags
                 });
-                const fileBuffer = await fs20.readFile(resolvedPath);
+                const fileBuffer = await fs21.readFile(resolvedPath);
                 const uploadResponse = await fetch(uploadInit.upload_url, {
                   method: "PUT",
                   headers: uploadInit.headers,
@@ -30948,6 +31521,93 @@ Each domain tool has an 'action' parameter for specific operations.` : "";
     );
     logDebug(`Consolidated mode: ${CONSOLIDATED_TOOLS.size} domain tools`);
   }
+  registerTool(
+    "vcs",
+    {
+      title: "Version Control",
+      description: `Git version control operations. Actions: status (working tree status), diff (show changes), log (commit history), blame (line-by-line authorship), branches (list branches), stash_list (list stashes).`,
+      inputSchema: external_exports.object({
+        action: external_exports.enum(["status", "diff", "log", "blame", "branches", "stash_list"]).describe("VCS action to perform"),
+        path: external_exports.string().optional().describe("File path for diff/blame (relative to repo root)"),
+        ref: external_exports.string().optional().describe("Git ref (branch, tag, commit) for log/diff"),
+        limit: external_exports.number().optional().describe("Max entries for log (default: 20)"),
+        staged: external_exports.boolean().optional().describe("Show staged changes only (for diff)")
+      })
+    },
+    async (input) => {
+      const cwd = resolveFolderPath(void 0, sessionManager) || process.cwd();
+      const runGit = async (args) => {
+        try {
+          const { stdout: stdout2 } = await execFileAsync("git", args, {
+            cwd,
+            timeout: 1e4,
+            maxBuffer: 512 * 1024
+          });
+          return stdout2.trim();
+        } catch (err) {
+          if (err.stderr?.includes("not a git repository")) {
+            throw new Error("Not a git repository. Run this from a git project directory.");
+          }
+          throw err;
+        }
+      };
+      switch (input.action) {
+        case "status": {
+          const output = await runGit(["status", "--porcelain=v2", "--branch"]);
+          return { content: [{ type: "text", text: output || "Working tree clean." }] };
+        }
+        case "diff": {
+          const args = ["diff"];
+          if (input.staged) args.push("--staged");
+          if (input.ref) args.push(input.ref);
+          if (input.path) args.push("--", input.path);
+          const output = await runGit(args);
+          return { content: [{ type: "text", text: output || "No changes." }] };
+        }
+        case "log": {
+          const limit = input.limit || 20;
+          const args = ["log", `--max-count=${limit}`, "--format=%H %ai %an <%ae>%n  %s", "--no-decorate"];
+          if (input.ref) args.push(input.ref);
+          if (input.path) args.push("--", input.path);
+          const output = await runGit(args);
+          return { content: [{ type: "text", text: output || "No commits." }] };
+        }
+        case "blame": {
+          if (!input.path) return errorResult("blame requires: path");
+          const args = ["blame", "--porcelain", input.path];
+          if (input.ref) args.splice(1, 0, input.ref);
+          const output = await runGit(args);
+          const summaryLines = [];
+          const blameLines = output.split("\n");
+          let currentCommit = "";
+          let currentAuthor = "";
+          let lineNum = 0;
+          for (const line of blameLines) {
+            if (/^[0-9a-f]{40}\s/.test(line)) {
+              const parts = line.split(" ");
+              currentCommit = parts[0].slice(0, 8);
+              lineNum = parseInt(parts[2] || "0", 10);
+            } else if (line.startsWith("author ")) {
+              currentAuthor = line.slice(7);
+            } else if (line.startsWith("	")) {
+              summaryLines.push(`${currentCommit} (${currentAuthor}) L${lineNum}: ${line.slice(1)}`);
+            }
+          }
+          return { content: [{ type: "text", text: summaryLines.join("\n") || output }] };
+        }
+        case "branches": {
+          const output = await runGit(["branch", "-a", "--format=%(refname:short) %(objectname:short) %(subject)"]);
+          return { content: [{ type: "text", text: output || "No branches." }] };
+        }
+        case "stash_list": {
+          const output = await runGit(["stash", "list"]);
+          return { content: [{ type: "text", text: output || "No stashes." }] };
+        }
+        default:
+          return errorResult(`Unknown vcs action: ${input.action}`);
+      }
+    }
+  );
   applyToolSurfaceProfile(activeSurfaceProfile, false);
 }
 function registerLimitedTools(server) {
@@ -31938,8 +32598,8 @@ var SessionManager = class _SessionManager {
   /**
    * Set the folder path hint (can be passed from tools that know the workspace path)
    */
-  setFolderPath(path20) {
-    this.folderPath = path20;
+  setFolderPath(path21) {
+    this.folderPath = path21;
   }
   /**
    * Mark that context_smart has been called in this session.
@@ -32129,7 +32789,7 @@ var SessionManager = class _SessionManager {
     }
     if (this.ideRoots.length === 0) {
       const cwd = process.cwd();
-      const fs20 = await import("fs");
+      const fs21 = await import("fs");
       const projectIndicators = [
         ".git",
         "package.json",
@@ -32139,7 +32799,7 @@ var SessionManager = class _SessionManager {
       ];
       const hasProjectIndicator = projectIndicators.some((f) => {
         try {
-          return fs20.existsSync(`${cwd}/${f}`);
+          return fs21.existsSync(`${cwd}/${f}`);
         } catch {
           return false;
         }
@@ -32342,6 +33002,14 @@ var SessionManager = class _SessionManager {
       const filePath = input.file_path || input.notebook_path || input.path;
       if (filePath && typeof filePath === "string") {
         this.activeFiles.add(filePath);
+        globalHotPathStore.recordPaths(
+          {
+            workspace_id: typeof this.context?.workspace_id === "string" ? this.context.workspace_id : void 0,
+            project_id: typeof this.context?.project_id === "string" ? this.context.project_id : void 0
+          },
+          [filePath],
+          "activity_focus"
+        );
         if (this.activeFiles.size > 30) {
           const arr = Array.from(this.activeFiles);
           this.activeFiles = new Set(arr.slice(-30));
@@ -32734,28 +33402,28 @@ async function runHttpGateway() {
 
 // src/index.ts
 init_version();
-import { existsSync as existsSync15, mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir18 } from "os";
-import { join as join21 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join22 } from "path";
 
 // src/setup.ts
-import * as fs7 from "node:fs/promises";
-import * as path8 from "node:path";
-import { homedir as homedir6 } from "node:os";
+import * as fs8 from "node:fs/promises";
+import * as path9 from "node:path";
+import { homedir as homedir7 } from "node:os";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 init_rules_templates();
 init_version();
 
 // src/credentials.ts
-import * as fs6 from "node:fs/promises";
-import * as path7 from "node:path";
-import { homedir as homedir5 } from "node:os";
+import * as fs7 from "node:fs/promises";
+import * as path8 from "node:path";
+import { homedir as homedir6 } from "node:os";
 function normalizeApiUrl(input) {
   return String(input ?? "").trim().replace(/\/+$/, "");
 }
 function credentialsFilePath() {
-  return path7.join(homedir5(), ".contextstream", "credentials.json");
+  return path8.join(homedir6(), ".contextstream", "credentials.json");
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -32763,7 +33431,7 @@ function isRecord(value) {
 async function readSavedCredentials() {
   const filePath = credentialsFilePath();
   try {
-    const raw = await fs6.readFile(filePath, "utf8");
+    const raw = await fs7.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed)) return null;
     const version = parsed.version;
@@ -32789,7 +33457,7 @@ async function readSavedCredentials() {
 }
 async function writeSavedCredentials(input) {
   const filePath = credentialsFilePath();
-  await fs6.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const existing = await readSavedCredentials();
   const value = {
@@ -32801,9 +33469,9 @@ async function writeSavedCredentials(input) {
     updated_at: now
   };
   const body = JSON.stringify(value, null, 2) + "\n";
-  await fs6.writeFile(filePath, body, { encoding: "utf8", mode: 384 });
+  await fs7.writeFile(filePath, body, { encoding: "utf8", mode: 384 });
   try {
-    await fs6.chmod(filePath, 384);
+    await fs7.chmod(filePath, 384);
   } catch {
   }
   return { path: filePath, value };
@@ -32852,7 +33520,7 @@ function parseNumberList(input, max) {
 }
 async function fileExists(filePath) {
   try {
-    await fs7.stat(filePath);
+    await fs8.stat(filePath);
     return true;
   } catch {
     return false;
@@ -33017,47 +33685,47 @@ function replaceContextStreamBlock2(existing, content) {
   return { content: appended, status: "appended" };
 }
 async function upsertTextFile(filePath, content, _marker) {
-  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs8.mkdir(path9.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   const wrappedContent = wrapWithMarkers2(content);
   if (!exists) {
-    await fs7.writeFile(filePath, wrappedContent + "\n", "utf8");
+    await fs8.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "created";
   }
-  const existing = await fs7.readFile(filePath, "utf8").catch(() => "");
+  const existing = await fs8.readFile(filePath, "utf8").catch(() => "");
   if (!existing.trim()) {
-    await fs7.writeFile(filePath, wrappedContent + "\n", "utf8");
+    await fs8.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "updated";
   }
   const replaced = replaceContextStreamBlock2(existing, content);
-  await fs7.writeFile(filePath, replaced.content, "utf8");
+  await fs8.writeFile(filePath, replaced.content, "utf8");
   return replaced.status;
 }
 function globalRulesPathForEditor(editor) {
-  const home = homedir6();
+  const home = homedir7();
   switch (editor) {
     case "codex":
-      return path8.join(home, ".codex", "AGENTS.md");
+      return path9.join(home, ".codex", "AGENTS.md");
     case "copilot":
       return null;
     case "opencode":
-      return path8.join(home, ".opencode", "AGENTS.md");
+      return path9.join(home, ".opencode", "AGENTS.md");
     case "claude":
-      return path8.join(home, ".claude", "CLAUDE.md");
+      return path9.join(home, ".claude", "CLAUDE.md");
     case "cline":
-      return path8.join(home, "Documents", "Cline", "Rules", "contextstream.md");
+      return path9.join(home, "Documents", "Cline", "Rules", "contextstream.md");
     case "kilo":
-      return path8.join(home, ".kilocode", "rules", "contextstream.md");
+      return path9.join(kiloConfigDir(), "rules", "contextstream.md");
     case "roo":
-      return path8.join(home, ".roo", "rules", "contextstream.md");
+      return path9.join(home, ".roo", "rules", "contextstream.md");
     case "aider":
-      return path8.join(home, ".aider.conf.yml");
+      return path9.join(home, ".aider.conf.yml");
     case "antigravity":
-      return path8.join(home, ".gemini", "GEMINI.md");
+      return path9.join(home, ".gemini", "GEMINI.md");
     case "cursor":
       return null;
     case "windsurf":
-      return path8.join(home, ".codeium", "windsurf", "memories", "global_rules.md");
+      return path9.join(home, ".codeium", "windsurf", "memories", "global_rules.md");
     default:
       return null;
   }
@@ -33069,100 +33737,104 @@ async function anyPathExists(paths) {
   return false;
 }
 async function isCodexInstalled() {
-  const home = homedir6();
+  const home = homedir7();
   const envHome = process.env.CODEX_HOME;
   const candidates = [
     envHome,
-    path8.join(home, ".codex"),
-    path8.join(home, ".codex", "config.toml"),
-    path8.join(home, ".config", "codex")
+    path9.join(home, ".codex"),
+    path9.join(home, ".codex", "config.toml"),
+    path9.join(home, ".config", "codex")
   ].filter((candidate) => Boolean(candidate));
   return anyPathExists(candidates);
 }
 function openCodeConfigPath() {
-  const home = homedir6();
+  const home = homedir7();
   const xdgConfigHome = process.env.XDG_CONFIG_HOME;
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path8.join(home, "AppData", "Roaming");
-    return path8.join(appData, "opencode", "opencode.json");
+    const appData = process.env.APPDATA || path9.join(home, "AppData", "Roaming");
+    return path9.join(appData, "opencode", "opencode.json");
   }
-  const configRoot = xdgConfigHome || path8.join(home, ".config");
-  return path8.join(configRoot, "opencode", "opencode.json");
+  const configRoot = xdgConfigHome || path9.join(home, ".config");
+  return path9.join(configRoot, "opencode", "opencode.json");
 }
 async function isOpenCodeInstalled() {
   const configPath = openCodeConfigPath();
-  const configDir = path8.dirname(configPath);
-  const home = homedir6();
+  const configDir = path9.dirname(configPath);
+  const home = homedir7();
   const candidates = [
     configDir,
     configPath,
-    path8.join(home, ".bun", "bin", "opencode"),
-    path8.join(home, ".local", "bin", "opencode")
+    path9.join(home, ".bun", "bin", "opencode"),
+    path9.join(home, ".local", "bin", "opencode")
   ];
   return anyPathExists(candidates);
 }
 async function isClaudeInstalled() {
-  const home = homedir6();
-  const candidates = [path8.join(home, ".claude"), path8.join(home, ".config", "claude")];
+  const home = homedir7();
+  const candidates = [path9.join(home, ".claude"), path9.join(home, ".config", "claude")];
   const desktopConfig = claudeDesktopConfigPath();
   if (desktopConfig) candidates.push(desktopConfig);
   if (process.platform === "darwin") {
-    candidates.push(path8.join(home, "Library", "Application Support", "Claude"));
+    candidates.push(path9.join(home, "Library", "Application Support", "Claude"));
   } else if (process.platform === "win32") {
     const appData = process.env.APPDATA;
-    if (appData) candidates.push(path8.join(appData, "Claude"));
+    if (appData) candidates.push(path9.join(appData, "Claude"));
   }
   return anyPathExists(candidates);
 }
 async function isClineInstalled() {
-  const home = homedir6();
+  const home = homedir7();
   const candidates = [
-    path8.join(home, "Documents", "Cline"),
-    path8.join(home, ".cline"),
-    path8.join(home, ".config", "cline")
+    path9.join(home, "Documents", "Cline"),
+    path9.join(home, ".cline"),
+    path9.join(home, ".config", "cline")
   ];
   return anyPathExists(candidates);
 }
 async function isCopilotInstalled() {
-  const home = homedir6();
+  const home = homedir7();
   const candidates = [
-    path8.join(home, ".copilot"),
-    path8.join(home, ".config", "github-copilot"),
-    path8.join(home, ".vscode", "extensions", "github.copilot-chat"),
-    path8.join(home, ".vscode", "extensions", "github.copilot")
+    path9.join(home, ".copilot"),
+    path9.join(home, ".config", "github-copilot"),
+    path9.join(home, ".vscode", "extensions", "github.copilot-chat"),
+    path9.join(home, ".vscode", "extensions", "github.copilot")
   ];
   return anyPathExists(candidates);
 }
 async function isKiloInstalled() {
-  const home = homedir6();
-  const candidates = [path8.join(home, ".kilocode"), path8.join(home, ".config", "kilocode")];
+  const home = homedir7();
+  const candidates = [
+    kiloConfigDir(),
+    path9.join(home, ".kilocode"),
+    path9.join(home, ".config", "kilocode")
+  ];
   return anyPathExists(candidates);
 }
 async function isRooInstalled() {
-  const home = homedir6();
-  const candidates = [path8.join(home, ".roo"), path8.join(home, ".config", "roo")];
+  const home = homedir7();
+  const candidates = [path9.join(home, ".roo"), path9.join(home, ".config", "roo")];
   return anyPathExists(candidates);
 }
 async function isAiderInstalled() {
-  const home = homedir6();
-  const candidates = [path8.join(home, ".aider.conf.yml"), path8.join(home, ".config", "aider")];
+  const home = homedir7();
+  const candidates = [path9.join(home, ".aider.conf.yml"), path9.join(home, ".config", "aider")];
   return anyPathExists(candidates);
 }
 async function isCursorInstalled() {
-  const home = homedir6();
-  const candidates = [path8.join(home, ".cursor")];
+  const home = homedir7();
+  const candidates = [path9.join(home, ".cursor")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Cursor.app");
-    candidates.push(path8.join(home, "Applications", "Cursor.app"));
-    candidates.push(path8.join(home, "Library", "Application Support", "Cursor"));
+    candidates.push(path9.join(home, "Applications", "Cursor.app"));
+    candidates.push(path9.join(home, "Library", "Application Support", "Cursor"));
   } else if (process.platform === "win32") {
     const localApp = process.env.LOCALAPPDATA;
     const programFiles = process.env.ProgramFiles;
     const programFilesX86 = process.env["ProgramFiles(x86)"];
-    if (localApp) candidates.push(path8.join(localApp, "Programs", "Cursor", "Cursor.exe"));
-    if (localApp) candidates.push(path8.join(localApp, "Cursor", "Cursor.exe"));
-    if (programFiles) candidates.push(path8.join(programFiles, "Cursor", "Cursor.exe"));
-    if (programFilesX86) candidates.push(path8.join(programFilesX86, "Cursor", "Cursor.exe"));
+    if (localApp) candidates.push(path9.join(localApp, "Programs", "Cursor", "Cursor.exe"));
+    if (localApp) candidates.push(path9.join(localApp, "Cursor", "Cursor.exe"));
+    if (programFiles) candidates.push(path9.join(programFiles, "Cursor", "Cursor.exe"));
+    if (programFilesX86) candidates.push(path9.join(programFilesX86, "Cursor", "Cursor.exe"));
   } else {
     candidates.push("/usr/bin/cursor");
     candidates.push("/usr/local/bin/cursor");
@@ -33172,20 +33844,20 @@ async function isCursorInstalled() {
   return anyPathExists(candidates);
 }
 async function isWindsurfInstalled() {
-  const home = homedir6();
-  const candidates = [path8.join(home, ".codeium", "windsurf")];
+  const home = homedir7();
+  const candidates = [path9.join(home, ".codeium", "windsurf")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Windsurf.app");
-    candidates.push(path8.join(home, "Applications", "Windsurf.app"));
-    candidates.push(path8.join(home, "Library", "Application Support", "Windsurf"));
+    candidates.push(path9.join(home, "Applications", "Windsurf.app"));
+    candidates.push(path9.join(home, "Library", "Application Support", "Windsurf"));
   } else if (process.platform === "win32") {
     const localApp = process.env.LOCALAPPDATA;
     const programFiles = process.env.ProgramFiles;
     const programFilesX86 = process.env["ProgramFiles(x86)"];
-    if (localApp) candidates.push(path8.join(localApp, "Programs", "Windsurf", "Windsurf.exe"));
-    if (localApp) candidates.push(path8.join(localApp, "Windsurf", "Windsurf.exe"));
-    if (programFiles) candidates.push(path8.join(programFiles, "Windsurf", "Windsurf.exe"));
-    if (programFilesX86) candidates.push(path8.join(programFilesX86, "Windsurf", "Windsurf.exe"));
+    if (localApp) candidates.push(path9.join(localApp, "Programs", "Windsurf", "Windsurf.exe"));
+    if (localApp) candidates.push(path9.join(localApp, "Windsurf", "Windsurf.exe"));
+    if (programFiles) candidates.push(path9.join(programFiles, "Windsurf", "Windsurf.exe"));
+    if (programFilesX86) candidates.push(path9.join(programFilesX86, "Windsurf", "Windsurf.exe"));
   } else {
     candidates.push("/usr/bin/windsurf");
     candidates.push("/usr/local/bin/windsurf");
@@ -33195,22 +33867,22 @@ async function isWindsurfInstalled() {
   return anyPathExists(candidates);
 }
 async function isAntigravityInstalled() {
-  const home = homedir6();
-  const candidates = [path8.join(home, ".gemini")];
+  const home = homedir7();
+  const candidates = [path9.join(home, ".gemini")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Antigravity.app");
-    candidates.push(path8.join(home, "Applications", "Antigravity.app"));
-    candidates.push(path8.join(home, "Library", "Application Support", "Antigravity"));
+    candidates.push(path9.join(home, "Applications", "Antigravity.app"));
+    candidates.push(path9.join(home, "Library", "Application Support", "Antigravity"));
   } else if (process.platform === "win32") {
     const localApp = process.env.LOCALAPPDATA;
     const programFiles = process.env.ProgramFiles;
     const programFilesX86 = process.env["ProgramFiles(x86)"];
     if (localApp)
-      candidates.push(path8.join(localApp, "Programs", "Antigravity", "Antigravity.exe"));
-    if (localApp) candidates.push(path8.join(localApp, "Antigravity", "Antigravity.exe"));
-    if (programFiles) candidates.push(path8.join(programFiles, "Antigravity", "Antigravity.exe"));
+      candidates.push(path9.join(localApp, "Programs", "Antigravity", "Antigravity.exe"));
+    if (localApp) candidates.push(path9.join(localApp, "Antigravity", "Antigravity.exe"));
+    if (programFiles) candidates.push(path9.join(programFiles, "Antigravity", "Antigravity.exe"));
     if (programFilesX86)
-      candidates.push(path8.join(programFilesX86, "Antigravity", "Antigravity.exe"));
+      candidates.push(path9.join(programFilesX86, "Antigravity", "Antigravity.exe"));
   } else {
     candidates.push("/usr/bin/antigravity");
     candidates.push("/usr/local/bin/antigravity");
@@ -33249,7 +33921,21 @@ async function isEditorInstalled(editor) {
 }
 var IS_WINDOWS = process.platform === "win32";
 var DEFAULT_CONTEXTSTREAM_API_URL = "https://api.contextstream.io";
+var DEFAULT_CONTEXTSTREAM_MCP_URL = "https://mcp.contextstream.io/mcp?default_context_mode=fast";
+var DEFAULT_CONTEXTSTREAM_TOOLSET = "complete";
+var DEFAULT_CONTEXTSTREAM_OUTPUT_FORMAT = "compact";
+var DEFAULT_CONTEXTSTREAM_SEARCH_LIMIT = "15";
+var DEFAULT_CONTEXTSTREAM_SEARCH_MAX_CHARS = "2400";
+var DEFAULT_CONTEXTSTREAM_TRANSCRIPTS_ENABLED = "true";
+var DEFAULT_CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED = "true";
+var VSCODE_MCP_MODE_ENV = "CONTEXTSTREAM_VSCODE_MCP_MODE";
 var OPENCODE_CONFIG_SCHEMA_URL = "https://opencode.ai/config.json";
+var REMOTE_HEADER_TOOLSET = "X-ContextStream-Toolset";
+var REMOTE_HEADER_OUTPUT_FORMAT = "X-ContextStream-Output-Format";
+var REMOTE_HEADER_SEARCH_LIMIT = "X-ContextStream-Search-Limit";
+var REMOTE_HEADER_SEARCH_MAX_CHARS = "X-ContextStream-Search-Max-Chars";
+var REMOTE_HEADER_TRANSCRIPTS_ENABLED = "X-ContextStream-Transcripts-Enabled";
+var REMOTE_HEADER_CONSOLIDATED = "X-ContextStream-Consolidated";
 function escapeTomlString(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
@@ -33258,11 +33944,31 @@ function formatTomlEnvLines(env) {
 }
 function buildSetupEnv(params) {
   const contextPack = params.contextPackEnabled === false ? "false" : "true";
-  return {
+  const env = {
     CONTEXTSTREAM_API_URL: params.apiUrl,
-    CONTEXTSTREAM_API_KEY: params.apiKey,
-    CONTEXTSTREAM_CONTEXT_PACK: contextPack
+    CONTEXTSTREAM_ALLOW_HEADER_AUTH: "false",
+    CONTEXTSTREAM_WORKSPACE_ID: params.workspaceId ?? "",
+    CONTEXTSTREAM_PROJECT_ID: params.projectId ?? "",
+    CONTEXTSTREAM_USER_AGENT: `contextstream-mcp/${VERSION}`,
+    CONTEXTSTREAM_TOOLSET: DEFAULT_CONTEXTSTREAM_TOOLSET,
+    CONTEXTSTREAM_LOG_LEVEL: "quiet",
+    CONTEXTSTREAM_OUTPUT_FORMAT: DEFAULT_CONTEXTSTREAM_OUTPUT_FORMAT,
+    CONTEXTSTREAM_CONTEXT_PACK: contextPack,
+    CONTEXTSTREAM_TRANSCRIPTS_ENABLED: DEFAULT_CONTEXTSTREAM_TRANSCRIPTS_ENABLED,
+    CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED: DEFAULT_CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED,
+    CONTEXTSTREAM_SHOW_TIMING: "false",
+    CONTEXTSTREAM_PROGRESSIVE_MODE: "false",
+    CONTEXTSTREAM_ROUTER_MODE: "false",
+    CONTEXTSTREAM_CONSOLIDATED: "true",
+    CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS: "true",
+    CONTEXTSTREAM_SEARCH_LIMIT: DEFAULT_CONTEXTSTREAM_SEARCH_LIMIT,
+    CONTEXTSTREAM_SEARCH_MAX_CHARS: DEFAULT_CONTEXTSTREAM_SEARCH_MAX_CHARS,
+    CONTEXTSTREAM_INCLUDE_STRUCTURED_CONTENT: "true"
   };
+  if (params.apiKey) {
+    env.CONTEXTSTREAM_API_KEY = params.apiKey;
+  }
+  return env;
 }
 function buildContextStreamMcpServer(params) {
   const env = buildSetupEnv(params);
@@ -33279,7 +33985,45 @@ function buildContextStreamMcpServer(params) {
     env
   };
 }
+function resolveVsCodeMcpMode() {
+  const rawValue = process.env[VSCODE_MCP_MODE_ENV]?.trim().toLowerCase();
+  if (rawValue === "remote" || rawValue === "local") {
+    return rawValue;
+  }
+  return "auto";
+}
+function getHostedRemoteMcpUrl() {
+  const override = process.env.CONTEXTSTREAM_MCP_HTTP_URL?.trim();
+  return override || DEFAULT_CONTEXTSTREAM_MCP_URL;
+}
+function buildHostedRemoteHeaders() {
+  return {
+    [REMOTE_HEADER_TOOLSET]: DEFAULT_CONTEXTSTREAM_TOOLSET,
+    [REMOTE_HEADER_OUTPUT_FORMAT]: DEFAULT_CONTEXTSTREAM_OUTPUT_FORMAT,
+    [REMOTE_HEADER_SEARCH_LIMIT]: DEFAULT_CONTEXTSTREAM_SEARCH_LIMIT,
+    [REMOTE_HEADER_SEARCH_MAX_CHARS]: DEFAULT_CONTEXTSTREAM_SEARCH_MAX_CHARS,
+    [REMOTE_HEADER_TRANSCRIPTS_ENABLED]: DEFAULT_CONTEXTSTREAM_TRANSCRIPTS_ENABLED,
+    [REMOTE_HEADER_CONSOLIDATED]: "true"
+  };
+}
+function shouldUseHostedRemoteMcp(apiUrl) {
+  const mode = resolveVsCodeMcpMode();
+  if (mode === "remote") {
+    return true;
+  }
+  if (mode === "local") {
+    return false;
+  }
+  return normalizeApiUrl(apiUrl) === DEFAULT_CONTEXTSTREAM_API_URL;
+}
 function buildContextStreamVsCodeServer(params) {
+  if (shouldUseHostedRemoteMcp(params.apiUrl)) {
+    return {
+      type: "http",
+      url: getHostedRemoteMcpUrl(),
+      headers: buildHostedRemoteHeaders()
+    };
+  }
   const env = buildSetupEnv(params);
   if (IS_WINDOWS) {
     return {
@@ -33298,7 +34042,17 @@ function buildContextStreamVsCodeServer(params) {
 }
 function buildContextStreamOpenCodeEnvironment(params) {
   const environment = {
-    CONTEXTSTREAM_API_KEY: "{env:CONTEXTSTREAM_API_KEY}"
+    CONTEXTSTREAM_API_KEY: "{env:CONTEXTSTREAM_API_KEY}",
+    CONTEXTSTREAM_TOOLSET: DEFAULT_CONTEXTSTREAM_TOOLSET,
+    CONTEXTSTREAM_LOG_LEVEL: "quiet",
+    CONTEXTSTREAM_OUTPUT_FORMAT: DEFAULT_CONTEXTSTREAM_OUTPUT_FORMAT,
+    CONTEXTSTREAM_TRANSCRIPTS_ENABLED: DEFAULT_CONTEXTSTREAM_TRANSCRIPTS_ENABLED,
+    CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED: DEFAULT_CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED,
+    CONTEXTSTREAM_CONSOLIDATED: "true",
+    CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS: "true",
+    CONTEXTSTREAM_SEARCH_LIMIT: DEFAULT_CONTEXTSTREAM_SEARCH_LIMIT,
+    CONTEXTSTREAM_SEARCH_MAX_CHARS: DEFAULT_CONTEXTSTREAM_SEARCH_MAX_CHARS,
+    CONTEXTSTREAM_INCLUDE_STRUCTURED_CONTENT: "true"
   };
   if (normalizeApiUrl(params.apiUrl) !== DEFAULT_CONTEXTSTREAM_API_URL) {
     environment.CONTEXTSTREAM_API_URL = params.apiUrl;
@@ -33316,6 +34070,46 @@ function buildContextStreamOpenCodeLocalServer(params) {
     enabled: true
   };
 }
+function kiloConfigDir() {
+  const home = homedir7();
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path9.join(home, "AppData", "Roaming");
+    return path9.join(appData, "kilo");
+  }
+  return path9.join(home, ".config", "kilo");
+}
+function buildContextStreamKiloServer(params) {
+  const env = buildSetupEnv(params);
+  delete env.CONTEXTSTREAM_API_KEY;
+  return {
+    type: "local",
+    command: ["npx", "-y", "@contextstream/mcp-server@latest"],
+    environment: env,
+    enabled: true
+  };
+}
+async function upsertKiloMcpConfig(filePath, server) {
+  await fs8.mkdir(path9.dirname(filePath), { recursive: true });
+  const exists = await fileExists(filePath);
+  let root = {};
+  if (exists) {
+    const raw = await fs8.readFile(filePath, "utf8").catch(() => "");
+    const parsed = tryParseJsonLike(raw);
+    if (!parsed.ok) throw new Error(`Invalid JSON in ${filePath}: ${parsed.error}`);
+    root = parsed.value;
+  }
+  if (!root || typeof root !== "object" || Array.isArray(root)) root = {};
+  if (!root.mcp || typeof root.mcp !== "object" || Array.isArray(root.mcp)) root.mcp = {};
+  if (!root.instructions) {
+    root.instructions = [".kilo/rules/*.md"];
+  }
+  const before = JSON.stringify(root.mcp.contextstream ?? null);
+  root.mcp.contextstream = server;
+  const after = JSON.stringify(root.mcp.contextstream ?? null);
+  await fs8.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
+  if (!exists) return "created";
+  return before === after ? "skipped" : "updated";
+}
 function stripJsonComments(input) {
   return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
 }
@@ -33335,11 +34129,11 @@ function tryParseJsonLike(raw) {
   }
 }
 async function upsertJsonMcpConfig(filePath, server) {
-  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs8.mkdir(path9.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   let root = {};
   if (exists) {
-    const raw = await fs7.readFile(filePath, "utf8").catch(() => "");
+    const raw = await fs8.readFile(filePath, "utf8").catch(() => "");
     const parsed = tryParseJsonLike(raw);
     if (!parsed.ok) throw new Error(`Invalid JSON in ${filePath}: ${parsed.error}`);
     root = parsed.value;
@@ -33350,16 +34144,16 @@ async function upsertJsonMcpConfig(filePath, server) {
   const before = JSON.stringify(root.mcpServers.contextstream ?? null);
   root.mcpServers.contextstream = server;
   const after = JSON.stringify(root.mcpServers.contextstream ?? null);
-  await fs7.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
+  await fs8.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
   if (!exists) return "created";
   return before === after ? "skipped" : "updated";
 }
 async function upsertJsonVsCodeMcpConfig(filePath, server) {
-  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs8.mkdir(path9.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   let root = {};
   if (exists) {
-    const raw = await fs7.readFile(filePath, "utf8").catch(() => "");
+    const raw = await fs8.readFile(filePath, "utf8").catch(() => "");
     const parsed = tryParseJsonLike(raw);
     if (!parsed.ok) throw new Error(`Invalid JSON in ${filePath}: ${parsed.error}`);
     root = parsed.value;
@@ -33368,18 +34162,29 @@ async function upsertJsonVsCodeMcpConfig(filePath, server) {
   if (!root.servers || typeof root.servers !== "object" || Array.isArray(root.servers))
     root.servers = {};
   const before = JSON.stringify(root.servers.contextstream ?? null);
-  root.servers.contextstream = server;
+  const existingServer = root.servers.contextstream;
+  if (existingServer && typeof existingServer === "object" && !Array.isArray(existingServer) && existingServer.type === "http" && server.type === "http") {
+    root.servers.contextstream = {
+      ...server,
+      headers: {
+        ...server.headers,
+        ...existingServer.headers && typeof existingServer.headers === "object" ? existingServer.headers : {}
+      }
+    };
+  } else {
+    root.servers.contextstream = server;
+  }
   const after = JSON.stringify(root.servers.contextstream ?? null);
-  await fs7.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
+  await fs8.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
   if (!exists) return "created";
   return before === after ? "skipped" : "updated";
 }
 async function upsertOpenCodeMcpConfig(filePath, server) {
-  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs8.mkdir(path9.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   let root = {};
   if (exists) {
-    const raw = await fs7.readFile(filePath, "utf8").catch(() => "");
+    const raw = await fs8.readFile(filePath, "utf8").catch(() => "");
     const parsed = tryParseJsonLike(raw);
     if (!parsed.ok) throw new Error(`Invalid JSON in ${filePath}: ${parsed.error}`);
     root = parsed.value;
@@ -33396,14 +34201,14 @@ async function upsertOpenCodeMcpConfig(filePath, server) {
     schema: root.$schema ?? null,
     contextstream: root.mcp.contextstream ?? null
   });
-  await fs7.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
+  await fs8.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
   if (!exists) return "created";
   return before === after ? "skipped" : "updated";
 }
 function claudeDesktopConfigPath() {
-  const home = homedir6();
+  const home = homedir7();
   if (process.platform === "darwin") {
-    return path8.join(
+    return path9.join(
       home,
       "Library",
       "Application Support",
@@ -33412,18 +34217,18 @@ function claudeDesktopConfigPath() {
     );
   }
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path8.join(home, "AppData", "Roaming");
-    return path8.join(appData, "Claude", "claude_desktop_config.json");
+    const appData = process.env.APPDATA || path9.join(home, "AppData", "Roaming");
+    return path9.join(appData, "Claude", "claude_desktop_config.json");
   }
   if (process.platform === "linux") {
-    return path8.join(home, ".config", "Claude", "claude_desktop_config.json");
+    return path9.join(home, ".config", "Claude", "claude_desktop_config.json");
   }
   return null;
 }
 async function upsertCodexTomlConfig(filePath, params) {
-  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs8.mkdir(path9.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
-  const existing = exists ? await fs7.readFile(filePath, "utf8").catch(() => "") : "";
+  const existing = exists ? await fs8.readFile(filePath, "utf8").catch(() => "") : "";
   const env = buildSetupEnv(params);
   const envLines = formatTomlEnvLines(env);
   const marker = "[mcp_servers.contextstream]";
@@ -33441,15 +34246,15 @@ args = ["--prefer-online", "-y", "@contextstream/mcp-server@latest"]
 [mcp_servers.contextstream.env]
 ` + envLines + "\n";
   if (!exists) {
-    await fs7.writeFile(filePath, block.trimStart(), "utf8");
+    await fs8.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
   }
   if (!existing.includes(marker)) {
-    await fs7.writeFile(filePath, existing.trimEnd() + block, "utf8");
+    await fs8.writeFile(filePath, existing.trimEnd() + block, "utf8");
     return "updated";
   }
   if (!existing.includes(envMarker)) {
-    await fs7.writeFile(
+    await fs8.writeFile(
       filePath,
       existing.trimEnd() + "\n\n" + envMarker + "\n" + envLines + "\n",
       "utf8"
@@ -33499,18 +34304,18 @@ args = ["--prefer-online", "-y", "@contextstream/mcp-server@latest"]
   }
   const updated = out.join("\n");
   if (updated === existing) return "skipped";
-  await fs7.writeFile(filePath, updated, "utf8");
+  await fs8.writeFile(filePath, updated, "utf8");
   return "updated";
 }
 async function discoverProjectsUnderFolder(parentFolder) {
-  const entries = await fs7.readdir(parentFolder, { withFileTypes: true });
-  const candidates = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => path8.join(parentFolder, e.name));
+  const entries = await fs8.readdir(parentFolder, { withFileTypes: true });
+  const candidates = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => path9.join(parentFolder, e.name));
   const projects = [];
   for (const dir of candidates) {
-    const hasGit = await fileExists(path8.join(dir, ".git"));
-    const hasPkg = await fileExists(path8.join(dir, "package.json"));
-    const hasCargo = await fileExists(path8.join(dir, "Cargo.toml"));
-    const hasPyProject = await fileExists(path8.join(dir, "pyproject.toml"));
+    const hasGit = await fileExists(path9.join(dir, ".git"));
+    const hasPkg = await fileExists(path9.join(dir, "package.json"));
+    const hasCargo = await fileExists(path9.join(dir, "Cargo.toml"));
+    const hasPyProject = await fileExists(path9.join(dir, "pyproject.toml"));
     if (hasGit || hasPkg || hasCargo || hasPyProject) projects.push(dir);
   }
   return projects;
@@ -33555,7 +34360,7 @@ async function selectProjectForCurrentDirectory(client, cwd, workspaceId, dryRun
   if (!workspaceId || workspaceId === "dry-run") {
     return void 0;
   }
-  const folderName = path8.basename(cwd) || "project";
+  const folderName = path9.basename(cwd) || "project";
   let projects = [];
   try {
     const result = await client.listProjects({
@@ -33631,7 +34436,7 @@ async function selectProjectForCurrentDirectory(client, cwd, workspaceId, dryRun
   return void 0;
 }
 async function indexProjectWithProgress(client, projectPath, workspaceId) {
-  const projectName = path8.basename(projectPath);
+  const projectName = path9.basename(projectPath);
   console.log(`
 ${colors.bright}Updating index for '${projectName}'...${colors.reset}`);
   console.log(`${colors.dim}${projectPath}${colors.reset}
@@ -34155,14 +34960,16 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         "\nCopilot canonical pair disabled for this run. You can rerun setup anytime to generate both files together."
       );
     }
-    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, contextPackEnabled });
-    const mcpServerClaude = buildContextStreamMcpServer({ apiUrl, apiKey, contextPackEnabled });
-    const mcpServerOpenCode = buildContextStreamOpenCodeLocalServer({
+    const setupEnvBase = {
       apiUrl,
       apiKey,
-      contextPackEnabled
-    });
-    const vsCodeServer = buildContextStreamVsCodeServer({ apiUrl, apiKey, contextPackEnabled });
+      contextPackEnabled,
+      workspaceId: workspaceId && workspaceId !== "dry-run" ? workspaceId : void 0
+    };
+    const mcpServer = buildContextStreamMcpServer(setupEnvBase);
+    const mcpServerClaude = buildContextStreamMcpServer(setupEnvBase);
+    const mcpServerOpenCode = buildContextStreamOpenCodeLocalServer(setupEnvBase);
+    const vsCodeServer = buildContextStreamVsCodeServer(setupEnvBase);
     let hasPrintedOpenCodeEnvNote = false;
     const printOpenCodeEnvNote = () => {
       if (hasPrintedOpenCodeEnvNote) return;
@@ -34178,7 +34985,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         if (mcpScope === "project" && editor !== "codex") continue;
         try {
           if (editor === "codex") {
-            const filePath = path8.join(homedir6(), ".codex", "config.toml");
+            const filePath = path9.join(homedir7(), ".codex", "config.toml");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -34194,7 +35001,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "copilot") {
-            const filePath = path8.join(homedir6(), ".copilot", "mcp-config.json");
+            const filePath = path9.join(homedir7(), ".copilot", "mcp-config.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -34249,7 +35056,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "cursor") {
-            const filePath = path8.join(homedir6(), ".cursor", "mcp.json");
+            const filePath = path9.join(homedir7(), ".cursor", "mcp.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -34261,7 +35068,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "windsurf") {
-            const filePath = path8.join(homedir6(), ".codeium", "windsurf", "mcp_config.json");
+            const filePath = path9.join(homedir7(), ".codeium", "windsurf", "mcp_config.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -34278,7 +35085,20 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             );
             continue;
           }
-          if (editor === "kilo" || editor === "roo") {
+          if (editor === "kilo") {
+            const filePath = path9.join(kiloConfigDir(), "kilo.jsonc");
+            if (dryRun) {
+              writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
+              console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
+              continue;
+            }
+            const kiloServer = buildContextStreamKiloServer(setupEnvBase);
+            const status = await upsertKiloMcpConfig(filePath, kiloServer);
+            writeActions.push({ kind: "mcp-config", target: filePath, status });
+            console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
+            continue;
+          }
+          if (editor === "roo") {
             console.log(
               `- ${EDITOR_LABELS[editor]}: project MCP config supported via file; global is managed via the app UI.`
             );
@@ -34300,7 +35120,8 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
       windsurf: "windsurf",
       cline: "cline",
       roo: "roo",
-      kilo: "kilo",
+      kilo: null,
+      // Kilo CLI: no hooks API, enforcement via rules + skills
       codex: null,
       // No hooks API
       copilot: null,
@@ -34331,7 +35152,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
           });
           for (const script of result.installed) {
             writeActions.push({ kind: "hooks", target: script, status: "created" });
-            console.log(`- ${EDITOR_LABELS[editor]}: installed ${path8.basename(script)}`);
+            console.log(`- ${EDITOR_LABELS[editor]}: installed ${path9.basename(script)}`);
           }
           if (editor === "cursor") {
             console.log(
@@ -34407,7 +35228,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         await rl.question(`Add current folder as a project? [Y/n] (${process.cwd()}): `)
       );
       if (addCwd.toLowerCase() !== "n" && addCwd.toLowerCase() !== "no") {
-        projectPaths.add(path8.resolve(process.cwd()));
+        projectPaths.add(path9.resolve(process.cwd()));
       }
       while (true) {
         console.log("\n  1) Add another project path");
@@ -34417,13 +35238,13 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         if (choice === "3") break;
         if (choice === "1") {
           const p = normalizeInput(await rl.question("Project folder path: "));
-          if (p) projectPaths.add(path8.resolve(p));
+          if (p) projectPaths.add(path9.resolve(p));
           continue;
         }
         if (choice === "2") {
           const parent = normalizeInput(await rl.question("Parent folder path: "));
           if (!parent) continue;
-          const parentAbs = path8.resolve(parent);
+          const parentAbs = path9.resolve(parent);
           const projects2 = await discoverProjectsUnderFolder(parentAbs);
           if (projects2.length === 0) {
             console.log(
@@ -34456,7 +35277,7 @@ Applying to ${projects.length} project(s)...`);
             workspace_id: workspaceId,
             workspace_name: workspaceName,
             create_parent_mapping: createParentMapping,
-            ...path8.resolve(projectPath) === path8.resolve(process.cwd()) && selectedCurrentProject ? {
+            ...path9.resolve(projectPath) === path9.resolve(process.cwd()) && selectedCurrentProject ? {
               project_id: selectedCurrentProject.id,
               project_name: selectedCurrentProject.name
             } : {},
@@ -34468,7 +35289,7 @@ Applying to ${projects.length} project(s)...`);
           });
           writeActions.push({
             kind: "workspace-config",
-            target: path8.join(projectPath, ".contextstream", "config.json"),
+            target: path9.join(projectPath, ".contextstream", "config.json"),
             status: "created"
           });
           console.log(`- Linked workspace in ${projectPath}`);
@@ -34479,24 +35300,37 @@ Applying to ${projects.length} project(s)...`);
       } else if (workspaceId && workspaceId !== "dry-run" && workspaceName && dryRun) {
         writeActions.push({
           kind: "workspace-config",
-          target: path8.join(projectPath, ".contextstream", "config.json"),
+          target: path9.join(projectPath, ".contextstream", "config.json"),
           status: "dry-run"
         });
       }
+      const isCurrentProject = path9.resolve(projectPath) === path9.resolve(process.cwd());
+      const projectIdForPath = isCurrentProject ? selectedCurrentProject?.id : void 0;
+      const projectSetupEnv = {
+        apiUrl,
+        apiKey: "",
+        // Omit API key from project configs — comes from global config or environment
+        contextPackEnabled,
+        workspaceId: workspaceId && workspaceId !== "dry-run" ? workspaceId : void 0,
+        projectId: projectIdForPath
+      };
+      const projectMcpServer = buildContextStreamMcpServer(projectSetupEnv);
+      const projectVsCodeServer = buildContextStreamVsCodeServer(projectSetupEnv);
+      const projectMcpServerClaude = buildContextStreamMcpServer(projectSetupEnv);
       if (mcpScope === "project" || mcpScope === "both" || enforceCopilotCanonicalPair) {
         for (const editor of configuredEditors) {
           const shouldWriteProjectMcp = mcpScope === "project" || mcpScope === "both" || enforceCopilotCanonicalPair && editor === "copilot";
           if (!shouldWriteProjectMcp) continue;
           try {
             if (editor === "cursor") {
-              const cursorPath = path8.join(projectPath, ".cursor", "mcp.json");
-              const vscodePath = path8.join(projectPath, ".vscode", "mcp.json");
+              const cursorPath = path9.join(projectPath, ".cursor", "mcp.json");
+              const vscodePath = path9.join(projectPath, ".vscode", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: cursorPath, status: "dry-run" });
                 writeActions.push({ kind: "mcp-config", target: vscodePath, status: "dry-run" });
               } else {
-                const status1 = await upsertJsonMcpConfig(cursorPath, mcpServer);
-                const status2 = await upsertJsonVsCodeMcpConfig(vscodePath, vsCodeServer);
+                const status1 = await upsertJsonMcpConfig(cursorPath, projectMcpServer);
+                const status2 = await upsertJsonVsCodeMcpConfig(vscodePath, projectVsCodeServer);
                 writeActions.push({ kind: "mcp-config", target: cursorPath, status: status1 });
                 writeActions.push({ kind: "mcp-config", target: vscodePath, status: status2 });
               }
@@ -34504,22 +35338,22 @@ Applying to ${projects.length} project(s)...`);
             }
             if (editor === "windsurf") {
               console.log(
-                `- ${EDITOR_LABELS[editor]}: uses global MCP config only (${path8.join(homedir6(), ".codeium", "windsurf", "mcp_config.json")}).`
+                `- ${EDITOR_LABELS[editor]}: uses global MCP config only (${path9.join(homedir7(), ".codeium", "windsurf", "mcp_config.json")}).`
               );
               continue;
             }
             if (editor === "claude") {
-              const mcpPath = path8.join(projectPath, ".mcp.json");
+              const mcpPath = path9.join(projectPath, ".mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: mcpPath, status: "dry-run" });
               } else {
-                const status = await upsertJsonMcpConfig(mcpPath, mcpServerClaude);
+                const status = await upsertJsonMcpConfig(mcpPath, projectMcpServerClaude);
                 writeActions.push({ kind: "mcp-config", target: mcpPath, status });
               }
               continue;
             }
             if (editor === "opencode") {
-              const openCodePath = path8.join(projectPath, "opencode.json");
+              const openCodePath = path9.join(projectPath, "opencode.json");
               if (dryRun) {
                 writeActions.push({
                   kind: "mcp-config",
@@ -34527,38 +35361,40 @@ Applying to ${projects.length} project(s)...`);
                   status: "dry-run"
                 });
               } else {
-                const status = await upsertOpenCodeMcpConfig(openCodePath, mcpServerOpenCode);
+                const projectOpenCode = buildContextStreamOpenCodeLocalServer(projectSetupEnv);
+                const status = await upsertOpenCodeMcpConfig(openCodePath, projectOpenCode);
                 writeActions.push({ kind: "mcp-config", target: openCodePath, status });
               }
               printOpenCodeEnvNote();
               continue;
             }
             if (editor === "copilot") {
-              const vsCodePath = path8.join(projectPath, ".vscode", "mcp.json");
+              const vsCodePath = path9.join(projectPath, ".vscode", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: vsCodePath, status: "dry-run" });
               } else {
-                const status = await upsertJsonVsCodeMcpConfig(vsCodePath, vsCodeServer);
+                const status = await upsertJsonVsCodeMcpConfig(vsCodePath, projectVsCodeServer);
                 writeActions.push({ kind: "mcp-config", target: vsCodePath, status });
               }
               continue;
             }
             if (editor === "kilo") {
-              const kiloPath = path8.join(projectPath, ".kilocode", "mcp.json");
+              const kiloPath = path9.join(projectPath, "kilo.jsonc");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: kiloPath, status: "dry-run" });
               } else {
-                const status = await upsertJsonMcpConfig(kiloPath, mcpServer);
+                const kiloServer = buildContextStreamKiloServer(projectSetupEnv);
+                const status = await upsertKiloMcpConfig(kiloPath, kiloServer);
                 writeActions.push({ kind: "mcp-config", target: kiloPath, status });
               }
               continue;
             }
             if (editor === "roo") {
-              const rooPath = path8.join(projectPath, ".roo", "mcp.json");
+              const rooPath = path9.join(projectPath, ".roo", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: rooPath, status: "dry-run" });
               } else {
-                const status = await upsertJsonMcpConfig(rooPath, mcpServer);
+                const status = await upsertJsonMcpConfig(rooPath, projectMcpServer);
                 writeActions.push({ kind: "mcp-config", target: rooPath, status });
               }
               continue;
@@ -34577,11 +35413,11 @@ Applying to ${projects.length} project(s)...`);
         const rule = generateRuleContent(editor, {
           workspaceName,
           workspaceId: workspaceId && workspaceId !== "dry-run" ? workspaceId : void 0,
-          projectName: path8.basename(projectPath),
+          projectName: path9.basename(projectPath),
           mode: getModeForEditor(editor)
         });
         if (!rule) continue;
-        const filePath = path8.join(projectPath, rule.filename);
+        const filePath = path9.join(projectPath, rule.filename);
         if (dryRun) {
           writeActions.push({ kind: "rules", target: filePath, status: "dry-run" });
           continue;
@@ -34720,14 +35556,14 @@ Applying to ${projects.length} project(s)...`);
 // src/index.ts
 var ENABLE_PROMPTS2 = (process.env.CONTEXTSTREAM_ENABLE_PROMPTS || "true").toLowerCase() !== "false";
 function showFirstRunMessage() {
-  const configDir = join21(homedir18(), ".contextstream");
-  const starShownFile = join21(configDir, ".star-shown");
-  if (existsSync15(starShownFile)) {
+  const configDir = join22(homedir19(), ".contextstream");
+  const starShownFile = join22(configDir, ".star-shown");
+  if (existsSync16(starShownFile)) {
     return;
   }
-  if (!existsSync15(configDir)) {
+  if (!existsSync16(configDir)) {
     try {
-      mkdirSync7(configDir, { recursive: true });
+      mkdirSync8(configDir, { recursive: true });
     } catch {
       return;
     }
@@ -34740,7 +35576,7 @@ function showFirstRunMessage() {
   console.error("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
   console.error("");
   try {
-    writeFileSync8(starShownFile, (/* @__PURE__ */ new Date()).toISOString());
+    writeFileSync9(starShownFile, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
 }