@contextstream/mcp-server 0.4.71 → 0.4.73

package/dist/index.js

@@ -1109,6 +1109,7 @@ async function readFilesFromDirectory(rootPath, options = {}) {
     } catch {
       return;
     }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (files.length >= maxFiles) break;
       const fullPath = path2.join(dir, entry.name);
@@ -1168,6 +1169,7 @@ async function* readAllFilesInBatches(rootPath, options = {}) {
     } catch {
       return;
     }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       const fullPath = path2.join(dir, entry.name);
       const relPath = path2.join(relativePath, entry.name);
@@ -1254,6 +1256,7 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
     } catch {
       return;
     }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       const fullPath = path2.join(dir, entry.name);
       const relPath = path2.join(relativePath, entry.name);
@@ -1344,6 +1347,7 @@ async function countIndexableFiles(rootPath, options = {}) {
     } catch {
       return;
     }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (count >= maxFiles) {
         stopped = true;
@@ -4896,7 +4900,7 @@ __export(post_write_exports, {
 });
 import * as fs9 from "node:fs";
 import * as path10 from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir9 } 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;
@@ -4966,7 +4970,7 @@ function loadApiConfig(startDir) {
     currentDir = parentDir;
   }
   if (!apiKey) {
-    const homeMcpPath = path10.join(homedir8(), ".mcp.json");
+    const homeMcpPath = path10.join(homedir9(), ".mcp.json");
     if (fs9.existsSync(homeMcpPath)) {
       try {
         const content = fs9.readFileSync(homeMcpPath, "utf-8");
@@ -5246,7 +5250,7 @@ var init_post_write = __esm({
 // src/hooks/common.ts
 import * as fs10 from "node:fs";
 import * as path11 from "node:path";
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 function readHookInput() {
   try {
     return JSON.parse(fs10.readFileSync(0, "utf8"));
@@ -5311,7 +5315,7 @@ function loadHookConfig(cwd) {
     searchDir = parentDir;
   }
   if (!apiKey && !jwt) {
-    const homeMcpPath = path11.join(homedir9(), ".mcp.json");
+    const homeMcpPath = path11.join(homedir10(), ".mcp.json");
     if (fs10.existsSync(homeMcpPath)) {
       try {
         const config = JSON.parse(fs10.readFileSync(homeMcpPath, "utf8"));
@@ -5476,7 +5480,7 @@ __export(post_tool_use_failure_exports, {
 });
 import * as fs11 from "node:fs";
 import * as path12 from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir11 } 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";
 }
@@ -5546,7 +5550,7 @@ var init_post_tool_use_failure = __esm({
   "src/hooks/post-tool-use-failure.ts"() {
     "use strict";
     init_common();
-    FAILURE_COUNTERS_FILE = path12.join(homedir10(), ".contextstream", "hook-failure-counts.json");
+    FAILURE_COUNTERS_FILE = path12.join(homedir11(), ".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));
@@ -6003,7 +6007,7 @@ var init_teammate_idle = __esm({
 // src/hooks/prompt-state.ts
 import * as fs13 from "node:fs";
 import * as path13 from "node:path";
-import { homedir as homedir11 } from "node:os";
+import { homedir as homedir12 } from "node:os";
 function defaultState() {
   return { workspaces: {} };
 }
@@ -6205,7 +6209,7 @@ var STATE_PATH;
 var init_prompt_state = __esm({
   "src/hooks/prompt-state.ts"() {
     "use strict";
-    STATE_PATH = path13.join(homedir11(), ".contextstream", "prompt-state.json");
+    STATE_PATH = path13.join(homedir12(), ".contextstream", "prompt-state.json");
   }
 });
 
@@ -6216,7 +6220,7 @@ __export(pre_tool_use_exports, {
 });
 import * as fs14 from "node:fs";
 import * as path14 from "node:path";
-import { homedir as homedir12 } from "node:os";
+import { homedir as homedir13 } from "node:os";
 function isDiscoveryGlob(pattern) {
   const patternLower = pattern.toLowerCase();
   for (const p of DISCOVERY_PATTERNS) {
@@ -6642,7 +6646,7 @@ var init_pre_tool_use = __esm({
     "use strict";
     init_prompt_state();
     ENABLED2 = process.env.CONTEXTSTREAM_HOOK_ENABLED !== "false";
-    INDEX_STATUS_FILE = path14.join(homedir12(), ".contextstream", "indexed-projects.json");
+    INDEX_STATUS_FILE = path14.join(homedir13(), ".contextstream", "indexed-projects.json");
     DEBUG_FILE = "/tmp/pretooluse-hook-debug.log";
     STALE_THRESHOLD_DAYS = 7;
     CONTEXT_FRESHNESS_SECONDS = 120;
@@ -6664,7 +6668,7 @@ __export(user_prompt_submit_exports, {
 });
 import * as fs15 from "node:fs";
 import * as path15 from "node:path";
-import { homedir as homedir13 } from "node:os";
+import { homedir as homedir14 } from "node:os";
 function loadConfigFromMcpJson(cwd) {
   let searchDir = path15.resolve(cwd);
   for (let i = 0; i < 5; i++) {
@@ -6709,7 +6713,7 @@ function loadConfigFromMcpJson(cwd) {
     searchDir = parentDir;
   }
   if (!API_KEY2) {
-    const homeMcpPath = path15.join(homedir13(), ".mcp.json");
+    const homeMcpPath = path15.join(homedir14(), ".mcp.json");
     if (fs15.existsSync(homeMcpPath)) {
       try {
         const content = fs15.readFileSync(homeMcpPath, "utf-8");
@@ -7271,7 +7275,7 @@ __export(pre_compact_exports, {
 });
 import * as fs16 from "node:fs";
 import * as path16 from "node:path";
-import { homedir as homedir14 } from "node:os";
+import { homedir as homedir15 } from "node:os";
 function loadConfigFromMcpJson2(cwd) {
   let searchDir = path16.resolve(cwd);
   for (let i = 0; i < 5; i++) {
@@ -7310,7 +7314,7 @@ function loadConfigFromMcpJson2(cwd) {
     searchDir = parentDir;
   }
   if (!API_KEY3) {
-    const homeMcpPath = path16.join(homedir14(), ".mcp.json");
+    const homeMcpPath = path16.join(homedir15(), ".mcp.json");
     if (fs16.existsSync(homeMcpPath)) {
       try {
         const content = fs16.readFileSync(homeMcpPath, "utf-8");
@@ -7594,7 +7598,7 @@ __export(post_compact_exports, {
 });
 import * as fs17 from "node:fs";
 import * as path17 from "node:path";
-import { homedir as homedir15 } from "node:os";
+import { homedir as homedir16 } from "node:os";
 function loadConfigFromMcpJson3(cwd) {
   let searchDir = path17.resolve(cwd);
   for (let i = 0; i < 5; i++) {
@@ -7633,7 +7637,7 @@ function loadConfigFromMcpJson3(cwd) {
     searchDir = parentDir;
   }
   if (!API_KEY4) {
-    const homeMcpPath = path17.join(homedir15(), ".mcp.json");
+    const homeMcpPath = path17.join(homedir16(), ".mcp.json");
     if (fs17.existsSync(homeMcpPath)) {
       try {
         const content = fs17.readFileSync(homeMcpPath, "utf-8");
@@ -7772,7 +7776,7 @@ __export(session_init_exports, {
 });
 import * as fs18 from "node:fs";
 import * as path18 from "node:path";
-import { homedir as homedir16 } from "node:os";
+import { homedir as homedir17 } from "node:os";
 function loadConfigFromMcpJson4(cwd) {
   let searchDir = path18.resolve(cwd);
   for (let i = 0; i < 5; i++) {
@@ -7817,7 +7821,7 @@ function loadConfigFromMcpJson4(cwd) {
     searchDir = parentDir;
   }
   if (!API_KEY5) {
-    const homeMcpPath = path18.join(homedir16(), ".mcp.json");
+    const homeMcpPath = path18.join(homedir17(), ".mcp.json");
     if (fs18.existsSync(homeMcpPath)) {
       try {
         const content = fs18.readFileSync(homeMcpPath, "utf-8");
@@ -8076,7 +8080,7 @@ __export(session_end_exports, {
 });
 import * as fs19 from "node:fs";
 import * as path19 from "node:path";
-import { homedir as homedir17 } from "node:os";
+import { homedir as homedir18 } from "node:os";
 function loadConfigFromMcpJson5(cwd) {
   let searchDir = path19.resolve(cwd);
   for (let i = 0; i < 5; i++) {
@@ -8118,7 +8122,7 @@ function loadConfigFromMcpJson5(cwd) {
     searchDir = parentDir;
   }
   if (!API_KEY6) {
-    const homeMcpPath = path19.join(homedir17(), ".mcp.json");
+    const homeMcpPath = path19.join(homedir18(), ".mcp.json");
     if (fs19.existsSync(homeMcpPath)) {
       try {
         const content = fs19.readFileSync(homeMcpPath, "utf-8");
@@ -8508,7 +8512,7 @@ __export(verify_key_exports, {
 });
 import * as fs20 from "node:fs";
 import * as path20 from "node:path";
-import { homedir as homedir18 } from "node:os";
+import { homedir as homedir19 } from "node:os";
 function maskApiKey2(key) {
   if (!key || key.length < 8) return "***";
   const prefixMatch = key.match(/^([a-z]{2,3}_)/i);
@@ -8541,11 +8545,11 @@ function extractFromMcpConfig(config) {
 function getClaudeDesktopConfigPath() {
   const platform2 = process.platform;
   if (platform2 === "darwin") {
-    return path20.join(homedir18(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return path20.join(homedir19(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   } else if (platform2 === "win32") {
     return path20.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
   } else {
-    return path20.join(homedir18(), ".config", "Claude", "claude_desktop_config.json");
+    return path20.join(homedir19(), ".config", "Claude", "claude_desktop_config.json");
   }
 }
 function loadApiKey() {
@@ -8583,7 +8587,7 @@ function loadApiKey() {
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  const globalMcpPath = path20.join(homedir18(), ".mcp.json");
+  const globalMcpPath = path20.join(homedir19(), ".mcp.json");
   if (fs20.existsSync(globalMcpPath)) {
     try {
       const content = fs20.readFileSync(globalMcpPath, "utf-8");
@@ -8602,7 +8606,7 @@ function loadApiKey() {
   }
   const cursorPaths = [
     path20.join(process.cwd(), ".cursor", "mcp.json"),
-    path20.join(homedir18(), ".cursor", "mcp.json")
+    path20.join(homedir19(), ".cursor", "mcp.json")
   ];
   for (const cursorPath of cursorPaths) {
     if (fs20.existsSync(cursorPath)) {
@@ -8640,9 +8644,9 @@ function loadApiKey() {
     }
   }
   const vscodePaths = [
-    path20.join(homedir18(), ".vscode", "mcp.json"),
-    path20.join(homedir18(), ".codeium", "windsurf", "mcp_config.json"),
-    path20.join(homedir18(), ".continue", "config.json")
+    path20.join(homedir19(), ".vscode", "mcp.json"),
+    path20.join(homedir19(), ".codeium", "windsurf", "mcp_config.json"),
+    path20.join(homedir19(), ".continue", "config.json")
   ];
   for (const vsPath of vscodePaths) {
     if (fs20.existsSync(vsPath)) {
@@ -8662,7 +8666,7 @@ function loadApiKey() {
       }
     }
   }
-  const credentialsPath = path20.join(homedir18(), ".contextstream", "credentials.json");
+  const credentialsPath = path20.join(homedir19(), ".contextstream", "credentials.json");
   if (fs20.existsSync(credentialsPath)) {
     try {
       const content = fs20.readFileSync(credentialsPath, "utf-8");
@@ -12888,6 +12892,7 @@ function loadConfig() {
 // src/client.ts
 import { randomUUID } from "node:crypto";
 import * as path5 from "node:path";
+import { homedir as homedir4 } from "node:os";
 
 // src/auth-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -13476,6 +13481,59 @@ function isDecisionResult(item) {
   if (tags.includes("decision")) return true;
   return false;
 }
+var WIRE_CODE_TO_KIND = {
+  W: "rule",
+  P: "rule",
+  L: "lesson",
+  D: "decision",
+  M: "memory",
+  T: "memory",
+  VC: "vcs",
+  PR: "preference",
+  SK: "skill",
+  TN: "transcript_snapshot",
+  C: "code",
+  F: "flash",
+  G: "graph",
+  I: "instruction",
+  TS: "tool_suggestion",
+  WA: "warning",
+  SY: "synthesis",
+  PK: "pack",
+  SR: "suggested_rule",
+  KN: "knowledge_node"
+};
+var KIND_DEFAULT_PRECEDENCE = {
+  rule: "always",
+  lesson: "critical",
+  decision: "high",
+  preference: "high",
+  skill: "high",
+  memory: "normal",
+  knowledge_node: "normal",
+  code: "normal",
+  flash: "normal",
+  instruction: "normal",
+  tool_suggestion: "normal",
+  warning: "normal",
+  synthesis: "normal",
+  pack: "normal",
+  suggested_rule: "normal",
+  vcs: "normal",
+  transcript_snapshot: "normal",
+  graph: "low",
+  unknown: "low"
+};
+function resolveItemKind(item) {
+  if (item.item_type) {
+    const lower = item.item_type.toLowerCase();
+    if (lower in KIND_DEFAULT_PRECEDENCE) return lower;
+  }
+  return WIRE_CODE_TO_KIND[item.typ] || "unknown";
+}
+function filterItemsByKind(items, kind) {
+  return items.filter((i) => resolveItemKind(i) === kind).sort((a, b) => b.score - a.score);
+}
 function pickString(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -13545,6 +13603,77 @@ function isMultiProjectFolder(folderPath) {
     return { isMultiProject: false, projectCount: 0, projectNames: [] };
   }
 }
+var INDEX_KEEPER_INCREMENTAL_INTERVAL_MS = 1e4;
+var INDEX_KEEPER_AGING_INTERVAL_MS = 3e5;
+var INDEX_KEEPER_STALE_INTERVAL_MS = 6e4;
+var INDEX_KEEPER_AGING_THRESHOLD_HOURS = 4;
+var INDEX_KEEPER_AGING_MAX_FILES = 2e4;
+var IndexKeeper = class {
+  constructor() {
+    this.lastIncremental = 0;
+    this.lastAging = 0;
+    this.lastStale = 0;
+    this.client = null;
+  }
+  attach(client) {
+    this.client = client;
+  }
+  shouldFire(lastMs, intervalMs) {
+    return Date.now() - lastMs >= intervalMs;
+  }
+  async tick(projectId, folderPath) {
+    if (!this.client || !projectId || !folderPath) return;
+    try {
+      await this.checkIncremental(projectId, folderPath);
+      await this.checkAgingRefresh(projectId, folderPath);
+    } catch {
+    }
+  }
+  async checkIncremental(projectId, folderPath) {
+    if (!this.shouldFire(this.lastIncremental, INDEX_KEEPER_INCREMENTAL_INTERVAL_MS)) return;
+    this.lastIncremental = Date.now();
+    if (!this.client) return;
+    try {
+      await this.client.checkAndIndexChangedFiles();
+    } catch {
+    }
+  }
+  async checkAgingRefresh(projectId, folderPath) {
+    if (!this.shouldFire(this.lastAging, INDEX_KEEPER_AGING_INTERVAL_MS)) return;
+    this.lastAging = Date.now();
+    if (!this.client) return;
+    const ageHours = this.client.localIndexAgeHours(folderPath);
+    if (ageHours === null || ageHours < INDEX_KEEPER_AGING_THRESHOLD_HOURS) return;
+    console.error(`[ContextStream] IndexKeeper: aging refresh for ${folderPath} (${ageHours}h old)`);
+    try {
+      await this.client.ingestLocal({
+        projectId,
+        rootPath: folderPath,
+        maxFiles: INDEX_KEEPER_AGING_MAX_FILES
+      });
+    } catch (e) {
+      console.error(`[ContextStream] IndexKeeper aging refresh failed:`, e);
+    }
+  }
+  maybeTriggerStaleReingest(params) {
+    if (params.freshness !== "stale") return void 0;
+    if (!this.shouldFire(this.lastStale, INDEX_KEEPER_STALE_INTERVAL_MS)) return void 0;
+    this.lastStale = Date.now();
+    if (!this.client) return void 0;
+    const client = this.client;
+    const pid = params.projectId;
+    const fp = params.folderPath;
+    setImmediate(async () => {
+      try {
+        await client.ingestLocal({ projectId: pid, rootPath: fp });
+        console.error(`[ContextStream] IndexKeeper: stale re-ingest completed for ${fp}`);
+      } catch (e) {
+        console.error(`[ContextStream] IndexKeeper stale re-ingest failed:`, e);
+      }
+    });
+    return `Started background re-index for ${fp} because the current index is stale.`;
+  }
+};
 var ContextStreamClient = class _ContextStreamClient {
   constructor(config) {
     this.config = config;
@@ -14454,6 +14583,16 @@ var ContextStreamClient = class _ContextStreamClient {
       }
     });
   }
+  async ingestFromPath(projectId, pathStr, opts) {
+    return request(this.config, `/projects/${projectId}/files/ingest-from-path`, {
+      body: {
+        path: pathStr,
+        force: opts?.force ?? false,
+        include_media: opts?.include_media ?? false,
+        max_files: opts?.max_files
+      }
+    });
+  }
   /**
    * High-level local ingest: reads files from disk, applies SHA-256 content
    * hash filtering, batches, and sends to the API with cooldown/status handling.
@@ -14511,7 +14650,22 @@ var ContextStreamClient = class _ContextStreamClient {
           }
         }
       } catch (e) {
-        console.error(`[ContextStream] Batch ingest error:`, e);
+        console.error(`[ContextStream] Batch ingest error (attempt 1):`, e);
+        try {
+          const retryResult = await this.ingestFiles(projectId, filteredBatch, ingestOptions);
+          const data = retryResult.data;
+          if (data) {
+            filesIndexed += data.files_indexed ?? 0;
+            apiSkipped += data.files_skipped ?? 0;
+            lastStatus = data.status;
+            if (data.status === "cooldown" || data.status === "daily_limit_exceeded") {
+              abortedEarly = true;
+              break;
+            }
+          }
+        } catch (retryErr) {
+          console.error(`[ContextStream] Batch ingest retry failed:`, retryErr);
+        }
       }
     }
     writeHashManifest(projectId, newHashes);
@@ -14564,6 +14718,28 @@ var ContextStreamClient = class _ContextStreamClient {
     this.indexChangedFilesAsync().catch(() => {
     });
   }
+  localIndexAgeHours(folderPath) {
+    try {
+      const resolvedFolder = path5.resolve(folderPath);
+      const fs21 = __require("node:fs");
+      const statusPath = path5.join(homedir4(), ".contextstream", "index-status.json");
+      const raw = fs21.readFileSync(statusPath, "utf-8");
+      const status = JSON.parse(raw);
+      const projects = status.projects ?? {};
+      for (const [projectPath, info] of Object.entries(projects)) {
+        const resolvedProjectPath = path5.resolve(projectPath);
+        if (resolvedFolder === resolvedProjectPath || resolvedFolder.startsWith(`${resolvedProjectPath}${path5.sep}`)) {
+          if (info?.indexed_at) {
+            const ageMs = Date.now() - new Date(info.indexed_at).getTime();
+            return Math.floor(ageMs / 36e5);
+          }
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
   /**
    * Internal async method to find and index changed files.
    * Called by checkAndIndexChangedFiles in fire-and-forget mode.
@@ -16340,6 +16516,61 @@ ${context}`;
       ...this.indexRefreshInProgress ? { index_status: "refreshing" } : {}
     };
   }
+  async getContextFast(params) {
+    const withDefaults = this.withDefaults(params);
+    if (!withDefaults.workspace_id) return null;
+    try {
+      const result = await request(this.config, "/context/hook", {
+        body: withDefaults,
+        timeoutMs: 5e3
+      });
+      const data = result?.data ?? result ?? {};
+      return {
+        context: data.context || "",
+        items: Array.isArray(data.items) ? data.items : void 0,
+        action_required: data.action_required
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getVcsRepos(params) {
+    try {
+      const result = await request(this.config, `/integrations/workspaces/${params.workspace_id}/vcs/repos`, {
+        method: "GET",
+        timeoutMs: 3e3
+      });
+      return Array.isArray(result?.data) ? result.data : Array.isArray(result) ? result : [];
+    } catch {
+      return [];
+    }
+  }
+  async getVcsResource(params) {
+    const qs = params.per_page ? `?per_page=${params.per_page}` : "";
+    try {
+      const result = await request(this.config, `/integrations/workspaces/${params.workspace_id}/vcs/${params.path}${qs}`, {
+        method: "GET",
+        timeoutMs: 4e3
+      });
+      return Array.isArray(result?.data) ? result.data : Array.isArray(result) ? result : [];
+    } catch {
+      return [];
+    }
+  }
+  async vcsApiRequest(params) {
+    const queryParts = [];
+    if (params.query) {
+      for (const [k, v] of Object.entries(params.query)) {
+        if (v !== void 0 && v !== null) queryParts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+      }
+    }
+    const qs = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+    const url = `/integrations/workspaces/${params.workspace_id}/vcs/${params.path}${qs}`;
+    return request(this.config, url, {
+      method: params.method,
+      ...params.body ? { body: params.body } : {}
+    });
+  }
   /**
    * Get high-priority lessons that should be surfaced proactively.
    * Returns critical and high severity lessons for warnings.
@@ -17775,7 +18006,7 @@ ${context}`;
 import * as fs6 from "node:fs";
 import * as path7 from "node:path";
 import { execFile } from "node:child_process";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { promisify as promisify2 } from "node:util";
 init_files();
 init_rules_templates();
@@ -18360,9 +18591,9 @@ 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";
+import { homedir as homedir5 } from "node:os";
 var STORE_VERSION = 1;
-var STORE_DIR = path6.join(homedir4(), ".contextstream");
+var STORE_DIR = path6.join(homedir5(), ".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;
@@ -18808,9 +19039,9 @@ var RULES_PROJECT_FILES = {
   aider: ".aider.conf.yml"
 };
 var RULES_GLOBAL_FILES = {
-  codex: [path7.join(homedir5(), ".codex", "AGENTS.md")],
-  kilo: [path7.join(homedir5(), ".kilocode", "rules", "contextstream.md")],
-  roo: [path7.join(homedir5(), ".roo", "rules", "contextstream.md")]
+  codex: [path7.join(homedir6(), ".codex", "AGENTS.md")],
+  kilo: [path7.join(homedir6(), ".kilocode", "rules", "contextstream.md")],
+  roo: [path7.join(homedir6(), ".roo", "rules", "contextstream.md")]
 };
 var rulesNoticeCache = /* @__PURE__ */ new Map();
 function compareVersions2(v1, v2) {
@@ -19973,6 +20204,7 @@ function parsePositiveInt(raw, fallback) {
 var OUTPUT_FORMAT = process.env.CONTEXTSTREAM_OUTPUT_FORMAT || "compact";
 var COMPACT_OUTPUT = OUTPUT_FORMAT === "compact";
 var SHOW_TIMING = process.env.CONTEXTSTREAM_SHOW_TIMING === "true" || process.env.CONTEXTSTREAM_SHOW_TIMING === "1";
+var CONCISE_TOOL_TEXT = process.env.CONTEXTSTREAM_CONCISE_TOOL_TEXT?.toLowerCase() !== "false";
 var INCLUDE_STRUCTURED_CONTENT = parseBoolEnvDefault(
   process.env.CONTEXTSTREAM_INCLUDE_STRUCTURED_CONTENT,
   true
@@ -19989,6 +20221,73 @@ function maybeStripStructuredContent(result) {
   const { structuredContent: _structuredContent, ...rest } = result;
   return rest;
 }
+function formatTypedLessons(items, compact) {
+  if (items.length === 0) return "";
+  const MAX = 5;
+  const entries = items.slice(0, MAX).map((item) => {
+    const sev = item.score >= 0.8 ? "CRIT" : item.score >= 0.5 ? "HIGH" : "note";
+    return compact ? `[LESSON:${sev}] ${item.value}` : `Lesson (${sev}): ${item.value}`;
+  });
+  return entries.join("\n");
+}
+function formatTypedPreferences(items, compact) {
+  if (items.length === 0) return "";
+  const MAX = 5;
+  const entries = items.slice(0, MAX).map(
+    (item) => compact ? `[PREF] ${item.value}` : `Preference: ${item.value}`
+  );
+  return entries.join("\n");
+}
+function formatTypedVcs(items, compact) {
+  if (items.length === 0) return "";
+  const MAX = 5;
+  const entries = items.slice(0, MAX).map(
+    (item) => compact ? `[VCS] ${item.value}` : `VCS: ${item.value}`
+  );
+  return entries.join("\n");
+}
+function formatTypedSkills(items, compact) {
+  if (items.length === 0) return "";
+  const MAX = 5;
+  const entries = items.slice(0, MAX).map(
+    (item) => compact ? `[SKILL] ${item.value}` : `Skill: ${item.value}`
+  );
+  return entries.join("\n");
+}
+function formatTypedSnapshots(items, compact) {
+  if (items.length === 0) return "";
+  const MAX = 3;
+  const entries = items.slice(0, MAX).map(
+    (item) => compact ? `[SNAPSHOT] ${item.value}` : `Transcript snapshot: ${item.value}`
+  );
+  return entries.join("\n");
+}
+function hasServerVcsItems(items) {
+  if (!items || items.length === 0) return false;
+  return items.some((i) => resolveItemKind(i) === "vcs");
+}
+var WARM_CACHE_TTL_MS = 3e4;
+var warmCacheEntry = null;
+function getWarmCacheKey(workspaceId, projectId) {
+  return `${workspaceId || ""}:${projectId || ""}`;
+}
+function getWarmCache(workspaceId, projectId) {
+  if (!warmCacheEntry) return null;
+  const key = getWarmCacheKey(workspaceId, projectId);
+  if (warmCacheEntry.key !== key) return null;
+  if (Date.now() - warmCacheEntry.timestamp > WARM_CACHE_TTL_MS) {
+    warmCacheEntry = null;
+    return null;
+  }
+  return warmCacheEntry.result;
+}
+function setWarmCache(workspaceId, projectId, result) {
+  warmCacheEntry = {
+    key: getWarmCacheKey(workspaceId, projectId),
+    timestamp: Date.now(),
+    result
+  };
+}
 var CONSOLIDATED_MODE = process.env.CONTEXTSTREAM_CONSOLIDATED !== "false";
 var CONSOLIDATED_TOOLS = /* @__PURE__ */ new Set([
   "init",
@@ -20351,6 +20650,8 @@ function setupClientDetection(server) {
 }
 function registerTools(server, client, sessionManager, options) {
   const upgradeUrl2 = process.env.CONTEXTSTREAM_UPGRADE_URL || "https://contextstream.io/pricing";
+  const indexKeeper = new IndexKeeper();
+  indexKeeper.attach(client);
   const toolSurfaceProfile = normalizeToolSurfaceProfile(
     options?.toolSurfaceProfile || process.env.CONTEXTSTREAM_TOOL_SURFACE_PROFILE
   );
@@ -20968,6 +21269,13 @@ Next step: ${createCommand}`
   function isNotFoundError(error) {
     return error instanceof HttpError && error.status === 404;
   }
+  function isAccessDeniedError(error) {
+    return error instanceof HttpError && (error.status === 403 || error.status === 401);
+  }
+  function isScopeInvalidResult(result) {
+    const data = result?.data ?? result ?? {};
+    return data.scope_is_valid === false || data.scope_invalid === true || typeof data.error === "string" && data.error.includes("project_access_denied");
+  }
   function isRequiresIngestEndpointError(error) {
     if (!(error instanceof HttpError)) return false;
     if (error.status !== 400) return false;
@@ -20983,6 +21291,100 @@ Next step: ${createCommand}`
       (t) => /[A-Z][a-z]/.test(t) || t.includes("_") || t.includes(".") || t.includes("::")
     );
   }
+  function isArtifactLikePath(filePath) {
+    const normalized = filePath.toLowerCase().replace(/\\/g, "/");
+    return normalized.includes("/.next/") || normalized.includes("/.next.bak/") || normalized.includes("/node_modules/") || normalized.includes("/dist/") || normalized.includes("/build/") || normalized.includes("/target/") || normalized.includes("/coverage/") || normalized.endsWith(".js.map") || normalized.endsWith(".css.map") || normalized.endsWith(".d.ts.map") || normalized.endsWith(".min.js") || normalized.startsWith("archives-ignore/") || normalized.includes("/archives-ignore/") || normalized.startsWith("archives-") && normalized.includes("/tasks/");
+  }
+  function queryExplicitlyTargetsArtifacts(query) {
+    const lower = query.toLowerCase();
+    return lower.includes(".map") || lower.includes("source map") || lower.includes("sourcemap") || lower.includes("node_modules") || lower.includes(".next") || lower.includes("dist/") || lower.includes("build/") || lower.includes("coverage");
+  }
+  function shouldFilterArtifactPaths(mode, query) {
+    if (mode === "pattern" || mode === "exhaustive") return false;
+    if (queryExplicitlyTargetsArtifacts(query)) return false;
+    return true;
+  }
+  const MIRROR_PREFIXES = [
+    "contextstream-ai-brain-export/",
+    "contextstream/",
+    "web/users/"
+  ];
+  function canonicalizeRepoPath(filePath) {
+    let normalized = filePath.replace(/\\/g, "/");
+    while (normalized.startsWith("./")) {
+      normalized = normalized.slice(2);
+    }
+    for (const prefix of MIRROR_PREFIXES) {
+      if (normalized.startsWith(prefix)) {
+        normalized = normalized.slice(prefix.length);
+        break;
+      }
+    }
+    if (normalized.startsWith(".claude/worktrees/")) {
+      const rest = normalized.slice(".claude/worktrees/".length);
+      const slashIdx = rest.indexOf("/");
+      if (slashIdx >= 0) {
+        normalized = rest.slice(slashIdx + 1);
+      }
+    }
+    const projectsIdx = normalized.indexOf("/projects/");
+    if (projectsIdx >= 0) {
+      const afterProjects = normalized.slice(projectsIdx + "/projects/".length);
+      const uuidEndIdx = afterProjects.indexOf("/");
+      if (uuidEndIdx >= 0 && /^[0-9a-f-]{36}/i.test(afterProjects)) {
+        normalized = afterProjects.slice(uuidEndIdx + 1);
+      }
+    }
+    return normalized;
+  }
+  function extractSymbolAnchors(query) {
+    const tokens = query.split(/\s+/).filter(Boolean);
+    const anchors = [];
+    for (const t of tokens) {
+      const cleaned = t.replace(/^["'`]+|["'`]+$/g, "");
+      if (!cleaned) continue;
+      const hasMixedCase = /[a-z]/.test(cleaned) && /[A-Z]/.test(cleaned);
+      const hasUnderscore = cleaned.includes("_");
+      const hasNamespaceSep = cleaned.includes("::") || cleaned.includes(".");
+      const isAllCaps = cleaned.length >= 3 && /^[A-Z0-9_]+$/.test(cleaned);
+      if (hasMixedCase || hasUnderscore || hasNamespaceSep || isAllCaps) {
+        anchors.push(cleaned);
+      }
+    }
+    return anchors;
+  }
+  function applySymbolAnchorRerank(results, anchors) {
+    if (anchors.length === 0 || results.length === 0) return results;
+    const lowerAnchors = anchors.map((a) => a.toLowerCase());
+    const scored = results.map((r, idx) => {
+      const fp = (r.file_path || "").toLowerCase();
+      const content = (r.content || "").toLowerCase();
+      let anchorHits = 0;
+      for (const anchor of lowerAnchors) {
+        if (fp.includes(anchor) || content.includes(anchor)) anchorHits++;
+      }
+      const isNoisy = isArtifactLikePath(r.file_path || "");
+      return { item: r, anchorHits, isNoisy, originalIdx: idx };
+    });
+    scored.sort((a, b) => {
+      if (b.anchorHits !== a.anchorHits) return b.anchorHits - a.anchorHits;
+      if (a.isNoisy !== b.isNoisy) return a.isNoisy ? 1 : -1;
+      return a.originalIdx - b.originalIdx;
+    });
+    return scored.map((s) => s.item);
+  }
+  function deduplicateSearchResults(results) {
+    const seen = /* @__PURE__ */ new Set();
+    return results.filter((r) => {
+      const fp = r.file_path ? canonicalizeRepoPath(r.file_path) : "";
+      const startLine = r.start_line || r.metadata?.start_line || "";
+      const key = fp ? `${fp}:${startLine}` : "";
+      if (!key) return true;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
   async function runLocalRipgrep(query, cwd, limit = 10) {
     try {
       const pattern = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -25521,7 +25923,7 @@ This saves ~80% tokens compared to including full chat history.`,
         project_id: external_exports.string().uuid().optional(),
         max_tokens: external_exports.number().optional().describe("Maximum tokens for context (default: 800)"),
         format: external_exports.enum(["minified", "readable", "structured"]).optional().describe("Context format (default: minified)"),
-        mode: external_exports.enum(["standard", "pack"]).optional().describe("Context pack mode (default: pack when enabled)"),
+        mode: external_exports.enum(["standard", "pack", "fast"]).optional().describe("Context mode: standard (default), pack (includes code context), fast (cached quick response)"),
         distill: external_exports.boolean().optional().describe("Use distillation for context pack (default: true)"),
         session_tokens: external_exports.number().optional().describe("Cumulative session token count for context pressure calculation"),
         context_threshold: external_exports.number().optional().describe("Custom context window threshold (defaults to 70k)"),
@@ -25612,21 +26014,149 @@ This saves ~80% tokens compared to including full chat history.`,
       if (!clientName && detectedClientInfo) {
         clientName = detectedClientInfo.name;
       }
-      const result = await client.getSmartContext({
-        user_message: input.user_message,
-        workspace_id: workspaceId,
-        project_id: projectId,
-        max_tokens: input.max_tokens,
-        format: input.format,
-        mode: input.mode,
-        distill: input.distill,
-        session_tokens: sessionTokens,
-        context_threshold: contextThreshold,
-        save_exchange: input.save_exchange,
-        session_id: sessionId,
-        client_name: clientName,
-        assistant_message: input.assistant_message
-      });
+      const conversationTurns = sessionManager?.getConversationTurns() ?? 0;
+      const isFastMode = input.mode === "fast";
+      const folderPathCtx = resolveFolderPath(void 0, sessionManager);
+      if (isFastMode && workspaceId) {
+        const fastResult = await client.getContextFast({ workspace_id: workspaceId, project_id: projectId });
+        if (fastResult && fastResult.context) {
+          const roundTripMs2 = Date.now() - startTime;
+          const timingStr2 = SHOW_TIMING ? ` | ${roundTripMs2}ms` : "";
+          return {
+            content: [{ type: "text", text: `${fastResult.context}
+---
+fast mode${timingStr2}` }]
+          };
+        }
+      }
+      const cachedResult = conversationTurns >= 2 ? getWarmCache(workspaceId, projectId) : null;
+      let proactiveVcsPromise;
+      if (conversationTurns <= 3 && workspaceId && !isFastMode) {
+        proactiveVcsPromise = (async () => {
+          const repos = await client.getVcsRepos({ workspace_id: workspaceId, per_page: 10 });
+          if (repos.length === 0) return { repos: [], pulls: [], issues: [], activity: [], notifications: [] };
+          const pullPromises = repos.slice(0, 5).map(
+            (r) => client.getVcsResource({ workspace_id: workspaceId, path: `repos/${r.id || r.repo_id}/pulls`, per_page: 5 })
+          );
+          const issuePromises = repos.slice(0, 5).map(
+            (r) => client.getVcsResource({ workspace_id: workspaceId, path: `repos/${r.id || r.repo_id}/issues`, per_page: 5 })
+          );
+          const [pullResults, issueResults] = await Promise.all([
+            Promise.all(pullPromises),
+            Promise.all(issuePromises)
+          ]);
+          return {
+            repos,
+            pulls: pullResults.flat(),
+            issues: issueResults.flat(),
+            activity: [],
+            notifications: []
+          };
+        })().catch(() => ({ repos: [], pulls: [], issues: [], activity: [], notifications: [] }));
+      }
+      let recentChangesPromise;
+      if (conversationTurns <= 2 && folderPathCtx && !CONCISE_TOOL_TEXT && !isFastMode) {
+        recentChangesPromise = (async () => {
+          try {
+            const { stdout: stdout2 } = await execFileAsync("git", [
+              "log",
+              "--oneline",
+              "--format=%h %s (%ar)",
+              "-n5"
+            ], { cwd: folderPathCtx, timeout: 3e3, maxBuffer: 64 * 1024 });
+            return stdout2.trim();
+          } catch {
+            return "";
+          }
+        })();
+      }
+      let result;
+      if (cachedResult) {
+        result = cachedResult;
+        const fastOverlay = await client.getContextFast({ workspace_id: workspaceId, project_id: projectId });
+        if (fastOverlay?.context) {
+          result = { ...result, context: result.context + "\n" + fastOverlay.context };
+          if (fastOverlay.items && Array.isArray(fastOverlay.items)) {
+            result.items = [...result.items || [], ...fastOverlay.items];
+          }
+        }
+      } else {
+        result = await client.getSmartContext({
+          user_message: input.user_message,
+          workspace_id: workspaceId,
+          project_id: projectId,
+          max_tokens: input.max_tokens,
+          format: input.format,
+          mode: input.mode === "fast" ? "standard" : input.mode,
+          distill: input.distill,
+          session_tokens: sessionTokens,
+          context_threshold: contextThreshold,
+          save_exchange: input.save_exchange,
+          session_id: sessionId,
+          client_name: clientName,
+          assistant_message: input.assistant_message
+        });
+        if (workspaceId) {
+          setWarmCache(workspaceId, projectId, result);
+        }
+      }
+      const typedItems = Array.isArray(result.items) ? result.items : [];
+      const hasTypedItems = typedItems.length > 0;
+      const compact = COMPACT_OUTPUT || CONCISE_TOOL_TEXT;
+      let typedContextBlock = "";
+      if (hasTypedItems) {
+        const parts = [];
+        const prefItems = filterItemsByKind(typedItems, "preference");
+        const lessonItems = filterItemsByKind(typedItems, "lesson");
+        const vcsItems = filterItemsByKind(typedItems, "vcs");
+        const skillItems = filterItemsByKind(typedItems, "skill");
+        const snapItems = filterItemsByKind(typedItems, "transcript_snapshot");
+        const prefText = formatTypedPreferences(prefItems, compact);
+        if (prefText) parts.push(prefText);
+        const lessonText = formatTypedLessons(lessonItems, compact);
+        if (lessonText) parts.push(lessonText);
+        const vcsText = formatTypedVcs(vcsItems, compact);
+        if (vcsText) parts.push(vcsText);
+        const skillText = formatTypedSkills(skillItems, compact);
+        if (skillText) parts.push(skillText);
+        if (conversationTurns <= 3) {
+          const snapText = formatTypedSnapshots(snapItems, compact);
+          if (snapText) parts.push(snapText);
+        }
+        if (parts.length > 0) {
+          typedContextBlock = "\n" + parts.join("\n") + "\n";
+        }
+      }
+      let proactiveVcsBlock = "";
+      if (proactiveVcsPromise) {
+        try {
+          const vcsCtx = await proactiveVcsPromise;
+          if (!hasServerVcsItems(typedItems) && (vcsCtx.pulls.length > 0 || vcsCtx.issues.length > 0)) {
+            const vParts = [];
+            if (vcsCtx.pulls.length > 0) {
+              vParts.push(compact ? `[VCS] ${vcsCtx.pulls.length} open PR(s)` : `Open PRs: ${vcsCtx.pulls.length}`);
+            }
+            if (vcsCtx.issues.length > 0) {
+              vParts.push(compact ? `[VCS] ${vcsCtx.issues.length} open issue(s)` : `Open issues: ${vcsCtx.issues.length}`);
+            }
+            if (vParts.length > 0) proactiveVcsBlock = "\n" + vParts.join("\n");
+          }
+        } catch {
+        }
+      }
+      let recentChangesBlock = "";
+      if (recentChangesPromise) {
+        try {
+          const changes = await recentChangesPromise;
+          if (changes) {
+            recentChangesBlock = compact ? `
+[RECENT_CHANGES] ${changes.split("\n").slice(0, 3).join("; ")}` : `
+[RECENT_CHANGES]
+${changes}`;
+          }
+        } catch {
+        }
+      }
       if (sessionManager && result.token_estimate) {
         sessionManager.addTokens(result.token_estimate);
       }
@@ -25792,7 +26322,7 @@ ${versionWarningLine}` : "",
         // Reinforce context() must be called every message
         searchRulesLine
       ].filter(Boolean).join("");
-      const finalContext = postCompactContext + result.context;
+      const finalContext = postCompactContext + result.context + typedContextBlock + proactiveVcsBlock + recentChangesBlock;
       const textParts = [
         finalContext,
         footer,
@@ -26807,6 +27337,12 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
         if (authError) return authError;
         client.checkAndIndexChangedFiles().catch(() => {
         });
+        const folderPathForKeeper = resolveFolderPath(void 0, sessionManager);
+        const projectIdForKeeper = resolveProjectId(void 0);
+        if (folderPathForKeeper && projectIdForKeeper) {
+          indexKeeper.tick(projectIdForKeeper, folderPathForKeeper).catch(() => {
+          });
+        }
         const startTime = Date.now();
         const modeInput = input.mode || "auto";
         const modeRecommendation = recommendSearchMode(input.query);
@@ -26833,12 +27369,12 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             const project = await client.getProject(explicitProjectId);
             const projectWorkspaceId = normalizeUuid(project?.workspace_id || project?.workspaceId);
             if (workspaceId && projectWorkspaceId && projectWorkspaceId !== workspaceId) {
-              explicitProjectScopeNote = `Explicit project_id ${explicitProjectId} belongs to workspace ${projectWorkspaceId}; auto-corrected to current workspace ${workspaceId}.`;
+              explicitProjectScopeNote = `Explicit project_id ${explicitProjectId} belongs to a different workspace and was ignored. Do NOT pass this project_id again \u2014 omit it and let the session resolve the correct project scope automatically.`;
               explicitProjectId = void 0;
             }
           } catch (error) {
             if (isNotFoundError(error)) {
-              explicitProjectScopeNote = `Explicit project_id ${explicitProjectId} was not found; auto-corrected using folder/index project mapping.`;
+              explicitProjectScopeNote = `Explicit project_id ${explicitProjectId} was not found. Do NOT pass this project_id again \u2014 omit it and let the session resolve the correct project scope automatically.`;
               explicitProjectId = void 0;
             } else {
               throw error;
@@ -27098,6 +27634,10 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           hot_paths_hint: hotPathsHint,
           output_format: input.output_format || suggestOutputFormat(input.query, requestedMode === "team" ? "hybrid" : requestedMode)
         });
+        let parallelRgPromise;
+        if (containsCodeIdentifiers(input.query) && folderPath && requestedMode !== "pattern") {
+          parallelRgPromise = runLocalRipgrep(input.query, folderPath, input.limit || 10);
+        }
         if (requestedMode === "team") {
           try {
             const teamResult = await runSearchForMode("team", {
@@ -27125,6 +27665,18 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             try {
               const modeResult = await runSearchForMode(requestedMode, paramsForCandidate);
               const envelope = extractSearchEnvelope(modeResult.result);
+              if (isScopeInvalidResult(modeResult.result)) {
+                if (!selected) {
+                  selected = {
+                    index,
+                    project_id: candidateProjectId,
+                    result: modeResult.result,
+                    executedMode: modeResult.executedMode,
+                    fallbackNote: modeResult.fallbackNote
+                  };
+                }
+                continue;
+              }
               if (explicitProjectId && index === 0 && envelope.results.length === 0) {
                 explicitScopeHadNoResults = true;
               }
@@ -27148,7 +27700,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
                 };
               }
             } catch (error) {
-              if (isNotFoundError(error)) {
+              if (isNotFoundError(error) || isAccessDeniedError(error)) {
                 continue;
               }
               const errMsg = error instanceof Error ? error.message : String(error);
@@ -27224,7 +27776,59 @@ 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;
         let { results, total } = extractSearchEnvelope(selected.result);
-        if (results.length === 0 && folderPath) {
+        const scopeInvalid = isScopeInvalidResult(selected.result);
+        for (const r of results) {
+          if (r.file_path) {
+            const canonical = canonicalizeRepoPath(r.file_path);
+            if (canonical !== r.file_path) r.file_path = canonical;
+          }
+        }
+        results = deduplicateSearchResults(results);
+        if (shouldFilterArtifactPaths(selected.executedMode, input.query) && results.length > 0) {
+          const beforeLen = results.length;
+          results = results.filter(
+            (r) => r.file_path ? !isArtifactLikePath(r.file_path) : true
+          );
+          if (results.length < beforeLen) {
+            modeFallbackNote = appendNote(
+              modeFallbackNote,
+              `Filtered ${beforeLen - results.length} artifact/generated path(s).`
+            );
+          }
+        }
+        if (results.length === 0 && !scopeInvalid) {
+          const escalationModes = (() => {
+            switch (selected.executedMode) {
+              case "semantic":
+                return ["hybrid", "keyword"];
+              case "hybrid":
+                return ["keyword"];
+              case "keyword":
+                return ["hybrid"];
+              default:
+                return [];
+            }
+          })();
+          for (const escMode of escalationModes) {
+            try {
+              const escResult = await runSearchForMode(escMode, {
+                ...baseParams,
+                workspace_id: workspaceId,
+                project_id: selected.project_id
+              });
+              const escEnvelope = extractSearchEnvelope(escResult.result);
+              if (escEnvelope.results.length > 0) {
+                results = escEnvelope.results;
+                total = escEnvelope.total;
+                modeFallbackNote = appendNote(modeFallbackNote, `${selected.executedMode} returned 0 results; escalated to ${escMode}.`);
+                break;
+              }
+            } catch {
+            }
+          }
+        }
+        const parallelCoversFallback = !!parallelRgPromise && selected.executedMode !== "pattern";
+        if (results.length === 0 && folderPath && !parallelCoversFallback) {
           const rgResults = await runLocalRipgrep(input.query, folderPath, input.limit || 10);
           if (rgResults.length > 0) {
             results = rgResults.map((r) => ({
@@ -27241,6 +27845,24 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             );
           }
         }
+        if (parallelRgPromise) {
+          try {
+            const parallelRgResults = await parallelRgPromise;
+            if (parallelRgResults.length > 0) {
+              const existingPaths = new Set(results.map((r) => r.file_path).filter(Boolean));
+              const newEntries = parallelRgResults.filter((r) => !existingPaths.has(r.file_path)).map((r) => ({ file_path: r.file_path, start_line: r.line, content: r.content, score: r.score, source: "local_ripgrep" }));
+              if (newEntries.length > 0) {
+                results = [...results, ...newEntries];
+              }
+            }
+          } catch {
+          }
+        }
+        const symbolAnchors = extractSymbolAnchors(input.query);
+        if (symbolAnchors.length > 0 && results.length > 1) {
+          results = applySymbolAnchorRerank(results, symbolAnchors);
+        }
+        total = results.length;
         const resultPaths = results.map((item) => typeof item?.file_path === "string" ? item.file_path : "").filter(Boolean);
         if (resultPaths.length > 0) {
           globalHotPathStore.recordPaths(
@@ -27255,13 +27877,13 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
         } else {
           lines.push(`\u{1F50D} ${total} results for "${input.query}"`);
         }
-        if (modeAutoSelected) {
+        if (modeAutoSelected && !(CONCISE_TOOL_TEXT && results.length > 0)) {
           lines.push(`Mode auto-selected: \`${requestedMode}\`. ${modeRecommendation.reason}`);
         }
-        if (modeFallbackNote) {
+        if (modeFallbackNote && !(CONCISE_TOOL_TEXT && results.length > 0)) {
           lines.push(modeFallbackNote);
         }
-        if (hotPathsHint?.entries?.length) {
+        if (hotPathsHint?.entries?.length && !CONCISE_TOOL_TEXT) {
           lines.push(
             `Hot-path hint active (${hotPathsHint.entries.length} paths, confidence ${(hotPathsHint.confidence * 100).toFixed(0)}%).`
           );
@@ -29941,6 +30563,19 @@ ${formatContent(response)}`
             }
             const validPath = await validateReadableDirectory(ingestPath);
             if (!validPath.ok) {
+              try {
+                const pathExists = await fs6.promises.stat(ingestPath).then(() => true).catch(() => false);
+                if (!pathExists) {
+                  const apiResult = await client.ingestFromPath(projectId, ingestPath, {
+                    force: input.force
+                  });
+                  return {
+                    content: [{ type: "text", text: `Delegated ingest to API for path: ${ingestPath}
+${formatContent(apiResult)}` }]
+                  };
+                }
+              } catch {
+              }
               return errorResult(validPath.error);
             }
             const ingestOptions = {
@@ -31525,13 +32160,35 @@ Each domain tool has an 'action' parameter for specific operations.` : "";
     "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).`,
+      description: `Git version control and remote repo operations.
+
+Local git actions: status, diff, log, blame, branches, stash_list
+Remote API actions: list_repos, get_repo, sync_repo, list_pulls, get_pull, get_pull_diff, get_pull_comments, get_pull_commits, get_pull_checks, get_pull_summary, summarize_pull, review_pull, comment_pull, merge_pull, list_issues, get_issue, create_issue, update_issue, comment_issue, list_commits, get_commit, get_commit_diff, compare_refs, list_branches_remote, list_tags, get_tree, get_blob, search_code, search_vcs, get_activity, list_notifications, mark_notification_read, mark_all_notifications_read, list_links, create_link, delete_link, list_automations, create_automation, update_automation, delete_automation, register_webhook, unregister_webhook`,
       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)")
+        action: external_exports.string().describe("VCS action to perform"),
+        workspace_id: external_exports.string().uuid().optional().describe("Workspace ID for remote VCS actions"),
+        repo_ref: external_exports.string().optional().describe("Repository reference (owner/repo) for remote actions"),
+        repo_id: external_exports.string().optional().describe("Repository ID for remote actions"),
+        path: external_exports.string().optional().describe("File path for diff/blame/tree/blob"),
+        ref: external_exports.string().optional().describe("Git ref (branch, tag, commit)"),
+        base_ref: external_exports.string().optional().describe("Base ref for compare_refs"),
+        limit: external_exports.number().optional().describe("Max entries (default: 20)"),
+        staged: external_exports.boolean().optional().describe("Show staged changes only (for diff)"),
+        pull_number: external_exports.number().optional().describe("Pull request number"),
+        issue_number: external_exports.number().optional().describe("Issue number"),
+        notification_id: external_exports.string().optional().describe("Notification ID"),
+        link_id: external_exports.string().optional().describe("Link ID"),
+        automation_id: external_exports.string().optional().describe("Automation ID"),
+        title: external_exports.string().optional().describe("Title for create_issue"),
+        body: external_exports.string().optional().describe("Body content"),
+        state: external_exports.string().optional().describe("State filter (open/closed)"),
+        labels: external_exports.array(external_exports.string()).optional().describe("Labels for issues"),
+        per_page: external_exports.number().optional().describe("Results per page"),
+        page: external_exports.number().optional().describe("Page number"),
+        event: external_exports.string().optional().describe("Review event (APPROVE/REQUEST_CHANGES/COMMENT)"),
+        provider: external_exports.string().optional().describe("VCS provider (github/gitlab/bitbucket)"),
+        query: external_exports.string().optional().describe("Search query"),
+        data: external_exports.record(external_exports.any()).optional().describe("Additional data for create/update operations")
       })
     },
     async (input) => {
@@ -31551,60 +32208,164 @@ Each domain tool has an 'action' parameter for specific operations.` : "";
           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." }] };
+      const localActions = /* @__PURE__ */ new Set(["status", "diff", "log", "blame", "branches", "stash_list"]);
+      if (localActions.has(input.action)) {
+        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 local vcs action: ${input.action}`);
         }
+      }
+      let wsId = resolveWorkspaceId(input.workspace_id);
+      if (!wsId) {
+        return errorResult("Remote VCS actions require a workspace_id. Call init() first or pass workspace_id.");
+      }
+      const resolveRepoPath = () => {
+        if (input.repo_id) return `repos/${input.repo_id}`;
+        if (input.repo_ref) return `repos/${encodeURIComponent(input.repo_ref)}`;
+        return "repos";
+      };
+      const repoPath = resolveRepoPath();
+      const q = {
+        state: input.state,
+        per_page: input.per_page,
+        page: input.page
+      };
+      switch (input.action) {
+        case "list_repos":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: "repos", query: q })) }] };
+        case "get_repo":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: repoPath })) }] };
+        case "sync_repo":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "POST", path: `${repoPath}/sync` })) }] };
+        case "list_pulls":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/pulls`, query: q })) }] };
+        case "get_pull":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/pulls/${input.pull_number}` })) }] };
+        case "get_pull_diff":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/pulls/${input.pull_number}/diff` })) }] };
+        case "get_pull_comments":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/pulls/${input.pull_number}/comments` })) }] };
+        case "get_pull_commits":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/pulls/${input.pull_number}/commits` })) }] };
+        case "get_pull_checks":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/pulls/${input.pull_number}/checks` })) }] };
+        case "get_pull_summary":
+        case "summarize_pull":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/pulls/${input.pull_number}/summary` })) }] };
+        case "review_pull":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "POST", path: `${repoPath}/pulls/${input.pull_number}/reviews`, body: { event: input.event || "COMMENT", body: input.body } })) }] };
+        case "comment_pull":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "POST", path: `${repoPath}/pulls/${input.pull_number}/comments`, body: { body: input.body } })) }] };
+        case "merge_pull":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "PUT", path: `${repoPath}/pulls/${input.pull_number}/merge`, body: input.data })) }] };
+        case "list_issues":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/issues`, query: q })) }] };
+        case "get_issue":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/issues/${input.issue_number}` })) }] };
+        case "create_issue":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "POST", path: `${repoPath}/issues`, body: { title: input.title, body: input.body, labels: input.labels } })) }] };
+        case "update_issue":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "PATCH", path: `${repoPath}/issues/${input.issue_number}`, body: { title: input.title, body: input.body, state: input.state, labels: input.labels, ...input.data } })) }] };
+        case "comment_issue":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "POST", path: `${repoPath}/issues/${input.issue_number}/comments`, body: { body: input.body } })) }] };
+        case "list_commits":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/commits`, query: { ...q, ref: input.ref } })) }] };
+        case "get_commit":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/commits/${input.ref}` })) }] };
+        case "get_commit_diff":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/commits/${input.ref}/diff` })) }] };
+        case "compare_refs":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/compare/${input.base_ref}...${input.ref}` })) }] };
+        case "list_branches_remote":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/branches`, query: q })) }] };
+        case "list_tags":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/tags`, query: q })) }] };
+        case "get_tree":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/tree`, query: { ref: input.ref, path: input.path } })) }] };
+        case "get_blob":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/blob`, query: { ref: input.ref, path: input.path } })) }] };
+        case "search_code":
+        case "search_vcs":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/search`, query: { q: input.query, ...q } })) }] };
+        case "get_activity":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/activity`, query: { limit: input.limit } })) }] };
+        case "list_notifications":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: "notifications", query: q })) }] };
+        case "mark_notification_read":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "PUT", path: `notifications/${input.notification_id}/read` })) }] };
+        case "mark_all_notifications_read":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "PUT", path: "notifications/read-all" })) }] };
+        case "list_links":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/links` })) }] };
+        case "create_link":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "POST", path: `${repoPath}/links`, body: input.data })) }] };
+        case "delete_link":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "DELETE", path: `${repoPath}/links/${input.link_id}` })) }] };
+        case "list_automations":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "GET", path: `${repoPath}/automations` })) }] };
+        case "create_automation":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "POST", path: `${repoPath}/automations`, body: input.data })) }] };
+        case "update_automation":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "PUT", path: `${repoPath}/automations/${input.automation_id}`, body: input.data })) }] };
+        case "delete_automation":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "DELETE", path: `${repoPath}/automations/${input.automation_id}` })) }] };
+        case "register_webhook":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "POST", path: `${repoPath}/webhooks`, body: input.data })) }] };
+        case "unregister_webhook":
+          return { content: [{ type: "text", text: formatContent(await client.vcsApiRequest({ workspace_id: wsId, method: "DELETE", path: `${repoPath}/webhooks`, body: input.data })) }] };
         default:
