@contextstream/mcp-server 0.4.15 → 0.4.17

package/dist/index.js

@@ -4050,6 +4050,131 @@ var coerce = {
 };
 var NEVER = INVALID;
 
+// src/version.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var UPGRADE_COMMAND = "npm update -g @contextstream/mcp-server";
+var NPM_LATEST_URL = "https://registry.npmjs.org/@contextstream/mcp-server/latest";
+function getVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkg = require2("../package.json");
+    const version = pkg?.version;
+    if (typeof version === "string" && version.trim()) return version.trim();
+  } catch {
+  }
+  return "unknown";
+}
+var VERSION = getVersion();
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] ?? 0;
+    const p2 = parts2[i] ?? 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var latestVersionPromise = null;
+function getCacheFilePath() {
+  return join(homedir(), ".contextstream", "version-cache.json");
+}
+function readCache() {
+  try {
+    const cacheFile = getCacheFilePath();
+    if (!existsSync(cacheFile)) return null;
+    const data = JSON.parse(readFileSync(cacheFile, "utf-8"));
+    if (Date.now() - data.checkedAt > CACHE_TTL_MS) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(latestVersion) {
+  try {
+    const configDir = join(homedir(), ".contextstream");
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+    const cacheFile = getCacheFilePath();
+    writeFileSync(cacheFile, JSON.stringify({
+      latestVersion,
+      checkedAt: Date.now()
+    }));
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(NPM_LATEST_URL, {
+      signal: controller.signal,
+      headers: { "Accept": "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveLatestVersion() {
+  const cached = readCache();
+  if (cached) return cached.latestVersion;
+  if (!latestVersionPromise) {
+    latestVersionPromise = fetchLatestVersion().finally(() => {
+      latestVersionPromise = null;
+    });
+  }
+  const latestVersion = await latestVersionPromise;
+  if (latestVersion) {
+    writeCache(latestVersion);
+  }
+  return latestVersion;
+}
+async function checkForUpdates() {
+  const notice = await getUpdateNotice();
+  if (notice?.behind) {
+    showUpdateWarning(notice.current, notice.latest);
+  }
+}
+function showUpdateWarning(currentVersion, latestVersion) {
+  console.error("");
+  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(`\u26A0\uFE0F  Update available: v${currentVersion} \u2192 v${latestVersion}`);
+  console.error("");
+  console.error(`   Run: ${UPGRADE_COMMAND}`);
+  console.error("");
+  console.error("   Then restart your AI tool to use the new version.");
+  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("");
+}
+async function getUpdateNotice() {
+  const currentVersion = VERSION;
+  if (currentVersion === "unknown") return null;
+  try {
+    const latestVersion = await resolveLatestVersion();
+    if (!latestVersion) return null;
+    if (compareVersions(currentVersion, latestVersion) < 0) {
+      return {
+        current: currentVersion,
+        latest: latestVersion,
+        behind: true,
+        upgrade_command: UPGRADE_COMMAND
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+
 // src/config.ts
 var DEFAULT_API_URL = "https://api.contextstream.io";
 function parseBooleanEnv(value) {
@@ -4065,7 +4190,7 @@ var configSchema = external_exports.object({
   jwt: external_exports.string().min(1).optional(),
   defaultWorkspaceId: external_exports.string().uuid().optional(),
   defaultProjectId: external_exports.string().uuid().optional(),
-  userAgent: external_exports.string().default("contextstream-mcp/0.1.0"),
+  userAgent: external_exports.string().default(`contextstream-mcp/${VERSION}`),
   allowHeaderAuth: external_exports.boolean().optional(),
   contextPackEnabled: external_exports.boolean().default(true)
 });
@@ -4732,131 +4857,6 @@ var CacheKeys = {
 };
 var globalCache = new MemoryCache();
 
-// src/version.ts
-import { createRequire } from "module";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { homedir } from "os";
-import { join as join3 } from "path";
-var UPGRADE_COMMAND = "npm update -g @contextstream/mcp-server";
-var NPM_LATEST_URL = "https://registry.npmjs.org/@contextstream/mcp-server/latest";
-function getVersion() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const pkg = require2("../package.json");
-    const version = pkg?.version;
-    if (typeof version === "string" && version.trim()) return version.trim();
-  } catch {
-  }
-  return "unknown";
-}
-var VERSION = getVersion();
-function compareVersions(v1, v2) {
-  const parts1 = v1.split(".").map(Number);
-  const parts2 = v2.split(".").map(Number);
-  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-    const p1 = parts1[i] ?? 0;
-    const p2 = parts2[i] ?? 0;
-    if (p1 < p2) return -1;
-    if (p1 > p2) return 1;
-  }
-  return 0;
-}
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var latestVersionPromise = null;
-function getCacheFilePath() {
-  return join3(homedir(), ".contextstream", "version-cache.json");
-}
-function readCache() {
-  try {
-    const cacheFile = getCacheFilePath();
-    if (!existsSync2(cacheFile)) return null;
-    const data = JSON.parse(readFileSync2(cacheFile, "utf-8"));
-    if (Date.now() - data.checkedAt > CACHE_TTL_MS) return null;
-    return data;
-  } catch {
-    return null;
-  }
-}
-function writeCache(latestVersion) {
-  try {
-    const configDir = join3(homedir(), ".contextstream");
-    if (!existsSync2(configDir)) {
-      mkdirSync2(configDir, { recursive: true });
-    }
-    const cacheFile = getCacheFilePath();
-    writeFileSync2(cacheFile, JSON.stringify({
-      latestVersion,
-      checkedAt: Date.now()
-    }));
-  } catch {
-  }
-}
-async function fetchLatestVersion() {
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch(NPM_LATEST_URL, {
-      signal: controller.signal,
-      headers: { "Accept": "application/json" }
-    });
-    clearTimeout(timeout);
-    if (!response.ok) return null;
-    const data = await response.json();
-    return typeof data.version === "string" ? data.version : null;
-  } catch {
-    return null;
-  }
-}
-async function resolveLatestVersion() {
-  const cached = readCache();
-  if (cached) return cached.latestVersion;
-  if (!latestVersionPromise) {
-    latestVersionPromise = fetchLatestVersion().finally(() => {
-      latestVersionPromise = null;
-    });
-  }
-  const latestVersion = await latestVersionPromise;
-  if (latestVersion) {
-    writeCache(latestVersion);
-  }
-  return latestVersion;
-}
-async function checkForUpdates() {
-  const notice = await getUpdateNotice();
-  if (notice?.behind) {
-    showUpdateWarning(notice.current, notice.latest);
-  }
-}
-function showUpdateWarning(currentVersion, latestVersion) {
-  console.error("");
-  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(`\u26A0\uFE0F  Update available: v${currentVersion} \u2192 v${latestVersion}`);
-  console.error("");
-  console.error(`   Run: ${UPGRADE_COMMAND}`);
-  console.error("");
-  console.error("   Then restart your AI tool to use the new version.");
-  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("");
-}
-async function getUpdateNotice() {
-  const currentVersion = VERSION;
-  if (currentVersion === "unknown") return null;
-  try {
-    const latestVersion = await resolveLatestVersion();
-    if (!latestVersion) return null;
-    if (compareVersions(currentVersion, latestVersion) < 0) {
-      return {
-        current: currentVersion,
-        latest: latestVersion,
-        behind: true,
-        upgrade_command: UPGRADE_COMMAND
-      };
-    }
-  } catch {
-  }
-  return null;
-}
-
 // src/client.ts
 var uuidSchema = external_exports.string().uuid();
 function unwrapApiResponse(result) {
@@ -6587,7 +6587,10 @@ var ContextStreamClient = class {
           max_tokens: maxTokens,
           format,
           mode,
-          distill: params.distill
+          distill: params.distill,
+          client_version: VERSION,
+          rules_version: VERSION,
+          notice_inline: false
         }
       });
       const data = unwrapApiResponse(apiResult);
@@ -7469,9 +7472,11 @@ W:${wsHint}
 // src/tools.ts
 import * as fs3 from "node:fs";
 import * as path4 from "node:path";
+import { homedir as homedir2 } from "node:os";
 
 // src/rules-templates.ts
 var DEFAULT_CLAUDE_MCP_SERVER_NAME = "contextstream";
+var RULES_VERSION = VERSION === "unknown" ? "0.0.0" : VERSION;
 var CONTEXTSTREAM_TOOL_NAMES = [
   // Standalone tools (always present)
   "session_init",
@@ -7507,6 +7512,7 @@ var CONTEXTSTREAM_RULES_FULL = `
 
 You have access to ContextStream MCP tools for persistent memory and context.
 v0.4.x uses **~11 consolidated domain tools** for ~75% token reduction vs previous versions.
+Rules Version: ${RULES_VERSION}
 
 ## TL;DR - REQUIRED EVERY MESSAGE
 
@@ -7578,6 +7584,13 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 ---
 
+### Rules Update Notices
+
+- If you see **[RULES_NOTICE]**, update rules via \`generate_editor_rules(folder_path="<cwd>")\` (or rerun setup).
+- If you see **[VERSION_NOTICE]**, tell the user to update MCP using the provided command.
+
+---
+
 ### Preferences & Lessons (Use Early)
 
 - If preferences/style matter: \`session(action="user_context")\`
@@ -7595,6 +7608,7 @@ Before searching files or code, confirm the project is indexed and the graph is
    - Local repo: \`project(action="ingest_local", path="<cwd>")\`
    - Otherwise: \`project(action="index")\`
 3. If graph queries are empty/unavailable: \`graph(action="ingest")\`
+4. If indexing is in progress, tell the user and wait; do not fall back to local scans.
 
 Only after this preflight, proceed with search/analysis below.
 
@@ -7602,9 +7616,12 @@ Only after this preflight, proceed with search/analysis below.
 
 **Search order:**
 1. \`session(action="smart_search", query="...")\` - context-enriched
-2. \`search(mode="hybrid", query="...")\` - semantic + keyword
-3. \`graph(action="dependencies", ...)\` - code structure
-4. Local repo scans (rg/ls/find) - only if ContextStream returns no results
+2. \`search(mode="hybrid", query="...")\` or \`search(mode="keyword", query="<filename>")\`
+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 or is unavailable
+
+Use ContextStream results directly; only open files if you need exact code.
 
 **Code Analysis:**
 - Dependencies: \`graph(action="dependencies", file_path="...")\`
@@ -7684,6 +7701,7 @@ var CONTEXTSTREAM_RULES_MINIMAL = `
 ## ContextStream v0.4.x (Consolidated Domain Tools)
 
 v0.4.x uses ~11 consolidated domain tools for ~75% token reduction vs previous versions.
+Rules Version: ${RULES_VERSION}
 
 ### Required Every Message
 
@@ -7705,7 +7723,7 @@ v0.4.x uses ~11 consolidated domain tools for ~75% token reduction vs previous v
 | \`session\` | \`session(action="capture", ...)\` \u2014 actions: capture, capture_lesson, get_lessons, recall, remember, user_context, summary, compress, delta, smart_search |
 | \`memory\` | \`memory(action="list_events", ...)\` \u2014 CRUD for events/nodes, search, decisions, timeline, summary |
 | \`graph\` | \`graph(action="dependencies", ...)\` \u2014 dependencies, impact, call_path, related, ingest |
-| \`project\` | \`project(action="list", ...)\` \u2014 list, get, create, update, index, statistics |
+| \`project\` | \`project(action="list", ...)\` - list, get, create, update, index, overview, statistics, files, index_status, ingest_local |
 | \`workspace\` | \`workspace(action="list", ...)\` \u2014 list, get, associate, bootstrap |
 | \`integration\` | \`integration(provider="github", action="search", ...)\` \u2014 GitHub/Slack integration |
 | \`help\` | \`help(action="tools")\` \u2014 tools, auth, version, editor_rules |
@@ -7715,8 +7733,10 @@ v0.4.x uses ~11 consolidated domain tools for ~75% token reduction vs previous v
 - **First message**: Always call \`session_init\` with context_hint
 - **Every message after**: Always call \`context_smart\` BEFORE responding (semantic search for relevant context)
 - **Before searching files/code**: Check \`project(action="index_status")\`; if missing/stale run \`project(action="ingest_local", path="<cwd>")\` or \`project(action="index")\`, and use \`graph(action="ingest")\` if needed
-- **For discovery**: Use \`session(action="smart_search")\` or \`search(mode="hybrid")\` before local repo scans
+- **For discovery**: Use \`session(action="smart_search")\` or \`search(mode="hybrid")\` before any local repo scans
+- **For file/function/config lookups**: Use \`search\`/\`graph\` first; only fall back to rg/ls/find if ContextStream returns no results
 - **For code analysis**: Use \`graph(action="dependencies")\` or \`graph(action="impact")\` for call/dependency analysis
+- **On [RULES_NOTICE]**: Use \`generate_editor_rules(folder_path="<cwd>")\` to update rules
 - **After completing work**: Always capture decisions/insights with \`session(action="capture")\`
 - **On mistakes/corrections**: Immediately capture lessons with \`session(action="capture_lesson")\`
 
@@ -8042,6 +8062,235 @@ function normalizeUuid(value) {
   if (!value) return void 0;
   return uuidSchema2.safeParse(value).success ? value : void 0;
 }
+var RULES_NOTICE_CACHE_TTL_MS = 10 * 60 * 1e3;
+var RULES_VERSION_REGEX = /Rules Version:\s*([0-9][0-9A-Za-z.\-]*)/i;
+var RULES_PROJECT_FILES = {
+  codex: "AGENTS.md",
+  claude: "CLAUDE.md",
+  cursor: ".cursorrules",
+  windsurf: ".windsurfrules",
+  cline: ".clinerules",
+  kilo: path4.join(".kilocode", "rules", "contextstream.md"),
+  roo: path4.join(".roo", "rules", "contextstream.md"),
+  aider: ".aider.conf.yml"
+};
+var RULES_GLOBAL_FILES = {
+  codex: [path4.join(homedir2(), ".codex", "AGENTS.md")],
+  windsurf: [path4.join(homedir2(), ".codeium", "windsurf", "memories", "global_rules.md")],
+  kilo: [path4.join(homedir2(), ".kilocode", "rules", "contextstream.md")],
+  roo: [path4.join(homedir2(), ".roo", "rules", "contextstream.md")]
+};
+var rulesNoticeCache = /* @__PURE__ */ new Map();
+function compareVersions2(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] ?? 0;
+    const p2 = parts2[i] ?? 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+function extractRulesVersion(content) {
+  const match = content.match(RULES_VERSION_REGEX);
+  return match?.[1]?.trim() ?? null;
+}
+function detectEditorFromClientName(clientName) {
+  if (!clientName) return null;
+  const normalized = clientName.toLowerCase().trim();
+  if (normalized.includes("cursor")) return "cursor";
+  if (normalized.includes("windsurf") || normalized.includes("codeium")) return "windsurf";
+  if (normalized.includes("claude")) return "claude";
+  if (normalized.includes("cline")) return "cline";
+  if (normalized.includes("kilo")) return "kilo";
+  if (normalized.includes("roo")) return "roo";
+  if (normalized.includes("codex")) return "codex";
+  if (normalized.includes("aider")) return "aider";
+  return null;
+}
+function resolveRulesCandidatePaths(folderPath, editorKey) {
+  const candidates = /* @__PURE__ */ new Set();
+  const addProject = (key) => {
+    if (!folderPath) return;
+    const rel = RULES_PROJECT_FILES[key];
+    if (rel) {
+      candidates.add(path4.join(folderPath, rel));
+    }
+  };
+  const addGlobal = (key) => {
+    const paths = RULES_GLOBAL_FILES[key];
+    if (!paths) return;
+    for (const p of paths) {
+      candidates.add(p);
+    }
+  };
+  if (editorKey) {
+    addProject(editorKey);
+    addGlobal(editorKey);
+  } else {
+    for (const key of Object.keys(RULES_PROJECT_FILES)) {
+      addProject(key);
+      addGlobal(key);
+    }
+  }
+  return Array.from(candidates);
+}
+function resolveFolderPath(inputPath, sessionManager) {
+  if (inputPath) return inputPath;
+  const fromSession = sessionManager?.getFolderPath();
+  if (fromSession) return fromSession;
+  const ctxPath = sessionManager?.getContext();
+  const contextFolder = ctxPath && typeof ctxPath.folder_path === "string" ? ctxPath.folder_path : null;
+  if (contextFolder) return contextFolder;
+  const cwd = process.cwd();
+  const indicators = [".git", "package.json", "Cargo.toml", "pyproject.toml", ".contextstream"];
+  const hasIndicator = indicators.some((entry) => {
+    try {
+      return fs3.existsSync(path4.join(cwd, entry));
+    } catch {
+      return false;
+    }
+  });
+  return hasIndicator ? cwd : null;
+}
+function getRulesNotice(folderPath, clientName) {
+  if (!RULES_VERSION || RULES_VERSION === "0.0.0") return null;
+  const editorKey = detectEditorFromClientName(clientName);
+  if (!folderPath && !editorKey) {
+    return null;
+  }
+  const cacheKey = `${folderPath ?? "none"}|${editorKey ?? "all"}`;
+  const cached = rulesNoticeCache.get(cacheKey);
+  if (cached && Date.now() - cached.checkedAt < RULES_NOTICE_CACHE_TTL_MS) {
+    return cached.notice;
+  }
+  const candidates = resolveRulesCandidatePaths(folderPath, editorKey);
+  const existing = candidates.filter((filePath) => fs3.existsSync(filePath));
+  if (existing.length === 0) {
+    const updateCommand2 = folderPath ? `generate_editor_rules(folder_path="${folderPath}")` : 'generate_editor_rules(folder_path="<cwd>")';
+    const notice2 = {
+      status: "missing",
+      latest: RULES_VERSION,
+      files_checked: candidates,
+      update_tool: "generate_editor_rules",
+      update_args: {
+        ...folderPath ? { folder_path: folderPath } : {},
+        editors: editorKey ? [editorKey] : ["all"]
+      },
+      update_command: updateCommand2
+    };
+    rulesNoticeCache.set(cacheKey, { checkedAt: Date.now(), notice: notice2 });
+    return notice2;
+  }
+  const filesMissingVersion = [];
+  const filesOutdated = [];
+  const versions = [];
+  for (const filePath of existing) {
+    try {
+      const content = fs3.readFileSync(filePath, "utf-8");
+      const version = extractRulesVersion(content);
+      if (!version) {
+        filesMissingVersion.push(filePath);
+        continue;
+      }
+      versions.push(version);
+      if (compareVersions2(version, RULES_VERSION) < 0) {
+        filesOutdated.push(filePath);
+      }
+    } catch {
+      filesMissingVersion.push(filePath);
+    }
+  }
+  if (filesOutdated.length === 0 && filesMissingVersion.length === 0) {
+    rulesNoticeCache.set(cacheKey, { checkedAt: Date.now(), notice: null });
+    return null;
+  }
+  const current = versions.sort(compareVersions2).at(-1);
+  const updateCommand = folderPath ? `generate_editor_rules(folder_path="${folderPath}")` : 'generate_editor_rules(folder_path="<cwd>")';
+  const notice = {
+    status: filesOutdated.length > 0 ? "behind" : "unknown",
+    current,
+    latest: RULES_VERSION,
+    files_checked: existing,
+    ...filesOutdated.length > 0 ? { files_outdated: filesOutdated } : {},
+    ...filesMissingVersion.length > 0 ? { files_missing_version: filesMissingVersion } : {},
+    update_tool: "generate_editor_rules",
+    update_args: {
+      ...folderPath ? { folder_path: folderPath } : {},
+      editors: editorKey ? [editorKey] : ["all"]
+    },
+    update_command: updateCommand
+  };
+  rulesNoticeCache.set(cacheKey, { checkedAt: Date.now(), notice });
+  return notice;
+}
+var CONTEXTSTREAM_START_MARKER = "<!-- BEGIN ContextStream -->";
+var CONTEXTSTREAM_END_MARKER = "<!-- END ContextStream -->";
+function wrapWithMarkers(content) {
+  return `${CONTEXTSTREAM_START_MARKER}
+${content.trim()}
+${CONTEXTSTREAM_END_MARKER}`;
+}
+async function upsertRuleFile(filePath, content) {
+  await fs3.promises.mkdir(path4.dirname(filePath), { recursive: true });
+  const wrappedContent = wrapWithMarkers(content);
+  let existing = "";
+  try {
+    existing = await fs3.promises.readFile(filePath, "utf8");
+  } catch {
+  }
+  if (!existing) {
+    await fs3.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
+    return "created";
+  }
+  const startIdx = existing.indexOf(CONTEXTSTREAM_START_MARKER);
+  const endIdx = existing.indexOf(CONTEXTSTREAM_END_MARKER);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = existing.substring(0, startIdx);
+    const after = existing.substring(endIdx + CONTEXTSTREAM_END_MARKER.length);
+    const updated = before.trimEnd() + "\n\n" + wrappedContent + "\n" + after.trimStart();
+    await fs3.promises.writeFile(filePath, updated.trim() + "\n", "utf8");
+    return "updated";
+  }
+  const joined = existing.trimEnd() + "\n\n" + wrappedContent + "\n";
+  await fs3.promises.writeFile(filePath, joined, "utf8");
+  return "appended";
+}
+async function writeEditorRules(options) {
+  const editors = options.editors && options.editors.length > 0 ? options.editors : getAvailableEditors();
+  const results = [];
+  for (const editor of editors) {
+    const rule = generateRuleContent(editor, {
+      workspaceName: options.workspaceName,
+      workspaceId: options.workspaceId,
+      projectName: options.projectName,
+      additionalRules: options.additionalRules,
+      mode: options.mode
+    });
+    if (!rule) {
+      results.push({ editor, filename: "", status: "unknown editor" });
+      continue;
+    }
+    const filePath = path4.join(options.folderPath, rule.filename);
+    try {
+      const status = await upsertRuleFile(filePath, rule.content);
+      results.push({ editor, filename: rule.filename, status });
+    } catch (err) {
+      results.push({
+        editor,
+        filename: rule.filename,
+        status: `error: ${err.message}`
+      });
+    }
+  }
+  for (const key of rulesNoticeCache.keys()) {
+    if (key.startsWith(`${options.folderPath}|`)) {
+      rulesNoticeCache.delete(key);
+    }
+  }
+  return results;
+}
 var WRITE_VERBS = /* @__PURE__ */ new Set([
   "create",
   "update",
@@ -9420,6 +9669,30 @@ Upgrade: ${upgradeUrl2}` : "";
     }
     return { ok: true, resolvedPath };
   }
+  function startBackgroundIngest(projectId, resolvedPath, ingestOptions, options = {}) {
+    (async () => {
+      try {
+        if (options.preflight) {
+          const fileCheck = await countIndexableFiles(resolvedPath, { maxFiles: 1 });
+          if (fileCheck.count === 0) {
+            console.error(`[ContextStream] No indexable files found in ${resolvedPath}. Skipping ingest.`);
+            return;
+          }
+        }
+        let totalIndexed = 0;
+        let batchCount = 0;
+        console.error(`[ContextStream] Starting background ingestion for project ${projectId} from ${resolvedPath}`);
+        for await (const batch of readAllFilesInBatches(resolvedPath, { batchSize: 50 })) {
+          const result = await client.ingestFiles(projectId, batch, ingestOptions);
+          totalIndexed += result.data?.files_indexed ?? batch.length;
+          batchCount++;
+        }
+        console.error(`[ContextStream] Completed background ingestion: ${totalIndexed} files in ${batchCount} batches`);
+      } catch (error) {
+        console.error(`[ContextStream] Ingestion failed:`, error);
+      }
+    })();
+  }
   registerTool(
     "mcp_server_version",
     {
@@ -9742,30 +10015,13 @@ Access: Free`,
           };
           fs3.writeFileSync(configPath, JSON.stringify(config, null, 2));
           if (input.generate_editor_rules) {
-            for (const editor of getAvailableEditors()) {
-              const rule = generateRuleContent(editor, {
-                workspaceId,
-                projectName: input.name
-              });
-              if (rule) {
-                const filePath = path4.join(input.folder_path, rule.filename);
-                try {
-                  let existingContent = "";
-                  try {
-                    existingContent = fs3.readFileSync(filePath, "utf-8");
-                  } catch {
-                  }
-                  if (!existingContent) {
-                    fs3.writeFileSync(filePath, rule.content);
-                    rulesGenerated.push(rule.filename);
-                  } else if (!existingContent.includes("ContextStream")) {
-                    fs3.writeFileSync(filePath, existingContent + "\n\n" + rule.content);
-                    rulesGenerated.push(rule.filename + " (appended)");
-                  }
-                } catch {
-                }
-              }
-            }
+            const ruleResults = await writeEditorRules({
+              folderPath: input.folder_path,
+              editors: getAvailableEditors(),
+              workspaceId,
+              projectName: input.name
+            });
+            rulesGenerated = ruleResults.filter((r) => r.status === "created" || r.status === "updated" || r.status === "appended").map((r) => r.status === "created" ? r.filename : `${r.filename} (${r.status})`);
           }
         } catch (err) {
           console.error("[ContextStream] Failed to write project config:", err);
@@ -10356,7 +10612,8 @@ ${formatContent(result)}`
       title: "Ingest local files",
       description: `Read ALL files from a local directory and ingest them for indexing.
 This indexes your entire project by reading files in batches.
-Automatically detects code files and skips ignored directories like node_modules, target, dist, etc.`,
+Automatically detects code files and skips ignored directories like node_modules, target, dist, etc.
+Runs in the background and returns immediately; use 'projects_index_status' to monitor progress.`,
       inputSchema: external_exports.object({
         project_id: external_exports.string().uuid().optional().describe("Project to ingest files into (defaults to current session project)"),
         path: external_exports.string().describe("Local directory path to read files from"),
@@ -10373,31 +10630,11 @@ Automatically detects code files and skips ignored directories like node_modules
       if (!pathCheck.ok) {
         return errorResult(pathCheck.error);
       }
-      const fileCheck = await countIndexableFiles(pathCheck.resolvedPath, { maxFiles: 1 });
-      if (fileCheck.count === 0) {
-        return errorResult(
-          `Error: no indexable files found in directory: ${input.path}. The directory may be empty or contain only ignored files/directories. Supported file types include: .ts, .js, .py, .rs, .go, .java, .md, .json, etc.`
-        );
-      }
       const ingestOptions = {
         ...input.write_to_disk !== void 0 && { write_to_disk: input.write_to_disk },
         ...input.overwrite !== void 0 && { overwrite: input.overwrite }
       };
-      (async () => {
-        try {
-          let totalIndexed = 0;
-          let batchCount = 0;
-          console.error(`[ContextStream] Starting background ingestion for project ${projectId} from ${pathCheck.resolvedPath}`);
-          for await (const batch of readAllFilesInBatches(pathCheck.resolvedPath, { batchSize: 50 })) {
-            const result = await client.ingestFiles(projectId, batch, ingestOptions);
-            totalIndexed += result.data?.files_indexed ?? batch.length;
-            batchCount++;
-          }
-          console.error(`[ContextStream] Completed background ingestion: ${totalIndexed} files in ${batchCount} batches`);
-        } catch (error) {
-          console.error(`[ContextStream] Ingestion failed:`, error);
-        }
-      })();
+      startBackgroundIngest(projectId, pathCheck.resolvedPath, ingestOptions, { preflight: true });
       const summary = {
         status: "started",
         message: "Ingestion running in background",
@@ -10733,6 +10970,25 @@ This does semantic search on the first message. You only need context_smart on s
       if (sessionManager) {
         sessionManager.markInitialized(result);
       }
+      const folderPathForRules = input.folder_path || ideRoots[0] || resolveFolderPath(void 0, sessionManager);
+      if (sessionManager && folderPathForRules) {
+        sessionManager.setFolderPath(folderPathForRules);
+      }
+      let rulesNotice = null;
+      if (folderPathForRules || detectedClientInfo?.name) {
+        rulesNotice = getRulesNotice(folderPathForRules, detectedClientInfo?.name);
+        if (rulesNotice) {
+          result.rules_notice = rulesNotice;
+        }
+      }
+      let versionNotice = null;
+      try {
+        versionNotice = await getUpdateNotice();
+      } catch {
+      }
+      if (versionNotice) {
+        result.version_notice = versionNotice;
+      }
       const workspaceId = typeof result.workspace_id === "string" ? result.workspace_id : void 0;
       if (workspaceId && AUTO_HIDE_INTEGRATIONS) {
         try {
@@ -10804,6 +11060,19 @@ This does semantic search on the first message. You only need context_smart on s
       } else if (workspaceWarning) {
         text = [`Warning: ${workspaceWarning}`, "", formatContent(result)].join("\n");
       }
+      const noticeLines = [];
+      if (rulesNotice) {
+        const current = rulesNotice.current ?? "unknown";
+        noticeLines.push(`[RULES_NOTICE] status=${rulesNotice.status} current=${current} latest=${rulesNotice.latest} update="${rulesNotice.update_command}"`);
+      }
+      if (versionNotice?.behind) {
+        noticeLines.push(`[VERSION_NOTICE] current=${versionNotice.current} latest=${versionNotice.latest} upgrade="${versionNotice.upgrade_command}"`);
+      }
+      if (noticeLines.length > 0) {
+        text = `${text}
+
+${noticeLines.join("\n")}`;
+      }
       return { content: [{ type: "text", text }], structuredContent: toStructured(result) };
     }
   );
@@ -10893,32 +11162,13 @@ Optionally generates AI editor rules for automatic ContextStream usage.`,
       const result = await client.associateWorkspace(input);
       let rulesGenerated = [];
       if (input.generate_editor_rules) {
-        const fs6 = await import("fs");
-        const path7 = await import("path");
-        for (const editor of getAvailableEditors()) {
-          const rule = generateRuleContent(editor, {
-            workspaceName: input.workspace_name,
-            workspaceId: input.workspace_id
-          });
-          if (rule) {
-            const filePath = path7.join(input.folder_path, rule.filename);
-            try {
-              let existingContent = "";
-              try {
-                existingContent = fs6.readFileSync(filePath, "utf-8");
-              } catch {
-              }
-              if (!existingContent) {
-                fs6.writeFileSync(filePath, rule.content);
-                rulesGenerated.push(rule.filename);
-              } else if (!existingContent.includes("ContextStream Integration")) {
-                fs6.writeFileSync(filePath, existingContent + "\n\n" + rule.content);
-                rulesGenerated.push(rule.filename + " (appended)");
-              }
-            } catch {
-            }
-          }
-        }
+        const ruleResults = await writeEditorRules({
+          folderPath: input.folder_path,
+          editors: getAvailableEditors(),
+          workspaceName: input.workspace_name,
+          workspaceId: input.workspace_id
+        });
+        rulesGenerated = ruleResults.filter((r) => r.status === "created" || r.status === "updated" || r.status === "appended").map((r) => r.status === "created" ? r.filename : `${r.filename} (${r.status})`);
       }
       const response = {
         ...result,
@@ -10998,31 +11248,13 @@ Behavior:
       });
       let rulesGenerated = [];
       if (input.generate_editor_rules) {
-        const fs6 = await import("fs");
-        const path7 = await import("path");
-        for (const editor of getAvailableEditors()) {
-          const rule = generateRuleContent(editor, {
-            workspaceName: newWorkspace.name || input.workspace_name,
-            workspaceId: newWorkspace.id
-          });
-          if (!rule) continue;
-          const filePath = path7.join(folderPath, rule.filename);
-          try {
-            let existingContent = "";
-            try {
-              existingContent = fs6.readFileSync(filePath, "utf-8");
-            } catch {
-            }
-            if (!existingContent) {
-              fs6.writeFileSync(filePath, rule.content);
-              rulesGenerated.push(rule.filename);
-            } else if (!existingContent.includes("ContextStream Integration")) {
-              fs6.writeFileSync(filePath, existingContent + "\n\n" + rule.content);
-              rulesGenerated.push(rule.filename + " (appended)");
-            }
-          } catch {
-          }
-        }
+        const ruleResults = await writeEditorRules({
+          folderPath,
+          editors: getAvailableEditors(),
+          workspaceName: newWorkspace.name || input.workspace_name,
+          workspaceId: newWorkspace.id
+        });
+        rulesGenerated = ruleResults.filter((r) => r.status === "created" || r.status === "updated" || r.status === "appended").map((r) => r.status === "created" ? r.filename : `${r.filename} (${r.status})`);
       }
       const session = await client.initSession(
         {
@@ -11427,7 +11659,7 @@ Example: "What were the auth decisions?" or "What are my TypeScript preferences?
 These rules instruct the AI to automatically use ContextStream for memory and context.
 Supported editors: ${getAvailableEditors().join(", ")}`,
       inputSchema: external_exports.object({
-        folder_path: external_exports.string().describe("Absolute path to the project folder"),
+        folder_path: external_exports.string().optional().describe("Absolute path to the project folder (defaults to IDE root/cwd)"),
         editors: external_exports.array(external_exports.enum(["codex", "windsurf", "cursor", "cline", "kilo", "roo", "claude", "aider", "all"])).optional().describe("Which editors to generate rules for. Defaults to all."),
         workspace_name: external_exports.string().optional().describe("Workspace name to include in rules"),
         workspace_id: external_exports.string().uuid().optional().describe("Workspace ID to include in rules"),
@@ -11438,58 +11670,48 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
       })
     },
     async (input) => {
-      const fs6 = await import("fs");
-      const path7 = await import("path");
+      const folderPath = resolveFolderPath(input.folder_path, sessionManager);
+      if (!folderPath) {
+        return errorResult("Error: folder_path is required. Provide folder_path or run from a project directory.");
+      }
       const editors = input.editors?.includes("all") || !input.editors ? getAvailableEditors() : input.editors.filter((e) => e !== "all");
       const results = [];
-      for (const editor of editors) {
-        const rule = generateRuleContent(editor, {
-          workspaceName: input.workspace_name,
-          workspaceId: input.workspace_id,
-          projectName: input.project_name,
-          additionalRules: input.additional_rules,
-          mode: input.mode
-        });
-        if (!rule) {
-          results.push({ editor, filename: "", status: "unknown editor" });
-          continue;
-        }
-        const filePath = path7.join(input.folder_path, rule.filename);
-        if (input.dry_run) {
+      if (input.dry_run) {
+        for (const editor of editors) {
+          const rule = generateRuleContent(editor, {
+            workspaceName: input.workspace_name,
+            workspaceId: input.workspace_id,
+            projectName: input.project_name,
+            additionalRules: input.additional_rules,
+            mode: input.mode
+          });
+          if (!rule) {
+            results.push({ editor, filename: "", status: "unknown editor" });
+            continue;
+          }
           results.push({
             editor,
             filename: rule.filename,
-            status: "dry run - would create",
+            status: "dry run - would update",
             content: rule.content
           });
-        } else {
-          try {
-            let existingContent = "";
-            try {
-              existingContent = fs6.readFileSync(filePath, "utf-8");
-            } catch {
-            }
-            if (existingContent && !existingContent.includes("ContextStream Integration")) {
-              const updatedContent = existingContent + "\n\n" + rule.content;
-              fs6.writeFileSync(filePath, updatedContent);
-              results.push({ editor, filename: rule.filename, status: "appended to existing" });
-            } else {
-              fs6.writeFileSync(filePath, rule.content);
-              results.push({ editor, filename: rule.filename, status: "created" });
-            }
-          } catch (err) {
-            results.push({
-              editor,
-              filename: rule.filename,
-              status: `error: ${err.message}`
-            });
-          }
         }
+      } else {
+        const writeResults = await writeEditorRules({
+          folderPath,
+          editors,
+          workspaceName: input.workspace_name,
+          workspaceId: input.workspace_id,
+          projectName: input.project_name,
+          additionalRules: input.additional_rules,
+          mode: input.mode
+        });
+        results.push(...writeResults);
       }
       const summary = {
-        folder: input.folder_path,
+        folder: folderPath,
         results,
-        message: input.dry_run ? "Dry run complete. Use dry_run: false to write files." : `Generated ${results.filter((r) => r.status === "created" || r.status.includes("appended")).length} rule files.`
+        message: input.dry_run ? "Dry run complete. Use dry_run: false to write files." : `Generated ${results.filter((r) => r.status === "created" || r.status === "updated" || r.status === "appended").length} rule files.`
       };
       return { content: [{ type: "text", text: formatContent(summary) }], structuredContent: toStructured(summary) };
     }
@@ -11763,11 +11985,27 @@ This saves ~80% tokens compared to including full chat history.`,
       const footer = `
 ---
 \u{1F3AF} ${result.sources_used} sources | ~${result.token_estimate} tokens | format: ${result.format}`;
-      const versionNoticeLine = result.version_notice?.behind ? `
-[VERSION_NOTICE] current=${result.version_notice.current} latest=${result.version_notice.latest} upgrade="${result.version_notice.upgrade_command}"` : "";
+      const folderPathForRules = resolveFolderPath(void 0, sessionManager);
+      const rulesNotice = getRulesNotice(folderPathForRules, detectedClientInfo?.name);
+      let versionNotice = result.version_notice;
+      if (!versionNotice) {
+        try {
+          versionNotice = await getUpdateNotice();
+        } catch {
+        }
+      }
+      const rulesNoticeLine = rulesNotice ? `
+[RULES_NOTICE] status=${rulesNotice.status} current=${rulesNotice.current ?? "unknown"} latest=${rulesNotice.latest} update="${rulesNotice.update_command}"` : "";
+      const versionNoticeLine = versionNotice?.behind ? `
+[VERSION_NOTICE] current=${versionNotice.current} latest=${versionNotice.latest} upgrade="${versionNotice.upgrade_command}"` : "";
+      const enrichedResult = {
+        ...result,
+        ...rulesNotice ? { rules_notice: rulesNotice } : {},
+        ...versionNotice ? { version_notice: versionNotice } : {}
+      };
       return {
-        content: [{ type: "text", text: result.context + footer + versionNoticeLine }],
-        structuredContent: toStructured(result)
+        content: [{ type: "text", text: result.context + footer + rulesNoticeLine + versionNoticeLine }],
+        structuredContent: toStructured(enrichedResult)
       };
     }
   );
@@ -13489,24 +13727,27 @@ Use this to remove a reminder that is no longer relevant.`,
             if (!validPath.ok) {
               return errorResult(validPath.error);
             }
-            let totalFiles = 0;
-            let batches = 0;
-            for await (const batch of readAllFilesInBatches(validPath.resolvedPath, { batchSize: 50 })) {
-              if (batch.length === 0) continue;
-              await client.ingestFiles(projectId, batch, {
-                overwrite: input.overwrite,
-                write_to_disk: input.write_to_disk
-              });
-              totalFiles += batch.length;
-              batches += 1;
-            }
+            const ingestOptions = {
+              ...input.write_to_disk !== void 0 && { write_to_disk: input.write_to_disk },
+              ...input.overwrite !== void 0 && { overwrite: input.overwrite }
+            };
+            startBackgroundIngest(projectId, validPath.resolvedPath, ingestOptions);
             const result = {
+              status: "started",
+              message: "Ingestion running in background",
               project_id: projectId,
-              files_ingested: totalFiles,
-              batches,
-              path: validPath.resolvedPath
+              path: validPath.resolvedPath,
+              ...input.write_to_disk !== void 0 && { write_to_disk: input.write_to_disk },
+              ...input.overwrite !== void 0 && { overwrite: input.overwrite },
+              note: "Use 'project' with action 'index_status' to monitor progress."
+            };
+            return {
+              content: [{
+                type: "text",
+                text: `Ingestion started in background for directory: ${validPath.resolvedPath}. Use 'project' with action 'index_status' to monitor progress.`
+              }],
+              structuredContent: toStructured(result)
             };
-            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
           }
           default:
             return errorResult(`Unknown action: ${input.action}`);
@@ -14819,6 +15060,12 @@ var SessionManager = class {
   getContext() {
     return this.context;
   }
+  /**
+   * Get the current folder path (if known)
+   */
+  getFolderPath() {
+    return this.folderPath;
+  }
   /**
    * Mark session as manually initialized (e.g., when session_init is called explicitly)
    */
@@ -14830,6 +15077,10 @@ var SessionManager = class {
     if (workspaceId || projectId) {
       this.client.setDefaults({ workspace_id: workspaceId, project_id: projectId });
     }
+    const contextFolderPath = typeof context.folder_path === "string" ? context.folder_path : void 0;
+    if (contextFolderPath) {
+      this.folderPath = contextFolderPath;
+    }
   }
   /**
    * Set the folder path hint (can be passed from tools that know the workspace path)
@@ -14921,6 +15172,9 @@ var SessionManager = class {
     if (this.ideRoots.length === 0 && this.folderPath) {
       this.ideRoots = [this.folderPath];
     }
+    if (this.ideRoots.length > 0) {
+      this.folderPath = this.ideRoots[0];
+    }
     this.initializationPromise = this._doInitialize();
     try {
       const result = await this.initializationPromise;
@@ -15366,25 +15620,25 @@ async function runHttpGateway() {
 
 // src/index.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { join as join8 } from "path";
 
 // src/setup.ts
 import * as fs5 from "node:fs/promises";
 import * as path6 from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 
 // src/credentials.ts
 import * as fs4 from "node:fs/promises";
 import * as path5 from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 function normalizeApiUrl(input) {
   return String(input ?? "").trim().replace(/\/+$/, "");
 }
 function credentialsFilePath() {
-  return path5.join(homedir2(), ".contextstream", "credentials.json");
+  return path5.join(homedir3(), ".contextstream", "credentials.json");
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -15482,27 +15736,27 @@ async function fileExists(filePath) {
     return false;
   }
 }
-var CONTEXTSTREAM_START_MARKER = "<!-- BEGIN ContextStream -->";
-var CONTEXTSTREAM_END_MARKER = "<!-- END ContextStream -->";
-function wrapWithMarkers(content) {
-  return `${CONTEXTSTREAM_START_MARKER}
+var CONTEXTSTREAM_START_MARKER2 = "<!-- BEGIN ContextStream -->";
+var CONTEXTSTREAM_END_MARKER2 = "<!-- END ContextStream -->";
+function wrapWithMarkers2(content) {
+  return `${CONTEXTSTREAM_START_MARKER2}
 ${content.trim()}
-${CONTEXTSTREAM_END_MARKER}`;
+${CONTEXTSTREAM_END_MARKER2}`;
 }
 async function upsertTextFile(filePath, content, _marker) {
   await fs5.mkdir(path6.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
-  const wrappedContent = wrapWithMarkers(content);
+  const wrappedContent = wrapWithMarkers2(content);
   if (!exists) {
     await fs5.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "created";
   }
   const existing = await fs5.readFile(filePath, "utf8").catch(() => "");
-  const startIdx = existing.indexOf(CONTEXTSTREAM_START_MARKER);
-  const endIdx = existing.indexOf(CONTEXTSTREAM_END_MARKER);
+  const startIdx = existing.indexOf(CONTEXTSTREAM_START_MARKER2);
+  const endIdx = existing.indexOf(CONTEXTSTREAM_END_MARKER2);
   if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
     const before = existing.substring(0, startIdx);
-    const after = existing.substring(endIdx + CONTEXTSTREAM_END_MARKER.length);
+    const after = existing.substring(endIdx + CONTEXTSTREAM_END_MARKER2.length);
     const updated = before.trimEnd() + "\n\n" + wrappedContent + "\n" + after.trimStart();
     await fs5.writeFile(filePath, updated.trim() + "\n", "utf8");
     return "updated";
@@ -15517,7 +15771,7 @@ async function upsertTextFile(filePath, content, _marker) {
   return "appended";
 }
 function globalRulesPathForEditor(editor) {
-  const home = homedir3();
+  const home = homedir4();
   switch (editor) {
     case "codex":
       return path6.join(home, ".codex", "AGENTS.md");
@@ -15546,7 +15800,7 @@ async function anyPathExists(paths) {
   return false;
 }
 async function isCodexInstalled() {
-  const home = homedir3();
+  const home = homedir4();
   const envHome = process.env.CODEX_HOME;
   const candidates = [
     envHome,
@@ -15557,7 +15811,7 @@ async function isCodexInstalled() {
   return anyPathExists(candidates);
 }
 async function isClaudeInstalled() {
-  const home = homedir3();
+  const home = homedir4();
   const candidates = [
     path6.join(home, ".claude"),
     path6.join(home, ".config", "claude")
@@ -15573,7 +15827,7 @@ async function isClaudeInstalled() {
   return anyPathExists(candidates);
 }
 async function isWindsurfInstalled() {
-  const home = homedir3();
+  const home = homedir4();
   const candidates = [
     path6.join(home, ".codeium"),
     path6.join(home, ".codeium", "windsurf"),
@@ -15592,7 +15846,7 @@ async function isWindsurfInstalled() {
   return anyPathExists(candidates);
 }
 async function isClineInstalled() {
-  const home = homedir3();
+  const home = homedir4();
   const candidates = [
     path6.join(home, "Documents", "Cline"),
     path6.join(home, ".cline"),
@@ -15601,7 +15855,7 @@ async function isClineInstalled() {
   return anyPathExists(candidates);
 }
 async function isKiloInstalled() {
-  const home = homedir3();
+  const home = homedir4();
   const candidates = [
     path6.join(home, ".kilocode"),
     path6.join(home, ".config", "kilocode")
@@ -15609,7 +15863,7 @@ async function isKiloInstalled() {
   return anyPathExists(candidates);
 }
 async function isRooInstalled() {
-  const home = homedir3();
+  const home = homedir4();
   const candidates = [
     path6.join(home, ".roo"),
     path6.join(home, ".config", "roo")
@@ -15617,7 +15871,7 @@ async function isRooInstalled() {
   return anyPathExists(candidates);
 }
 async function isAiderInstalled() {
-  const home = homedir3();
+  const home = homedir4();
   const candidates = [
     path6.join(home, ".aider.conf.yml"),
     path6.join(home, ".config", "aider")
@@ -15625,7 +15879,7 @@ async function isAiderInstalled() {
   return anyPathExists(candidates);
 }
 async function isCursorInstalled() {
-  const home = homedir3();
+  const home = homedir4();
   const candidates = [path6.join(home, ".cursor")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Cursor.app");
@@ -15773,7 +16027,7 @@ async function upsertJsonVsCodeMcpConfig(filePath, server) {
   return before === after ? "skipped" : "updated";
 }
 function claudeDesktopConfigPath() {
-  const home = homedir3();
+  const home = homedir4();
   if (process.platform === "darwin") {
     return path6.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
@@ -16177,7 +16431,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         if (mcpScope === "project" && editor !== "codex") continue;
         try {
           if (editor === "codex") {
-            const filePath = path6.join(homedir3(), ".codex", "config.toml");
+            const filePath = path6.join(homedir4(), ".codex", "config.toml");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -16189,7 +16443,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "windsurf") {
-            const filePath = path6.join(homedir3(), ".codeium", "windsurf", "mcp_config.json");
+            const filePath = path6.join(homedir4(), ".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}`);
@@ -16223,7 +16477,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "cursor") {
-            const filePath = path6.join(homedir3(), ".cursor", "mcp.json");
+            const filePath = path6.join(homedir4(), ".cursor", "mcp.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -16450,7 +16704,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 = join8(homedir4(), ".contextstream");
+  const configDir = join8(homedir5(), ".contextstream");
   const starShownFile = join8(configDir, ".star-shown");
   if (existsSync4(starShownFile)) {
     return;

package/dist/test-server.js

@@ -4050,6 +4050,21 @@ var coerce = {
 };
 var NEVER = INVALID;
 
+// src/version.ts
+import { createRequire } from "module";
+function getVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkg = require2("../package.json");
+    const version = pkg?.version;
+    if (typeof version === "string" && version.trim()) return version.trim();
+  } catch {
+  }
+  return "unknown";
+}
+var VERSION = getVersion();
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+
 // src/config.ts
 var DEFAULT_API_URL = "https://api.contextstream.io";
 function parseBooleanEnv(value) {
@@ -4065,7 +4080,7 @@ var configSchema = external_exports.object({
   jwt: external_exports.string().min(1).optional(),
   defaultWorkspaceId: external_exports.string().uuid().optional(),
   defaultProjectId: external_exports.string().uuid().optional(),
-  userAgent: external_exports.string().default("contextstream-mcp/0.1.0"),
+  userAgent: external_exports.string().default(`contextstream-mcp/${VERSION}`),
   allowHeaderAuth: external_exports.boolean().optional(),
   contextPackEnabled: external_exports.boolean().default(true)
 });
@@ -4097,21 +4112,6 @@ function loadConfig() {
   return parsed.data;
 }
 
-// src/version.ts
-import { createRequire } from "module";
-function getVersion() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const pkg = require2("../package.json");
-    const version = pkg?.version;
-    if (typeof version === "string" && version.trim()) return version.trim();
-  } catch {
-  }
-  return "unknown";
-}
-var VERSION = getVersion();
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-
 // src/test-server.ts
 var PORT = parseInt(process.env.MCP_TEST_PORT || "3099", 10);
 var pendingRequests = /* @__PURE__ */ new Map();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.4.15",
+  "version": "0.4.17",
   "description": "ContextStream MCP server - v0.4.x with consolidated domain tools (~11 tools, ~75% token reduction). Code context, memory, search, and AI tools.",
   "type": "module",
   "license": "MIT",