-          return errorResult(`Unknown vcs action: ${input.action}`);
+          return errorResult(`Unknown vcs action: ${input.action}. Use 'status', 'diff', 'log', 'blame', 'branches', 'stash_list' for local git, or remote API actions like 'list_repos', 'list_pulls', 'list_issues', etc.`);
       }
     }
   );
@@ -33403,13 +34164,13 @@ async function runHttpGateway() {
 // src/index.ts
 init_version();
 import { existsSync as existsSync16, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir19 } from "os";
+import { homedir as homedir20 } from "os";
 import { join as join22 } from "path";
 
 // src/setup.ts
 import * as fs8 from "node:fs/promises";
 import * as path9 from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 init_rules_templates();
@@ -33418,12 +34179,12 @@ init_version();
 // src/credentials.ts
 import * as fs7 from "node:fs/promises";
 import * as path8 from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 function normalizeApiUrl(input) {
   return String(input ?? "").trim().replace(/\/+$/, "");
 }
 function credentialsFilePath() {
-  return path8.join(homedir6(), ".contextstream", "credentials.json");
+  return path8.join(homedir7(), ".contextstream", "credentials.json");
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -33702,7 +34463,7 @@ async function upsertTextFile(filePath, content, _marker) {
   return replaced.status;
 }
 function globalRulesPathForEditor(editor) {
-  const home = homedir7();
+  const home = homedir8();
   switch (editor) {
     case "codex":
       return path9.join(home, ".codex", "AGENTS.md");
@@ -33737,7 +34498,7 @@ async function anyPathExists(paths) {
   return false;
 }
 async function isCodexInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const envHome = process.env.CODEX_HOME;
   const candidates = [
     envHome,
@@ -33748,7 +34509,7 @@ async function isCodexInstalled() {
   return anyPathExists(candidates);
 }
 function openCodeConfigPath() {
-  const home = homedir7();
+  const home = homedir8();
   const xdgConfigHome = process.env.XDG_CONFIG_HOME;
   if (process.platform === "win32") {
     const appData = process.env.APPDATA || path9.join(home, "AppData", "Roaming");
@@ -33760,7 +34521,7 @@ function openCodeConfigPath() {
 async function isOpenCodeInstalled() {
   const configPath = openCodeConfigPath();
   const configDir = path9.dirname(configPath);
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [
     configDir,
     configPath,
@@ -33770,7 +34531,7 @@ async function isOpenCodeInstalled() {
   return anyPathExists(candidates);
 }
 async function isClaudeInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [path9.join(home, ".claude"), path9.join(home, ".config", "claude")];
   const desktopConfig = claudeDesktopConfigPath();
   if (desktopConfig) candidates.push(desktopConfig);
@@ -33783,7 +34544,7 @@ async function isClaudeInstalled() {
   return anyPathExists(candidates);
 }
 async function isClineInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [
     path9.join(home, "Documents", "Cline"),
     path9.join(home, ".cline"),
@@ -33792,7 +34553,7 @@ async function isClineInstalled() {
   return anyPathExists(candidates);
 }
 async function isCopilotInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [
     path9.join(home, ".copilot"),
     path9.join(home, ".config", "github-copilot"),
@@ -33802,7 +34563,7 @@ async function isCopilotInstalled() {
   return anyPathExists(candidates);
 }
 async function isKiloInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [
     kiloConfigDir(),
     path9.join(home, ".kilocode"),
@@ -33811,17 +34572,17 @@ async function isKiloInstalled() {
   return anyPathExists(candidates);
 }
 async function isRooInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [path9.join(home, ".roo"), path9.join(home, ".config", "roo")];
   return anyPathExists(candidates);
 }
 async function isAiderInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [path9.join(home, ".aider.conf.yml"), path9.join(home, ".config", "aider")];
   return anyPathExists(candidates);
 }
 async function isCursorInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [path9.join(home, ".cursor")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Cursor.app");
@@ -33844,7 +34605,7 @@ async function isCursorInstalled() {
   return anyPathExists(candidates);
 }
 async function isWindsurfInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [path9.join(home, ".codeium", "windsurf")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Windsurf.app");
@@ -33867,7 +34628,7 @@ async function isWindsurfInstalled() {
   return anyPathExists(candidates);
 }
 async function isAntigravityInstalled() {
-  const home = homedir7();
+  const home = homedir8();
   const candidates = [path9.join(home, ".gemini")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Antigravity.app");
@@ -34071,7 +34832,7 @@ function buildContextStreamOpenCodeLocalServer(params) {
   };
 }
 function kiloConfigDir() {
-  const home = homedir7();
+  const home = homedir8();
   if (process.platform === "win32") {
     const appData = process.env.APPDATA || path9.join(home, "AppData", "Roaming");
     return path9.join(appData, "kilo");
@@ -34206,7 +34967,7 @@ async function upsertOpenCodeMcpConfig(filePath, server) {
   return before === after ? "skipped" : "updated";
 }
 function claudeDesktopConfigPath() {
-  const home = homedir7();
+  const home = homedir8();
   if (process.platform === "darwin") {
     return path9.join(
       home,
@@ -34985,7 +35746,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         if (mcpScope === "project" && editor !== "codex") continue;
         try {
           if (editor === "codex") {
-            const filePath = path9.join(homedir7(), ".codex", "config.toml");
+            const filePath = path9.join(homedir8(), ".codex", "config.toml");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -35001,7 +35762,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "copilot") {
-            const filePath = path9.join(homedir7(), ".copilot", "mcp-config.json");
+            const filePath = path9.join(homedir8(), ".copilot", "mcp-config.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -35056,7 +35817,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "cursor") {
-            const filePath = path9.join(homedir7(), ".cursor", "mcp.json");
+            const filePath = path9.join(homedir8(), ".cursor", "mcp.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -35068,7 +35829,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "windsurf") {
-            const filePath = path9.join(homedir7(), ".codeium", "windsurf", "mcp_config.json");
+            const filePath = path9.join(homedir8(), ".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}`);
@@ -35338,7 +36099,7 @@ Applying to ${projects.length} project(s)...`);
             }
             if (editor === "windsurf") {
               console.log(
-                `- ${EDITOR_LABELS[editor]}: uses global MCP config only (${path9.join(homedir7(), ".codeium", "windsurf", "mcp_config.json")}).`
+                `- ${EDITOR_LABELS[editor]}: uses global MCP config only (${path9.join(homedir8(), ".codeium", "windsurf", "mcp_config.json")}).`
               );
               continue;
             }
@@ -35556,7 +36317,7 @@ Applying to ${projects.length} project(s)...`);
 // src/index.ts
 var ENABLE_PROMPTS2 = (process.env.CONTEXTSTREAM_ENABLE_PROMPTS || "true").toLowerCase() !== "false";
 function showFirstRunMessage() {
-  const configDir = join22(homedir19(), ".contextstream");
+  const configDir = join22(homedir20(), ".contextstream");
   const starShownFile = join22(configDir, ".star-shown");
   if (existsSync16(starShownFile)) {
     return;