@contextstream/mcp-server 0.4.55 → 0.4.57

package/dist/index.js

@@ -38,6 +38,388 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/version.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+import { spawn } from "child_process";
+function getVersion() {
+  if (typeof __CONTEXTSTREAM_VERSION__ !== "undefined" && __CONTEXTSTREAM_VERSION__) {
+    return __CONTEXTSTREAM_VERSION__;
+  }
+  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";
+}
+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;
+}
+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;
+}
+function getVersionsBehind(current, latest) {
+  try {
+    const currentParts = current.split(".").map(Number);
+    const latestParts = latest.split(".").map(Number);
+    if ((latestParts[0] ?? 0) > (currentParts[0] ?? 0)) {
+      return 10 + ((latestParts[1] ?? 0) - (currentParts[1] ?? 0));
+    }
+    const minorDiff = (latestParts[1] ?? 0) - (currentParts[1] ?? 0);
+    const patchDiff = (latestParts[2] ?? 0) - (currentParts[2] ?? 0);
+    if (minorDiff > 0) {
+      return minorDiff;
+    } else if (minorDiff === 0 && patchDiff > 0) {
+      return 1;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+function getVersionWarning(notice) {
+  if (!notice?.behind) return null;
+  const versionsBehind = getVersionsBehind(notice.current, notice.latest);
+  if (versionsBehind >= 3) {
+    return `[VERSION_CRITICAL] MCP server is ${versionsBehind} versions behind (${notice.current} \u2192 ${notice.latest}). Update immediately: ${notice.upgrade_command}`;
+  } else if (versionsBehind >= 1) {
+    return `[VERSION_NOTICE] MCP server update available (${notice.current} \u2192 ${notice.latest}). Run: ${notice.upgrade_command}`;
+  }
+  return null;
+}
+function getVersionInstructions(notice) {
+  if (!notice?.behind) return null;
+  const versionsBehind = getVersionsBehind(notice.current, notice.latest);
+  if (versionsBehind >= 5) {
+    return `\u26A0\uFE0F CRITICAL: User's MCP is ${versionsBehind} versions behind. Mention update in EVERY response until updated.`;
+  } else if (versionsBehind >= 3) {
+    return `\u26A0\uFE0F User's MCP is ${versionsBehind} versions behind. Remind about update every 2-3 messages.`;
+  } else if (versionsBehind >= 1) {
+    return `Note: MCP update available (${notice.current}\u2192${notice.latest}). Mention once at session start.`;
+  }
+  return null;
+}
+function getVersionNoticeForHook(notice) {
+  if (!notice?.behind) return null;
+  const versionsBehind = getVersionsBehind(notice.current, notice.latest);
+  const severity = versionsBehind >= 5 ? "CRITICAL" : versionsBehind >= 3 ? "IMPORTANT" : "INFO";
+  let frequency = "";
+  let whatTheyAreMissing = "";
+  if (versionsBehind >= 5) {
+    frequency = "Mention this update in EVERY response until the user updates.";
+    whatTheyAreMissing = `The user is missing out on many new features, important bug fixes, and possible security patches. Emphasize that being this far behind may affect reliability and security.`;
+  } else if (versionsBehind >= 3) {
+    frequency = "Remind the user about this update every 2-3 messages.";
+    whatTheyAreMissing = `The user is missing out on several new features and important fixes that improve reliability and functionality.`;
+  } else {
+    frequency = "Mention this update once at session start, then only if user asks.";
+    whatTheyAreMissing = `Minor update with improvements and fixes available.`;
+  }
+  return `[VERSION_${severity}] MCP server is ${versionsBehind > 0 ? versionsBehind + " version(s)" : "a version"} behind (${notice.current} \u2192 ${notice.latest}).
+
+${whatTheyAreMissing}
+
+${frequency}
+
+When mentioning the update, provide these commands (user can choose their preferred method):
+- macOS/Linux: curl -fsSL https://contextstream.io/scripts/setup.sh | bash
+- Windows: irm https://contextstream.io/scripts/setup.ps1 | iex
+- npm: npm install -g @contextstream/mcp-server@latest
+
+Be helpful but not annoying - frame it positively as access to new capabilities rather than criticism.`;
+}
+function isAutoUpdateEnabled() {
+  if (process.env.CONTEXTSTREAM_AUTO_UPDATE === "false") {
+    return false;
+  }
+  try {
+    const configPath = join(homedir(), ".contextstream", "config.json");
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (config.auto_update === false) {
+        return false;
+      }
+    }
+  } catch {
+  }
+  return true;
+}
+function setAutoUpdatePreference(enabled) {
+  try {
+    const configDir = join(homedir(), ".contextstream");
+    const configPath = join(configDir, "config.json");
+    let config = {};
+    if (existsSync(configPath)) {
+      config = JSON.parse(readFileSync(configPath, "utf-8"));
+    } else {
+      if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+      }
+    }
+    config.auto_update = enabled;
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch {
+  }
+}
+async function attemptAutoUpdate() {
+  const currentVersion = VERSION;
+  if (!isAutoUpdateEnabled()) {
+    return {
+      attempted: false,
+      success: false,
+      previousVersion: currentVersion,
+      newVersion: null,
+      error: "Auto-update disabled"
+    };
+  }
+  const notice = await getUpdateNotice();
+  if (!notice?.behind) {
+    return {
+      attempted: false,
+      success: true,
+      previousVersion: currentVersion,
+      newVersion: null
+    };
+  }
+  const updateMethod = detectUpdateMethod();
+  try {
+    await runUpdate(updateMethod);
+    writeUpdateMarker(currentVersion, notice.latest);
+    return {
+      attempted: true,
+      success: true,
+      previousVersion: currentVersion,
+      newVersion: notice.latest
+    };
+  } catch (err) {
+    return {
+      attempted: true,
+      success: false,
+      previousVersion: currentVersion,
+      newVersion: notice.latest,
+      error: err instanceof Error ? err.message : "Update failed"
+    };
+  }
+}
+function detectUpdateMethod() {
+  const execPath = process.argv[1] || "";
+  if (execPath.includes("node_modules") || execPath.includes("npm")) {
+    return "npm";
+  }
+  const os2 = platform();
+  if (os2 === "win32") {
+    return "powershell";
+  }
+  return "curl";
+}
+async function runUpdate(method) {
+  return new Promise((resolve16, reject) => {
+    let command;
+    let args;
+    let shell;
+    switch (method) {
+      case "npm":
+        command = "npm";
+        args = ["install", "-g", "@contextstream/mcp-server@latest"];
+        shell = false;
+        break;
+      case "curl":
+        command = "bash";
+        args = ["-c", "curl -fsSL https://contextstream.io/scripts/setup.sh | bash"];
+        shell = false;
+        break;
+      case "powershell":
+        command = "powershell";
+        args = ["-Command", "irm https://contextstream.io/scripts/setup.ps1 | iex"];
+        shell = false;
+        break;
+    }
+    const proc = spawn(command, args, {
+      shell,
+      stdio: "ignore",
+      detached: true
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve16();
+      } else {
+        reject(new Error(`Update process exited with code ${code}`));
+      }
+    });
+    proc.unref();
+    setTimeout(() => resolve16(), 1e3);
+  });
+}
+function writeUpdateMarker(previousVersion, newVersion) {
+  try {
+    const markerPath = join(homedir(), ".contextstream", "update-pending.json");
+    const configDir = join(homedir(), ".contextstream");
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(markerPath, JSON.stringify({
+      previousVersion,
+      newVersion,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  } catch {
+  }
+}
+function checkUpdateMarker() {
+  try {
+    const markerPath = join(homedir(), ".contextstream", "update-pending.json");
+    if (!existsSync(markerPath)) return null;
+    const marker = JSON.parse(readFileSync(markerPath, "utf-8"));
+    const updatedAt = new Date(marker.updatedAt);
+    const hourAgo = new Date(Date.now() - 60 * 60 * 1e3);
+    if (updatedAt < hourAgo) {
+      try {
+        __require("fs").unlinkSync(markerPath);
+      } catch {
+      }
+      return null;
+    }
+    return { previousVersion: marker.previousVersion, newVersion: marker.newVersion };
+  } catch {
+    return null;
+  }
+}
+function clearUpdateMarker() {
+  try {
+    const markerPath = join(homedir(), ".contextstream", "update-pending.json");
+    if (existsSync(markerPath)) {
+      __require("fs").unlinkSync(markerPath);
+    }
+  } catch {
+  }
+}
+var NPM_LATEST_URL, AUTO_UPDATE_ENABLED, UPDATE_COMMANDS, UPGRADE_COMMAND, VERSION, CACHE_TTL_MS, latestVersionPromise;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    NPM_LATEST_URL = "https://registry.npmjs.org/@contextstream/mcp-server/latest";
+    AUTO_UPDATE_ENABLED = process.env.CONTEXTSTREAM_AUTO_UPDATE !== "false";
+    UPDATE_COMMANDS = {
+      npm: "npm install -g @contextstream/mcp-server@latest",
+      macLinux: "curl -fsSL https://contextstream.io/scripts/setup.sh | bash",
+      windows: "irm https://contextstream.io/scripts/setup.ps1 | iex"
+    };
+    UPGRADE_COMMAND = UPDATE_COMMANDS.npm;
+    VERSION = getVersion();
+    CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+    latestVersionPromise = null;
+  }
+});
+
 // node_modules/ignore/index.js
 var require_ignore = __commonJS({
   "node_modules/ignore/index.js"(exports, module) {
@@ -2772,46 +3154,291 @@ function loadConfigFromMcpJson(cwd) {
     }
   }
 }
+function readTranscriptFile(transcriptPath) {
+  try {
+    const content = fs10.readFileSync(transcriptPath, "utf-8");
+    const lines = content.trim().split("\n");
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user" || entry.type === "assistant") {
+          const msg = entry.message;
+          if (msg?.role && msg?.content) {
+            let textContent = "";
+            if (typeof msg.content === "string") {
+              textContent = msg.content;
+            } else if (Array.isArray(msg.content)) {
+              textContent = msg.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+            }
+            if (textContent) {
+              messages.push({ role: msg.role, content: textContent });
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return messages;
+  } catch {
+    return [];
+  }
+}
+function extractLastExchange(input, editorFormat) {
+  try {
+    if (editorFormat === "claude" && input.transcript_path) {
+      const messages = readTranscriptFile(input.transcript_path);
+      if (messages.length < 2) return null;
+      let lastAssistantIdx = -1;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "assistant") {
+          lastAssistantIdx = i;
+          break;
+        }
+      }
+      if (lastAssistantIdx < 1) return null;
+      let lastUserIdx = -1;
+      for (let i = lastAssistantIdx - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx < 0) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        userMessage: { role: "user", content: messages[lastUserIdx].content, timestamp: now },
+        assistantMessage: { role: "assistant", content: messages[lastAssistantIdx].content, timestamp: now },
+        sessionId: input.session_id
+      };
+    }
+    if (editorFormat === "claude" && input.session?.messages) {
+      const messages = input.session.messages;
+      if (messages.length < 2) return null;
+      let lastAssistantIdx = -1;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "assistant") {
+          lastAssistantIdx = i;
+          break;
+        }
+      }
+      if (lastAssistantIdx < 1) return null;
+      let lastUserIdx = -1;
+      for (let i = lastAssistantIdx - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx < 0) return null;
+      const userMsg = messages[lastUserIdx];
+      const assistantMsg = messages[lastAssistantIdx];
+      const extractContent = (content) => {
+        if (typeof content === "string") return content;
+        if (Array.isArray(content)) {
+          return content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+        }
+        return "";
+      };
+      const userContent = extractContent(userMsg.content);
+      const assistantContent = extractContent(assistantMsg.content);
+      if (!userContent || !assistantContent) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        userMessage: { role: "user", content: userContent, timestamp: now },
+        assistantMessage: { role: "assistant", content: assistantContent, timestamp: now },
+        sessionId: input.session_id
+      };
+    }
+    if ((editorFormat === "cursor" || editorFormat === "antigravity") && input.history) {
+      const history = input.history;
+      if (history.length < 2) return null;
+      let lastAssistantIdx = -1;
+      for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].role === "assistant") {
+          lastAssistantIdx = i;
+          break;
+        }
+      }
+      if (lastAssistantIdx < 1) return null;
+      let lastUserIdx = -1;
+      for (let i = lastAssistantIdx - 1; i >= 0; i--) {
+        if (history[i].role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx < 0) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        userMessage: { role: "user", content: history[lastUserIdx].content, timestamp: now },
+        assistantMessage: { role: "assistant", content: history[lastAssistantIdx].content, timestamp: now },
+        sessionId: input.conversationId || input.session_id
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveLastExchange(exchange, cwd, clientName) {
+  if (!API_KEY2) return;
+  const sessionId = exchange.sessionId || `hook-${Buffer.from(cwd).toString("base64").slice(0, 16)}`;
+  const payload = {
+    session_id: sessionId,
+    user_message: exchange.userMessage.content,
+    assistant_message: exchange.assistantMessage.content,
+    client_name: clientName
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  if (PROJECT_ID) {
+    payload.project_id = PROJECT_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    await fetch(`${API_URL2}/api/v1/transcripts/exchange`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY2
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
 async function fetchSessionContext() {
   if (!API_KEY2) return null;
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 3e3);
-    const url = new URL(`${API_URL2}/api/v1/context`);
-    if (WORKSPACE_ID) url.searchParams.set("workspace_id", WORKSPACE_ID);
-    if (PROJECT_ID) url.searchParams.set("project_id", PROJECT_ID);
-    url.searchParams.set("include_lessons", "true");
-    url.searchParams.set("include_decisions", "true");
-    url.searchParams.set("include_plans", "true");
-    url.searchParams.set("include_reminders", "true");
-    url.searchParams.set("limit", "3");
-    const response = await fetch(url.toString(), {
-      method: "GET",
+    const url = `${API_URL2}/api/v1/context/smart`;
+    const body = {
+      user_message: "hook context fetch",
+      max_tokens: 200,
+      format: "readable"
+    };
+    if (WORKSPACE_ID) body.workspace_id = WORKSPACE_ID;
+    if (PROJECT_ID) body.project_id = PROJECT_ID;
+    const response = await fetch(url, {
+      method: "POST",
       headers: {
-        "X-API-Key": API_KEY2
+        "X-API-Key": API_KEY2,
+        "Content-Type": "application/json"
       },
+      body: JSON.stringify(body),
       signal: controller.signal
     });
     clearTimeout(timeoutId);
     if (response.ok) {
-      return await response.json();
+      const data = await response.json();
+      return transformSmartContextResponse(data);
     }
     return null;
   } catch {
     return null;
   }
 }
-function buildEnhancedReminder(ctx, isNewSession2) {
+function transformSmartContextResponse(data) {
+  try {
+    const response = data;
+    const result = {};
+    if (response.data?.warnings && response.data.warnings.length > 0) {
+      result.lessons = response.data.warnings.map((w) => ({
+        title: "Lesson",
+        trigger: "",
+        prevention: w.replace(/^\[LESSONS_WARNING\]\s*/, "")
+      }));
+    }
+    if (response.data?.items) {
+      for (const item of response.data.items) {
+        if (item.item_type === "preference") {
+          if (!result.preferences) result.preferences = [];
+          result.preferences.push({
+            title: item.title,
+            content: item.content,
+            importance: item.metadata?.importance || "medium"
+          });
+        } else if (item.item_type === "plan") {
+          if (!result.active_plans) result.active_plans = [];
+          result.active_plans.push({
+            title: item.title,
+            status: "active"
+          });
+        } else if (item.item_type === "task") {
+          if (!result.pending_tasks) result.pending_tasks = [];
+          result.pending_tasks.push({
+            title: item.title,
+            status: "pending"
+          });
+        } else if (item.item_type === "reminder") {
+          if (!result.reminders) result.reminders = [];
+          result.reminders.push({
+            title: item.title,
+            content: item.content
+          });
+        }
+      }
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function buildClaudeReminder(ctx, versionNotice) {
+  const parts = [];
+  if (versionNotice?.behind) {
+    const versionInfo = getVersionNoticeForHook(versionNotice);
+    if (versionInfo) {
+      parts.push(versionInfo);
+      parts.push("");
+    }
+  }
+  const highImportancePrefs = ctx?.preferences?.filter((p) => p.importance === "high") || [];
+  if (highImportancePrefs.length > 0) {
+    parts.push(`[USER PREFERENCES - Always respect these]`);
+    for (const pref of highImportancePrefs.slice(0, 5)) {
+      parts.push(`\u2022 ${pref.title}: ${pref.content}`);
+    }
+    parts.push("");
+  }
+  parts.push(REMINDER);
+  return parts.join("\n");
+}
+function buildEnhancedReminder(ctx, isNewSession2, versionNotice) {
   const parts = [ENHANCED_REMINDER_HEADER];
+  if (versionNotice?.behind) {
+    const versionInfo = getVersionNoticeForHook(versionNotice);
+    if (versionInfo) {
+      parts.push(`## \u{1F504} UPDATE AVAILABLE
+`);
+      parts.push(versionInfo);
+      parts.push("");
+    }
+  }
   if (isNewSession2) {
     parts.push(`## \u{1F680} NEW SESSION DETECTED
 1. Call \`init(folder_path="...")\` - this triggers project indexing
 2. Wait for indexing: if \`init\` returns \`indexing_status: "started"\`, files are being indexed
-3. Then call \`context(user_message="...")\` for task-specific context
-4. Use \`search(mode="hybrid")\` for code discovery (not Glob/Grep/Read)
+3. Generate a unique session_id (e.g., "session-" + timestamp or UUID) - use this for ALL context() calls
+4. Call \`context(user_message="...", save_exchange=true, session_id="<your-session-id>")\` for task-specific context
+5. Use \`search(mode="hybrid")\` for code discovery (not Glob/Grep/Read)
 
 `);
   }
+  const highImportancePrefs = ctx?.preferences?.filter((p) => p.importance === "high") || [];
+  if (highImportancePrefs.length > 0) {
+    parts.push(`## \u2699\uFE0F USER PREFERENCES - Always respect these`);
+    for (const pref of highImportancePrefs.slice(0, 5)) {
+      parts.push(`- **${pref.title}**: ${pref.content}`);
+    }
+    parts.push("");
+  }
   if (ctx?.lessons && ctx.lessons.length > 0) {
     parts.push(`## \u26A0\uFE0F LESSONS FROM PAST MISTAKES`);
     for (const lesson of ctx.lessons.slice(0, 3)) {
@@ -2929,20 +3556,26 @@ async function runUserPromptSubmitHook() {
   }
   const editorFormat = detectEditorFormat2(input);
   const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const versionNoticePromise = getUpdateNotice();
+  const lastExchange = extractLastExchange(input, editorFormat);
+  const clientName = editorFormat === "claude" ? "claude-code" : editorFormat;
+  const saveExchangePromise = lastExchange ? saveLastExchange(lastExchange, cwd, clientName) : Promise.resolve();
   if (editorFormat === "claude") {
+    const [ctx, versionNotice] = await Promise.all([fetchSessionContext(), versionNoticePromise, saveExchangePromise]);
+    const claudeReminder = buildClaudeReminder(ctx, versionNotice);
     console.log(
       JSON.stringify({
         hookSpecificOutput: {
           hookEventName: "UserPromptSubmit",
-          additionalContext: REMINDER
+          additionalContext: claudeReminder
         }
       })
     );
   } else if (editorFormat === "cline") {
-    loadConfigFromMcpJson(cwd);
     const newSession = isNewSession(input, editorFormat);
-    const ctx = await fetchSessionContext();
-    const enhancedReminder = buildEnhancedReminder(ctx, newSession);
+    const [ctx, versionNotice] = await Promise.all([fetchSessionContext(), versionNoticePromise, saveExchangePromise]);
+    const enhancedReminder = buildEnhancedReminder(ctx, newSession, versionNotice);
     console.log(
       JSON.stringify({
         cancel: false,
@@ -2950,10 +3583,12 @@ async function runUserPromptSubmitHook() {
       })
     );
   } else if (editorFormat === "cursor") {
-    loadConfigFromMcpJson(cwd);
     const newSession = isNewSession(input, editorFormat);
-    const ctx = await fetchSessionContext();
-    const cursorReminder = ctx?.lessons?.length ? `[CONTEXTSTREAM] \u26A0\uFE0F ${ctx.lessons.length} lessons from past mistakes. Use search(mode="hybrid") before Glob/Grep. Call context() first. After file edits: project(action="index") to re-index.` : `[CONTEXTSTREAM] Use search(mode="hybrid") before Glob/Grep/Read. Call context() first. After file edits: project(action="index") to re-index.`;
+    const [ctx, versionNotice] = await Promise.all([fetchSessionContext(), versionNoticePromise, saveExchangePromise]);
+    let cursorReminder = ctx?.lessons?.length ? `[CONTEXTSTREAM] \u26A0\uFE0F ${ctx.lessons.length} lessons from past mistakes. Call context(save_exchange=true, session_id="...") FIRST. Use search(mode="hybrid") before Glob/Grep. After file edits: project(action="index").` : `[CONTEXTSTREAM] Call context(save_exchange=true, session_id="...") FIRST. Use search(mode="hybrid") before Glob/Grep/Read. After file edits: project(action="index").`;
+    if (versionNotice?.behind) {
+      cursorReminder += ` [UPDATE v${versionNotice.current}\u2192${versionNotice.latest}]`;
+    }
     console.log(
       JSON.stringify({
         continue: true,
@@ -2961,10 +3596,9 @@ async function runUserPromptSubmitHook() {
       })
     );
   } else if (editorFormat === "antigravity") {
-    loadConfigFromMcpJson(cwd);
     const newSession = isNewSession(input, editorFormat);
-    const ctx = await fetchSessionContext();
-    const enhancedReminder = buildEnhancedReminder(ctx, newSession);
+    const [ctx, versionNotice] = await Promise.all([fetchSessionContext(), versionNoticePromise, saveExchangePromise]);
+    const enhancedReminder = buildEnhancedReminder(ctx, newSession, versionNotice);
     console.log(
       JSON.stringify({
         cancel: false,
@@ -2978,6 +3612,7 @@ var ENABLED3, API_URL2, API_KEY2, WORKSPACE_ID, PROJECT_ID, REMINDER, ENHANCED_R
 var init_user_prompt_submit = __esm({
   "src/hooks/user-prompt-submit.ts"() {
     "use strict";
+    init_version();
     ENABLED3 = process.env.CONTEXTSTREAM_REMINDER_ENABLED !== "false";
     API_URL2 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
     API_KEY2 = process.env.CONTEXTSTREAM_API_KEY || "";
@@ -2985,9 +3620,11 @@ var init_user_prompt_submit = __esm({
     PROJECT_ID = null;
     REMINDER = `[CONTEXTSTREAM RULES - MANDATORY]
 
-1. FIRST: Call mcp__contextstream__context(user_message="...") before ANY other tool
+1. FIRST: Call mcp__contextstream__context(user_message="...", save_exchange=true, session_id="<session-id>") before ANY other tool
    - Returns: dynamic rules, lessons from past mistakes, relevant context
    - Check response for: [LESSONS_WARNING], [RULES_NOTICE], preferences
+   - save_exchange=true saves each conversation turn for later retrieval
+   - Use a consistent session_id for the entire conversation (generate once on first message)
 
 2. FOR CODE SEARCH: Check index status, then search appropriately
    \u26A0\uFE0F BEFORE searching: mcp__contextstream__project(action="index_status")
@@ -3014,7 +3651,7 @@ var init_user_prompt_submit = __esm({
 
 6. SKIP CONTEXTSTREAM: If user preference says "skip contextstream", use local tools instead
 [END]`;
-    ENHANCED_REMINDER_HEADER = `[CONTEXTSTREAM - ENHANCED CONTEXT]
+    ENHANCED_REMINDER_HEADER = `\u2B21 ContextStream \u2014 Smart Context & Memory
 
 `;
     isDirectRun3 = process.argv[1]?.includes("user-prompt-submit") || process.argv[2] === "user-prompt-submit";
@@ -4559,13 +5196,44 @@ async function fetchSessionContext2() {
     return null;
   }
 }
-function formatContext(ctx) {
+function formatContext(ctx, options = {}) {
+  const parts = ["\u2B21 ContextStream \u2014 Smart Context & Memory", ""];
+  if (options.updateMarker) {
+    parts.push(`
+## \u{1F389} UPDATE COMPLETE - RESTART CHAT SESSION`);
+    parts.push(`ContextStream was auto-updated from v${options.updateMarker.previousVersion} to v${options.updateMarker.newVersion}.`);
+    parts.push(`**Tell the user:** "ContextStream has been updated! Please start a new chat session (or restart your AI tool) to use the new version with the latest features and fixes."`);
+    parts.push("");
+  } else if (options.autoUpdateResult?.attempted) {
+    if (options.autoUpdateResult.success) {
+      parts.push(`
+## \u{1F504} AUTO-UPDATE INITIATED`);
+      parts.push(`ContextStream is updating from v${options.autoUpdateResult.previousVersion} to v${options.autoUpdateResult.newVersion}.`);
+      parts.push(`**Tell the user:** "ContextStream is updating in the background. Please start a new chat session (or restart your AI tool) in a moment to use the new version."`);
+      parts.push("");
+    } else if (options.autoUpdateResult.error) {
+      parts.push(`
+## \u26A0\uFE0F AUTO-UPDATE FAILED`);
+      parts.push(`Automatic update failed: ${options.autoUpdateResult.error}`);
+      const versionInfo = getVersionNoticeForHook(options.versionNotice || null);
+      if (versionInfo) {
+        parts.push(versionInfo);
+      }
+      parts.push("");
+    }
+  } else if (options.versionNotice?.behind && !isAutoUpdateEnabled()) {
+    const versionInfo = getVersionNoticeForHook(options.versionNotice);
+    if (versionInfo) {
+      parts.push(`
+## \u{1F504} UPDATE AVAILABLE (auto-update disabled)`);
+      parts.push(versionInfo);
+      parts.push("");
+    }
+  }
   if (!ctx) {
-    return `[ContextStream Session Start]
-
-No stored context found. Call \`mcp__contextstream__context(user_message="starting new session")\` to initialize.`;
+    parts.push('\nNo stored context found. Call `mcp__contextstream__context(user_message="starting new session")` to initialize.');
+    return parts.join("\n");
   }
-  const parts = ["[ContextStream Session Start]"];
   if (ctx.lessons && ctx.lessons.length > 0) {
     parts.push("\n## \u26A0\uFE0F Lessons from Past Mistakes");
     for (const lesson of ctx.lessons.slice(0, 3)) {
@@ -4613,8 +5281,21 @@ async function runSessionInitHook() {
   }
   const cwd = input.cwd || process.cwd();
   loadConfigFromMcpJson8(cwd);
-  const context = await fetchSessionContext2();
-  const formattedContext = formatContext(context);
+  const updateMarker = checkUpdateMarker();
+  if (updateMarker) {
+    clearUpdateMarker();
+  }
+  const [context, autoUpdateResult, versionNotice] = await Promise.all([
+    fetchSessionContext2(),
+    updateMarker ? Promise.resolve(null) : attemptAutoUpdate(),
+    // Skip if already updated
+    getUpdateNotice()
+  ]);
+  const formattedContext = formatContext(context, {
+    autoUpdateResult,
+    versionNotice,
+    updateMarker
+  });
   console.log(
     JSON.stringify({
       hookSpecificOutput: {
@@ -4629,6 +5310,7 @@ var ENABLED12, API_URL10, API_KEY10, WORKSPACE_ID8, PROJECT_ID2, isDirectRun12;
 var init_session_init = __esm({
   "src/hooks/session-init.ts"() {
     "use strict";
+    init_version();
     ENABLED12 = process.env.CONTEXTSTREAM_SESSION_INIT_ENABLED !== "false";
     API_URL10 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
     API_KEY10 = process.env.CONTEXTSTREAM_API_KEY || "";
@@ -4669,15 +5351,18 @@ function loadConfigFromMcpJson9(cwd) {
         }
       }
     }
-    if (!WORKSPACE_ID9) {
+    if (!WORKSPACE_ID9 || !PROJECT_ID3) {
       const csConfigPath = path20.join(searchDir, ".contextstream", "config.json");
       if (fs19.existsSync(csConfigPath)) {
         try {
           const content = fs19.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
-          if (csConfig.workspace_id) {
+          if (csConfig.workspace_id && !WORKSPACE_ID9) {
             WORKSPACE_ID9 = csConfig.workspace_id;
           }
+          if (csConfig.project_id && !PROJECT_ID3) {
+            PROJECT_ID3 = csConfig.project_id;
+          }
         } catch {
         }
       }
@@ -4709,7 +5394,9 @@ function parseTranscriptStats(transcriptPath) {
     messageCount: 0,
     toolCallCount: 0,
     duration: 0,
-    filesModified: []
+    filesModified: [],
+    messages: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   if (!transcriptPath || !fs19.existsSync(transcriptPath)) {
     return stats;
@@ -4724,26 +5411,63 @@ function parseTranscriptStats(transcriptPath) {
       if (!line.trim()) continue;
       try {
         const entry = JSON.parse(line);
-        if (entry.type === "user" || entry.type === "assistant") {
-          stats.messageCount++;
-        } else if (entry.type === "tool_use") {
-          stats.toolCallCount++;
-          if (["Write", "Edit", "NotebookEdit"].includes(entry.name || "")) {
-            const filePath = entry.input?.file_path;
-            if (filePath) {
-              modifiedFiles.add(filePath);
-            }
-          }
-        }
+        const msgType = entry.type || "";
+        const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
         if (entry.timestamp) {
           const ts = new Date(entry.timestamp);
           if (!firstTimestamp || ts < firstTimestamp) {
             firstTimestamp = ts;
+            stats.startedAt = entry.timestamp;
           }
           if (!lastTimestamp || ts > lastTimestamp) {
             lastTimestamp = ts;
           }
         }
+        if (msgType === "user" || entry.role === "user") {
+          stats.messageCount++;
+          const userContent = typeof entry.content === "string" ? entry.content : "";
+          if (userContent) {
+            stats.messages.push({
+              role: "user",
+              content: userContent,
+              timestamp
+            });
+          }
+        } else if (msgType === "assistant" || entry.role === "assistant") {
+          stats.messageCount++;
+          const assistantContent = typeof entry.content === "string" ? entry.content : "";
+          if (assistantContent) {
+            stats.messages.push({
+              role: "assistant",
+              content: assistantContent,
+              timestamp
+            });
+          }
+        } else if (msgType === "tool_use") {
+          stats.toolCallCount++;
+          const toolName = entry.name || "";
+          const toolInput = entry.input || {};
+          if (["Write", "Edit", "NotebookEdit"].includes(toolName)) {
+            const filePath = toolInput.file_path || toolInput.notebook_path;
+            if (filePath) {
+              modifiedFiles.add(filePath);
+            }
+          }
+          stats.messages.push({
+            role: "assistant",
+            content: `[Tool: ${toolName}]`,
+            timestamp,
+            tool_calls: { name: toolName, input: toolInput }
+          });
+        } else if (msgType === "tool_result") {
+          const resultContent = typeof entry.content === "string" ? entry.content.slice(0, 2e3) : JSON.stringify(entry.content || {}).slice(0, 2e3);
+          stats.messages.push({
+            role: "tool",
+            content: resultContent,
+            timestamp,
+            tool_results: { name: entry.name }
+          });
+        }
       } catch {
         continue;
       }
@@ -4751,15 +5475,66 @@ function parseTranscriptStats(transcriptPath) {
     if (firstTimestamp && lastTimestamp) {
       stats.duration = Math.round((lastTimestamp.getTime() - firstTimestamp.getTime()) / 1e3);
     }
-    stats.filesModified = Array.from(modifiedFiles);
-  } catch {
+    stats.filesModified = Array.from(modifiedFiles);
+  } catch {
+  }
+  return stats;
+}
+async function saveFullTranscript2(sessionId, stats, reason) {
+  if (!API_KEY11) {
+    return { success: false, message: "No API key configured" };
+  }
+  if (stats.messages.length === 0) {
+    return { success: false, message: "No messages to save" };
+  }
+  const payload = {
+    session_id: sessionId,
+    messages: stats.messages,
+    started_at: stats.startedAt,
+    source_type: "session_end",
+    title: `Session transcript (${reason})`,
+    metadata: {
+      reason,
+      tool_call_count: stats.toolCallCount,
+      files_modified: stats.filesModified.slice(0, 20),
+      duration_seconds: stats.duration
+    },
+    tags: ["session_end", reason]
+  };
+  if (WORKSPACE_ID9) {
+    payload.workspace_id = WORKSPACE_ID9;
+  }
+  if (PROJECT_ID3) {
+    payload.project_id = PROJECT_ID3;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const response = await fetch(`${API_URL11}/api/v1/transcripts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY11
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return { success: true, message: `Transcript saved (${stats.messages.length} messages)` };
+    }
+    return { success: false, message: `API error: ${response.status}` };
+  } catch (error) {
+    return { success: false, message: String(error) };
   }
-  return stats;
 }
 async function finalizeSession(sessionId, stats, reason) {
   if (!API_KEY11) return;
+  if (SAVE_TRANSCRIPT && stats.messages.length > 0) {
+    await saveFullTranscript2(sessionId, stats, reason);
+  }
   const payload = {
-    event_type: "session_end",
+    event_type: "manual_note",
     title: `Session Ended: ${reason}`,
     content: JSON.stringify({
       session_id: sessionId,
@@ -4775,8 +5550,7 @@ async function finalizeSession(sessionId, stats, reason) {
     }),
     importance: "low",
     tags: ["session", "end", reason],
-    source_type: "hook",
-    session_id: sessionId
+    source_type: "hook"
   };
   if (WORKSPACE_ID9) {
     payload.workspace_id = WORKSPACE_ID9;
@@ -4823,14 +5597,16 @@ async function runSessionEndHook() {
   await finalizeSession(sessionId, stats, reason);
   process.exit(0);
 }
-var ENABLED13, API_URL11, API_KEY11, WORKSPACE_ID9, isDirectRun13;
+var ENABLED13, SAVE_TRANSCRIPT, API_URL11, API_KEY11, WORKSPACE_ID9, PROJECT_ID3, isDirectRun13;
 var init_session_end = __esm({
   "src/hooks/session-end.ts"() {
     "use strict";
     ENABLED13 = process.env.CONTEXTSTREAM_SESSION_END_ENABLED !== "false";
+    SAVE_TRANSCRIPT = process.env.CONTEXTSTREAM_SESSION_END_SAVE_TRANSCRIPT !== "false";
     API_URL11 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
     API_KEY11 = process.env.CONTEXTSTREAM_API_KEY || "";
     WORKSPACE_ID9 = null;
+    PROJECT_ID3 = null;
     isDirectRun13 = process.argv[1]?.includes("session-end") || process.argv[2] === "session-end";
     if (isDirectRun13) {
       runSessionEndHook().catch(() => process.exit(0));
@@ -4988,10 +5764,11 @@ import * as fs20 from "node:fs";
 import * as path21 from "node:path";
 import { homedir as homedir18 } from "node:os";
 function maskApiKey2(key) {
-  if (!key || key.length < 10) return "***";
-  const prefix = key.slice(0, 6);
-  const suffix = key.slice(-4);
-  return `${prefix}...${suffix}`;
+  if (!key || key.length < 8) return "***";
+  const prefixMatch = key.match(/^([a-z]{2,3}_)/i);
+  const prefix = prefixMatch ? prefixMatch[1] : "";
+  const suffix = key.slice(-3);
+  return `${prefix}***...${suffix}`;
 }
 function extractFromMcpConfig(config) {
   if (!config.mcpServers) return {};
@@ -5016,10 +5793,10 @@ function extractFromMcpConfig(config) {
   return {};
 }
 function getClaudeDesktopConfigPath() {
-  const platform = process.platform;
-  if (platform === "darwin") {
+  const platform2 = process.platform;
+  if (platform2 === "darwin") {
     return path21.join(homedir18(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  } else if (platform === "win32") {
+  } else if (platform2 === "win32") {
     return path21.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
   } else {
     return path21.join(homedir18(), ".config", "Claude", "claude_desktop_config.json");
@@ -5174,6 +5951,7 @@ async function validateApiKey(apiKey, apiUrl) {
       return {
         valid: true,
         masked_key: maskApiKey2(apiKey),
+        // lgtm[js/clear-text-logging]
         email: data.email,
         name: data.name || data.full_name,
         plan: data.plan_name || data.plan || "free",
@@ -5183,12 +5961,14 @@ async function validateApiKey(apiKey, apiUrl) {
       return {
         valid: false,
         masked_key: maskApiKey2(apiKey),
+        // lgtm[js/clear-text-logging]
         error: "Invalid or expired API key"
       };
     } else {
       return {
         valid: false,
         masked_key: maskApiKey2(apiKey),
+        // lgtm[js/clear-text-logging]
         error: `API error: ${response.status}`
       };
     }
@@ -8918,561 +9698,390 @@ var ZodEffects = class extends ZodType {
         const result = effect.transform(base.value, checkCtx);
         if (result instanceof Promise) {
           throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
-        }
-        return { status: status.value, value: result };
-      } else {
-        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
-          if (!isValid(base))
-            return INVALID;
-          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
-            status: status.value,
-            value: result
-          }));
-        });
-      }
-    }
-    util.assertNever(effect);
-  }
-};
-ZodEffects.create = (schema, effect, params) => {
-  return new ZodEffects({
-    schema,
-    typeName: ZodFirstPartyTypeKind.ZodEffects,
-    effect,
-    ...processCreateParams(params)
-  });
-};
-ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
-  return new ZodEffects({
-    schema,
-    effect: { type: "preprocess", transform: preprocess },
-    typeName: ZodFirstPartyTypeKind.ZodEffects,
-    ...processCreateParams(params)
-  });
-};
-var ZodOptional = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
-    if (parsedType === ZodParsedType.undefined) {
-      return OK(void 0);
-    }
-    return this._def.innerType._parse(input);
-  }
-  unwrap() {
-    return this._def.innerType;
-  }
-};
-ZodOptional.create = (type, params) => {
-  return new ZodOptional({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodOptional,
-    ...processCreateParams(params)
-  });
-};
-var ZodNullable = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
-    if (parsedType === ZodParsedType.null) {
-      return OK(null);
-    }
-    return this._def.innerType._parse(input);
-  }
-  unwrap() {
-    return this._def.innerType;
-  }
-};
-ZodNullable.create = (type, params) => {
-  return new ZodNullable({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodNullable,
-    ...processCreateParams(params)
-  });
-};
-var ZodDefault = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    let data = ctx.data;
-    if (ctx.parsedType === ZodParsedType.undefined) {
-      data = this._def.defaultValue();
-    }
-    return this._def.innerType._parse({
-      data,
-      path: ctx.path,
-      parent: ctx
-    });
-  }
-  removeDefault() {
-    return this._def.innerType;
-  }
-};
-ZodDefault.create = (type, params) => {
-  return new ZodDefault({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodDefault,
-    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
-    ...processCreateParams(params)
-  });
-};
-var ZodCatch = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const newCtx = {
-      ...ctx,
-      common: {
-        ...ctx.common,
-        issues: []
-      }
-    };
-    const result = this._def.innerType._parse({
-      data: newCtx.data,
-      path: newCtx.path,
-      parent: {
-        ...newCtx
-      }
-    });
-    if (isAsync(result)) {
-      return result.then((result2) => {
-        return {
-          status: "valid",
-          value: result2.status === "valid" ? result2.value : this._def.catchValue({
-            get error() {
-              return new ZodError(newCtx.common.issues);
-            },
-            input: newCtx.data
-          })
-        };
-      });
-    } else {
-      return {
-        status: "valid",
-        value: result.status === "valid" ? result.value : this._def.catchValue({
-          get error() {
-            return new ZodError(newCtx.common.issues);
-          },
-          input: newCtx.data
-        })
-      };
-    }
-  }
-  removeCatch() {
-    return this._def.innerType;
-  }
-};
-ZodCatch.create = (type, params) => {
-  return new ZodCatch({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodCatch,
-    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
-    ...processCreateParams(params)
-  });
-};
-var ZodNaN = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
-    if (parsedType !== ZodParsedType.nan) {
-      const ctx = this._getOrReturnCtx(input);
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.nan,
-        received: ctx.parsedType
-      });
-      return INVALID;
-    }
-    return { status: "valid", value: input.data };
-  }
-};
-ZodNaN.create = (params) => {
-  return new ZodNaN({
-    typeName: ZodFirstPartyTypeKind.ZodNaN,
-    ...processCreateParams(params)
-  });
-};
-var BRAND = /* @__PURE__ */ Symbol("zod_brand");
-var ZodBranded = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const data = ctx.data;
-    return this._def.type._parse({
-      data,
-      path: ctx.path,
-      parent: ctx
-    });
-  }
-  unwrap() {
-    return this._def.type;
-  }
-};
-var ZodPipeline = class _ZodPipeline extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.common.async) {
-      const handleAsync = async () => {
-        const inResult = await this._def.in._parseAsync({
-          data: ctx.data,
-          path: ctx.path,
-          parent: ctx
-        });
-        if (inResult.status === "aborted")
-          return INVALID;
-        if (inResult.status === "dirty") {
-          status.dirty();
-          return DIRTY(inResult.value);
-        } else {
-          return this._def.out._parseAsync({
-            data: inResult.value,
-            path: ctx.path,
-            parent: ctx
-          });
-        }
-      };
-      return handleAsync();
-    } else {
-      const inResult = this._def.in._parseSync({
-        data: ctx.data,
-        path: ctx.path,
-        parent: ctx
-      });
-      if (inResult.status === "aborted")
-        return INVALID;
-      if (inResult.status === "dirty") {
-        status.dirty();
-        return {
-          status: "dirty",
-          value: inResult.value
-        };
+        }
+        return { status: status.value, value: result };
       } else {
-        return this._def.out._parseSync({
-          data: inResult.value,
-          path: ctx.path,
-          parent: ctx
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
+          if (!isValid(base))
+            return INVALID;
+          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+            status: status.value,
+            value: result
+          }));
         });
       }
     }
-  }
-  static create(a, b) {
-    return new _ZodPipeline({
-      in: a,
-      out: b,
-      typeName: ZodFirstPartyTypeKind.ZodPipeline
-    });
+    util.assertNever(effect);
   }
 };
-var ZodReadonly = class extends ZodType {
+ZodEffects.create = (schema, effect, params) => {
+  return new ZodEffects({
+    schema,
+    typeName: ZodFirstPartyTypeKind.ZodEffects,
+    effect,
+    ...processCreateParams(params)
+  });
+};
+ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
+  return new ZodEffects({
+    schema,
+    effect: { type: "preprocess", transform: preprocess },
+    typeName: ZodFirstPartyTypeKind.ZodEffects,
+    ...processCreateParams(params)
+  });
+};
+var ZodOptional = class extends ZodType {
   _parse(input) {
-    const result = this._def.innerType._parse(input);
-    const freeze = (data) => {
-      if (isValid(data)) {
-        data.value = Object.freeze(data.value);
-      }
-      return data;
-    };
-    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+    const parsedType = this._getType(input);
+    if (parsedType === ZodParsedType.undefined) {
+      return OK(void 0);
+    }
+    return this._def.innerType._parse(input);
   }
   unwrap() {
     return this._def.innerType;
   }
 };
-ZodReadonly.create = (type, params) => {
-  return new ZodReadonly({
+ZodOptional.create = (type, params) => {
+  return new ZodOptional({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodReadonly,
+    typeName: ZodFirstPartyTypeKind.ZodOptional,
     ...processCreateParams(params)
   });
 };
-function cleanParams(params, data) {
-  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-  const p2 = typeof p === "string" ? { message: p } : p;
-  return p2;
-}
-function custom(check, _params = {}, fatal) {
-  if (check)
-    return ZodAny.create().superRefine((data, ctx) => {
-      const r = check(data);
-      if (r instanceof Promise) {
-        return r.then((r2) => {
-          if (!r2) {
-            const params = cleanParams(_params, data);
-            const _fatal = params.fatal ?? fatal ?? true;
-            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-          }
-        });
-      }
-      if (!r) {
-        const params = cleanParams(_params, data);
-        const _fatal = params.fatal ?? fatal ?? true;
-        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-      }
-      return;
-    });
-  return ZodAny.create();
-}
-var late = {
-  object: ZodObject.lazycreate
-};
-var ZodFirstPartyTypeKind;
-(function(ZodFirstPartyTypeKind2) {
-  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
-  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
-  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
-  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
-  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
-  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
-  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
-  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
-  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
-  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
-  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
-  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
-  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
-  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
-  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
-  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
-  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
-  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
-  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
-  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
-  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
-  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
-  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
-  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
-  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
-  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
-  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
-  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
-  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
-  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
-  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
-  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
-  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
-  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
-  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
-  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
-})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = (cls, params = {
-  message: `Input not instance of ${cls.name}`
-}) => custom((data) => data instanceof cls, params);
-var stringType = ZodString.create;
-var numberType = ZodNumber.create;
-var nanType = ZodNaN.create;
-var bigIntType = ZodBigInt.create;
-var booleanType = ZodBoolean.create;
-var dateType = ZodDate.create;
-var symbolType = ZodSymbol.create;
-var undefinedType = ZodUndefined.create;
-var nullType = ZodNull.create;
-var anyType = ZodAny.create;
-var unknownType = ZodUnknown.create;
-var neverType = ZodNever.create;
-var voidType = ZodVoid.create;
-var arrayType = ZodArray.create;
-var objectType = ZodObject.create;
-var strictObjectType = ZodObject.strictCreate;
-var unionType = ZodUnion.create;
-var discriminatedUnionType = ZodDiscriminatedUnion.create;
-var intersectionType = ZodIntersection.create;
-var tupleType = ZodTuple.create;
-var recordType = ZodRecord.create;
-var mapType = ZodMap.create;
-var setType = ZodSet.create;
-var functionType = ZodFunction.create;
-var lazyType = ZodLazy.create;
-var literalType = ZodLiteral.create;
-var enumType = ZodEnum.create;
-var nativeEnumType = ZodNativeEnum.create;
-var promiseType = ZodPromise.create;
-var effectsType = ZodEffects.create;
-var optionalType = ZodOptional.create;
-var nullableType = ZodNullable.create;
-var preprocessType = ZodEffects.createWithPreprocess;
-var pipelineType = ZodPipeline.create;
-var ostring = () => stringType().optional();
-var onumber = () => numberType().optional();
-var oboolean = () => booleanType().optional();
-var coerce = {
-  string: ((arg) => ZodString.create({ ...arg, coerce: true })),
-  number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),
-  boolean: ((arg) => ZodBoolean.create({
-    ...arg,
-    coerce: true
-  })),
-  bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
-  date: ((arg) => ZodDate.create({ ...arg, coerce: true }))
-};
-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 install -g @contextstream/mcp-server@latest";
-var NPM_LATEST_URL = "https://registry.npmjs.org/@contextstream/mcp-server/latest";
-function getVersion() {
-  if (typeof __CONTEXTSTREAM_VERSION__ !== "undefined" && __CONTEXTSTREAM_VERSION__) {
-    return __CONTEXTSTREAM_VERSION__;
-  }
-  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 });
+var ZodNullable = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType === ZodParsedType.null) {
+      return OK(null);
     }
-    const cacheFile = getCacheFilePath();
-    writeFileSync(
-      cacheFile,
-      JSON.stringify({
-        latestVersion,
-        checkedAt: Date.now()
-      })
-    );
-  } catch {
+    return this._def.innerType._parse(input);
   }
-}
-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;
+  unwrap() {
+    return this._def.innerType;
   }
-}
-async function resolveLatestVersion() {
-  const cached = readCache();
-  if (cached) return cached.latestVersion;
-  if (!latestVersionPromise) {
-    latestVersionPromise = fetchLatestVersion().finally(() => {
-      latestVersionPromise = null;
+};
+ZodNullable.create = (type, params) => {
+  return new ZodNullable({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodNullable,
+    ...processCreateParams(params)
+  });
+};
+var ZodDefault = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    let data = ctx.data;
+    if (ctx.parsedType === ZodParsedType.undefined) {
+      data = this._def.defaultValue();
+    }
+    return this._def.innerType._parse({
+      data,
+      path: ctx.path,
+      parent: ctx
     });
   }
-  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);
+  removeDefault() {
+    return this._def.innerType;
   }
-}
-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) {
+};
+ZodDefault.create = (type, params) => {
+  return new ZodDefault({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodDefault,
+    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+    ...processCreateParams(params)
+  });
+};
+var ZodCatch = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const newCtx = {
+      ...ctx,
+      common: {
+        ...ctx.common,
+        issues: []
+      }
+    };
+    const result = this._def.innerType._parse({
+      data: newCtx.data,
+      path: newCtx.path,
+      parent: {
+        ...newCtx
+      }
+    });
+    if (isAsync(result)) {
+      return result.then((result2) => {
+        return {
+          status: "valid",
+          value: result2.status === "valid" ? result2.value : this._def.catchValue({
+            get error() {
+              return new ZodError(newCtx.common.issues);
+            },
+            input: newCtx.data
+          })
+        };
+      });
+    } else {
       return {
-        current: currentVersion,
-        latest: latestVersion,
-        behind: true,
-        upgrade_command: UPGRADE_COMMAND
+        status: "valid",
+        value: result.status === "valid" ? result.value : this._def.catchValue({
+          get error() {
+            return new ZodError(newCtx.common.issues);
+          },
+          input: newCtx.data
+        })
       };
     }
-  } catch {
   }
-  return null;
-}
-function getVersionsBehind(current, latest) {
-  try {
-    const currentParts = current.split(".").map(Number);
-    const latestParts = latest.split(".").map(Number);
-    if ((latestParts[0] ?? 0) > (currentParts[0] ?? 0)) {
-      return 10 + ((latestParts[1] ?? 0) - (currentParts[1] ?? 0));
+  removeCatch() {
+    return this._def.innerType;
+  }
+};
+ZodCatch.create = (type, params) => {
+  return new ZodCatch({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodCatch,
+    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
+    ...processCreateParams(params)
+  });
+};
+var ZodNaN = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.nan) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.nan,
+        received: ctx.parsedType
+      });
+      return INVALID;
     }
-    const minorDiff = (latestParts[1] ?? 0) - (currentParts[1] ?? 0);
-    const patchDiff = (latestParts[2] ?? 0) - (currentParts[2] ?? 0);
-    if (minorDiff > 0) {
-      return minorDiff;
-    } else if (minorDiff === 0 && patchDiff > 0) {
-      return 1;
+    return { status: "valid", value: input.data };
+  }
+};
+ZodNaN.create = (params) => {
+  return new ZodNaN({
+    typeName: ZodFirstPartyTypeKind.ZodNaN,
+    ...processCreateParams(params)
+  });
+};
+var BRAND = /* @__PURE__ */ Symbol("zod_brand");
+var ZodBranded = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const data = ctx.data;
+    return this._def.type._parse({
+      data,
+      path: ctx.path,
+      parent: ctx
+    });
+  }
+  unwrap() {
+    return this._def.type;
+  }
+};
+var ZodPipeline = class _ZodPipeline extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.common.async) {
+      const handleAsync = async () => {
+        const inResult = await this._def.in._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inResult.status === "aborted")
+          return INVALID;
+        if (inResult.status === "dirty") {
+          status.dirty();
+          return DIRTY(inResult.value);
+        } else {
+          return this._def.out._parseAsync({
+            data: inResult.value,
+            path: ctx.path,
+            parent: ctx
+          });
+        }
+      };
+      return handleAsync();
+    } else {
+      const inResult = this._def.in._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      });
+      if (inResult.status === "aborted")
+        return INVALID;
+      if (inResult.status === "dirty") {
+        status.dirty();
+        return {
+          status: "dirty",
+          value: inResult.value
+        };
+      } else {
+        return this._def.out._parseSync({
+          data: inResult.value,
+          path: ctx.path,
+          parent: ctx
+        });
+      }
     }
-    return 0;
-  } catch {
-    return 0;
   }
-}
-function getVersionWarning(notice) {
-  if (!notice?.behind) return null;
-  const versionsBehind = getVersionsBehind(notice.current, notice.latest);
-  if (versionsBehind >= 3) {
-    return `[VERSION_CRITICAL] MCP server is ${versionsBehind} versions behind (${notice.current} \u2192 ${notice.latest}). Update immediately: ${notice.upgrade_command}`;
-  } else if (versionsBehind >= 1) {
-    return `[VERSION_NOTICE] MCP server update available (${notice.current} \u2192 ${notice.latest}). Run: ${notice.upgrade_command}`;
+  static create(a, b) {
+    return new _ZodPipeline({
+      in: a,
+      out: b,
+      typeName: ZodFirstPartyTypeKind.ZodPipeline
+    });
   }
-  return null;
-}
-function getVersionInstructions(notice) {
-  if (!notice?.behind) return null;
-  const versionsBehind = getVersionsBehind(notice.current, notice.latest);
-  if (versionsBehind >= 5) {
-    return `\u26A0\uFE0F CRITICAL: User's MCP is ${versionsBehind} versions behind. Mention update in EVERY response until updated.`;
-  } else if (versionsBehind >= 3) {
-    return `\u26A0\uFE0F User's MCP is ${versionsBehind} versions behind. Remind about update every 2-3 messages.`;
-  } else if (versionsBehind >= 1) {
-    return `Note: MCP update available (${notice.current}\u2192${notice.latest}). Mention once at session start.`;
+};
+var ZodReadonly = class extends ZodType {
+  _parse(input) {
+    const result = this._def.innerType._parse(input);
+    const freeze = (data) => {
+      if (isValid(data)) {
+        data.value = Object.freeze(data.value);
+      }
+      return data;
+    };
+    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+  }
+  unwrap() {
+    return this._def.innerType;
   }
-  return null;
+};
+ZodReadonly.create = (type, params) => {
+  return new ZodReadonly({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodReadonly,
+    ...processCreateParams(params)
+  });
+};
+function cleanParams(params, data) {
+  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+  const p2 = typeof p === "string" ? { message: p } : p;
+  return p2;
+}
+function custom(check, _params = {}, fatal) {
+  if (check)
+    return ZodAny.create().superRefine((data, ctx) => {
+      const r = check(data);
+      if (r instanceof Promise) {
+        return r.then((r2) => {
+          if (!r2) {
+            const params = cleanParams(_params, data);
+            const _fatal = params.fatal ?? fatal ?? true;
+            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+          }
+        });
+      }
+      if (!r) {
+        const params = cleanParams(_params, data);
+        const _fatal = params.fatal ?? fatal ?? true;
+        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+      }
+      return;
+    });
+  return ZodAny.create();
 }
+var late = {
+  object: ZodObject.lazycreate
+};
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind2) {
+  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
+  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
+  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
+  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
+  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
+  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
+  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
+  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
+  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
+  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
+  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
+  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
+  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
+  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
+  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
+  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
+  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
+  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
+  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
+  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
+  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
+  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
+  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
+  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
+  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
+  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
+  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
+  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
+  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
+  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
+  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
+  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+var instanceOfType = (cls, params = {
+  message: `Input not instance of ${cls.name}`
+}) => custom((data) => data instanceof cls, params);
+var stringType = ZodString.create;
+var numberType = ZodNumber.create;
+var nanType = ZodNaN.create;
+var bigIntType = ZodBigInt.create;
+var booleanType = ZodBoolean.create;
+var dateType = ZodDate.create;
+var symbolType = ZodSymbol.create;
+var undefinedType = ZodUndefined.create;
+var nullType = ZodNull.create;
+var anyType = ZodAny.create;
+var unknownType = ZodUnknown.create;
+var neverType = ZodNever.create;
+var voidType = ZodVoid.create;
+var arrayType = ZodArray.create;
+var objectType = ZodObject.create;
+var strictObjectType = ZodObject.strictCreate;
+var unionType = ZodUnion.create;
+var discriminatedUnionType = ZodDiscriminatedUnion.create;
+var intersectionType = ZodIntersection.create;
+var tupleType = ZodTuple.create;
+var recordType = ZodRecord.create;
+var mapType = ZodMap.create;
+var setType = ZodSet.create;
+var functionType = ZodFunction.create;
+var lazyType = ZodLazy.create;
+var literalType = ZodLiteral.create;
+var enumType = ZodEnum.create;
+var nativeEnumType = ZodNativeEnum.create;
+var promiseType = ZodPromise.create;
+var effectsType = ZodEffects.create;
+var optionalType = ZodOptional.create;
+var nullableType = ZodNullable.create;
+var preprocessType = ZodEffects.createWithPreprocess;
+var pipelineType = ZodPipeline.create;
+var ostring = () => stringType().optional();
+var onumber = () => numberType().optional();
+var oboolean = () => booleanType().optional();
+var coerce = {
+  string: ((arg) => ZodString.create({ ...arg, coerce: true })),
+  number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),
+  boolean: ((arg) => ZodBoolean.create({
+    ...arg,
+    coerce: true
+  })),
+  bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
+  date: ((arg) => ZodDate.create({ ...arg, coerce: true }))
+};
+var NEVER = INVALID;
 
 // src/config.ts
+init_version();
 var DEFAULT_API_URL = "https://api.contextstream.io";
 function parseBooleanEnv(value) {
   if (value === void 0) return void 0;
@@ -9764,6 +10373,10 @@ function rewriteNotFoundMessage(input) {
 // src/files.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as os from "os";
+import * as crypto from "crypto";
 
 // src/ignore.ts
 var import_ignore = __toESM(require_ignore(), 1);
@@ -9837,6 +10450,7 @@ async function loadIgnorePatterns(projectRoot) {
 }
 
 // src/files.ts
+var execAsync = promisify(exec);
 var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
   // Rust
   "rs",
@@ -9944,12 +10558,116 @@ var MAX_FILE_SIZE = 1024 * 1024;
 var MAX_BATCH_BYTES = 10 * 1024 * 1024;
 var LARGE_FILE_THRESHOLD = 2 * 1024 * 1024;
 var MAX_FILES_PER_BATCH = 200;
+var gitContextCache = /* @__PURE__ */ new Map();
+function getMachineId() {
+  const hostname2 = os.hostname();
+  const hash = crypto.createHash("sha256").update(hostname2).digest("hex");
+  return hash.substring(0, 12);
+}
+async function isGitRepo(rootPath) {
+  try {
+    await execAsync("git rev-parse --is-inside-work-tree", {
+      cwd: rootPath,
+      timeout: 5e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitBranch(rootPath) {
+  try {
+    const { stdout: stdout2 } = await execAsync("git branch --show-current", {
+      cwd: rootPath,
+      timeout: 5e3
+    });
+    const branch = stdout2.trim();
+    return branch || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function getGitDefaultBranch(rootPath) {
+  try {
+    const { stdout: stdout2 } = await execAsync(
+      "git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null",
+      { cwd: rootPath, timeout: 5e3 }
+    );
+    const match = stdout2.trim().match(/refs\/remotes\/origin\/(.+)/);
+    if (match) return match[1];
+  } catch {
+  }
+  try {
+    const { stdout: stdout2 } = await execAsync(
+      "git config --get init.defaultBranch 2>/dev/null",
+      { cwd: rootPath, timeout: 5e3 }
+    );
+    const branch = stdout2.trim();
+    if (branch) return branch;
+  } catch {
+  }
+  try {
+    const { stdout: stdout2 } = await execAsync("git branch --list main master", {
+      cwd: rootPath,
+      timeout: 5e3
+    });
+    const branches = stdout2.trim().split("\n").map((b) => b.replace(/^\*?\s*/, "").trim()).filter(Boolean);
+    if (branches.includes("main")) return "main";
+    if (branches.includes("master")) return "master";
+  } catch {
+  }
+  return void 0;
+}
+async function getFileGitInfo(rootPath, relativePath) {
+  try {
+    const { stdout: stdout2 } = await execAsync(
+      `git log -1 --format="%H %ct" -- "${relativePath}"`,
+      { cwd: rootPath, timeout: 5e3 }
+    );
+    const parts = stdout2.trim().split(" ");
+    if (parts.length >= 2) {
+      const sha = parts[0];
+      const unixTimestamp = parseInt(parts[1], 10);
+      if (sha && !isNaN(unixTimestamp)) {
+        const timestamp = new Date(unixTimestamp * 1e3).toISOString();
+        return { sha, timestamp };
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function getGitContext(rootPath) {
+  const cached = gitContextCache.get(rootPath);
+  if (cached) return cached;
+  const machineId = getMachineId();
+  const isRepo = await isGitRepo(rootPath);
+  if (!isRepo) {
+    const context2 = { isGitRepo: false, machineId };
+    gitContextCache.set(rootPath, context2);
+    return context2;
+  }
+  const [branch, defaultBranch] = await Promise.all([
+    getGitBranch(rootPath),
+    getGitDefaultBranch(rootPath)
+  ]);
+  const context = {
+    isGitRepo: true,
+    branch,
+    defaultBranch,
+    isDefaultBranch: branch !== void 0 && branch === defaultBranch,
+    machineId
+  };
+  gitContextCache.set(rootPath, context);
+  return context;
+}
 async function* readAllFilesInBatches(rootPath, options = {}) {
   const maxBatchBytes = options.maxBatchBytes ?? MAX_BATCH_BYTES;
   const largeFileThreshold = options.largeFileThreshold ?? LARGE_FILE_THRESHOLD;
   const maxFilesPerBatch = options.maxFilesPerBatch ?? options.batchSize ?? MAX_FILES_PER_BATCH;
   const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
   const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
+  const gitCtx = await getGitContext(rootPath);
   let batch = [];
   let currentBatchBytes = 0;
   async function* walkDir(dir, relativePath = "") {
@@ -9975,7 +10693,25 @@ async function* readAllFilesInBatches(rootPath, options = {}) {
           const stat2 = await fs2.promises.stat(fullPath);
           if (stat2.size > maxFileSize) continue;
           const content = await fs2.promises.readFile(fullPath, "utf-8");
-          yield { path: relPath, content, sizeBytes: stat2.size };
+          const file = {
+            path: relPath,
+            content,
+            sizeBytes: stat2.size,
+            // Always include machine_id and source_modified_at
+            machine_id: gitCtx.machineId,
+            source_modified_at: stat2.mtime.toISOString()
+          };
+          if (gitCtx.isGitRepo) {
+            file.git_branch = gitCtx.branch;
+            file.git_default_branch = gitCtx.defaultBranch;
+            file.is_default_branch = gitCtx.isDefaultBranch;
+            const gitInfo = await getFileGitInfo(rootPath, relPath);
+            if (gitInfo) {
+              file.git_commit_sha = gitInfo.sha;
+              file.git_commit_timestamp = gitInfo.timestamp;
+            }
+          }
+          yield file;
         } catch {
         }
       }
@@ -9984,11 +10720,12 @@ async function* readAllFilesInBatches(rootPath, options = {}) {
   for await (const file of walkDir(rootPath)) {
     if (file.sizeBytes > largeFileThreshold) {
       if (batch.length > 0) {
-        yield batch.map(({ sizeBytes, ...rest }) => rest);
+        yield batch.map(({ sizeBytes: sizeBytes2, ...rest }) => rest);
         batch = [];
         currentBatchBytes = 0;
       }
-      yield [{ path: file.path, content: file.content }];
+      const { sizeBytes, ...fileData } = file;
+      yield [fileData];
       continue;
     }
     const wouldExceedBytes = currentBatchBytes + file.sizeBytes > maxBatchBytes;
@@ -10014,6 +10751,7 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
   const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
   const sinceMs = sinceTimestamp.getTime();
   const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
+  const gitCtx = await getGitContext(rootPath);
   let batch = [];
   let currentBatchBytes = 0;
   let filesScanned = 0;
@@ -10044,7 +10782,25 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
           if (stat2.size > maxFileSize) continue;
           const content = await fs2.promises.readFile(fullPath, "utf-8");
           filesChanged++;
-          yield { path: relPath, content, sizeBytes: stat2.size };
+          const file = {
+            path: relPath,
+            content,
+            sizeBytes: stat2.size,
+            // Always include machine_id and source_modified_at
+            machine_id: gitCtx.machineId,
+            source_modified_at: stat2.mtime.toISOString()
+          };
+          if (gitCtx.isGitRepo) {
+            file.git_branch = gitCtx.branch;
+            file.git_default_branch = gitCtx.defaultBranch;
+            file.is_default_branch = gitCtx.isDefaultBranch;
+            const gitInfo = await getFileGitInfo(rootPath, relPath);
+            if (gitInfo) {
+              file.git_commit_sha = gitInfo.sha;
+              file.git_commit_timestamp = gitInfo.timestamp;
+            }
+          }
+          yield file;
         } catch {
         }
       }
@@ -10053,11 +10809,12 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
   for await (const file of walkDir(rootPath)) {
     if (file.sizeBytes > largeFileThreshold) {
       if (batch.length > 0) {
-        yield batch.map(({ sizeBytes, ...rest }) => rest);
+        yield batch.map(({ sizeBytes: sizeBytes2, ...rest }) => rest);
         batch = [];
         currentBatchBytes = 0;
       }
-      yield [{ path: file.path, content: file.content }];
+      const { sizeBytes, ...fileData } = file;
+      yield [fileData];
       continue;
     }
     const wouldExceedBytes = currentBatchBytes + file.sizeBytes > maxBatchBytes;
@@ -10331,6 +11088,7 @@ var CacheKeys = {
 var globalCache = new MemoryCache();
 
 // src/client.ts
+init_version();
 var uuidSchema = external_exports.string().uuid();
 function unwrapApiResponse(result) {
   if (!result || typeof result !== "object") return result;
@@ -11153,6 +11911,26 @@ var ContextStreamClient = class {
     uuidSchema.parse(projectId);
     return request(this.config, `/projects/${projectId}/index/status`, { method: "GET" });
   }
+  /**
+   * Get index history for audit trail
+   * Shows which files were indexed, when, by which machine, and from which branch
+   */
+  projectIndexHistory(projectId, params) {
+    uuidSchema.parse(projectId);
+    const queryParams = new URLSearchParams();
+    if (params?.machine_id) queryParams.set("machine_id", params.machine_id);
+    if (params?.branch) queryParams.set("branch", params.branch);
+    if (params?.since) queryParams.set("since", params.since);
+    if (params?.until) queryParams.set("until", params.until);
+    if (params?.path_pattern) queryParams.set("path_pattern", params.path_pattern);
+    if (params?.sort_by) queryParams.set("sort_by", params.sort_by);
+    if (params?.sort_order) queryParams.set("sort_order", params.sort_order);
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.limit) queryParams.set("limit", params.limit.toString());
+    const queryString = queryParams.toString();
+    const url = `/projects/${projectId}/index/history${queryString ? `?${queryString}` : ""}`;
+    return request(this.config, url, { method: "GET" });
+  }
   /**
    * Check if project ingestion is recommended and return a recommendation.
    * This is used by session_init to inform the AI about the project's index status.
@@ -11227,10 +12005,11 @@ var ContextStreamClient = class {
    * Ingest files for indexing
    * This uploads files to the API for indexing
    * @param projectId - Project UUID
-   * @param files - Array of files to ingest
+   * @param files - Array of files to ingest (with optional version metadata)
    * @param options - Optional ingest options
    * @param options.write_to_disk - When true, write files to disk under QA_FILE_WRITE_ROOT before indexing
    * @param options.overwrite - Allow overwriting existing files when write_to_disk is enabled
+   * @param options.force - When true, bypass version checking and force re-index all files
    */
   ingestFiles(projectId, files, options) {
     uuidSchema.parse(projectId);
@@ -11238,7 +12017,8 @@ var ContextStreamClient = class {
       body: {
         files,
         ...options?.write_to_disk !== void 0 && { write_to_disk: options.write_to_disk },
-        ...options?.overwrite !== void 0 && { overwrite: options.overwrite }
+        ...options?.overwrite !== void 0 && { overwrite: options.overwrite },
+        ...options?.force !== void 0 && { force: options.force }
       }
     });
   }
@@ -11336,6 +12116,23 @@ var ContextStreamClient = class {
     uuidSchema.parse(workspaceId);
     return request(this.config, `/workspaces/${workspaceId}/content`, { method: "GET" });
   }
+  /**
+   * Get workspace index settings for multi-machine sync configuration
+   */
+  getWorkspaceIndexSettings(workspaceId) {
+    uuidSchema.parse(workspaceId);
+    return request(this.config, `/workspaces/${workspaceId}/index-settings`, { method: "GET" });
+  }
+  /**
+   * Update workspace index settings (admin only)
+   */
+  updateWorkspaceIndexSettings(workspaceId, settings) {
+    uuidSchema.parse(workspaceId);
+    return request(this.config, `/workspaces/${workspaceId}/index-settings`, {
+      method: "PUT",
+      body: settings
+    });
+  }
   // Memory extended operations
   getMemoryEvent(eventId) {
     uuidSchema.parse(eventId);
@@ -12647,7 +13444,8 @@ var ContextStreamClient = class {
           // Transcript save parameters
           ...params.save_exchange !== void 0 && { save_exchange: params.save_exchange },
           ...params.session_id !== void 0 && { session_id: params.session_id },
-          ...params.client_name !== void 0 && { client_name: params.client_name }
+          ...params.client_name !== void 0 && { client_name: params.client_name },
+          ...params.assistant_message !== void 0 && { assistant_message: params.assistant_message }
         }
       });
       const data = unwrapApiResponse(apiResult);
@@ -12664,10 +13462,17 @@ var ContextStreamClient = class {
       if (versionWarning2) {
         warnings2.push(versionWarning2);
       }
+      const CS_HEADER2 = "\u2B21 ContextStream \u2014 Smart Context & Memory";
       let context2 = String(data?.context ?? "");
       const versionInstructions = getVersionInstructions(versionNotice2);
       if (versionInstructions) {
-        context2 = `${versionInstructions}
+        context2 = `${CS_HEADER2}
+
+${versionInstructions}
+
+${context2}`;
+      } else {
+        context2 = `${CS_HEADER2}
 
 ${context2}`;
       }
@@ -12825,11 +13630,13 @@ ${context2}`;
     let charsUsed = 0;
     const maxChars = maxTokens * 4;
     let candidateContext;
+    const CS_HEADER = "\u2B21 ContextStream \u2014 Smart Context & Memory";
+    const CS_HEADER_MINIFIED = "CS:active";
     const CS_FIRST_RULE = "\u26A0\uFE0F STOP: Before Glob/Grep/Read \u2192 search(mode=hybrid) FIRST. Local tools ONLY if 0 results.";
     const CS_FIRST_RULE_MINIFIED = "R:CS-first|Idx:project.index_status->ingest|NoLocalScanUnlessCSempty";
     if (format === "minified") {
-      const parts = [CS_FIRST_RULE_MINIFIED];
-      charsUsed = CS_FIRST_RULE_MINIFIED.length + 1;
+      const parts = [CS_HEADER_MINIFIED, CS_FIRST_RULE_MINIFIED];
+      charsUsed = CS_HEADER_MINIFIED.length + CS_FIRST_RULE_MINIFIED.length + 2;
       for (const item of items) {
         const entry = `${item.type}:${item.value}`;
         if (charsUsed + entry.length + 1 > maxChars) break;
@@ -12837,12 +13644,12 @@ ${context2}`;
         charsUsed += entry.length + 1;
       }
       context = parts.join("|");
-      candidateContext = [CS_FIRST_RULE_MINIFIED, ...items.map((i) => `${i.type}:${i.value}`)].join(
+      candidateContext = [CS_HEADER_MINIFIED, CS_FIRST_RULE_MINIFIED, ...items.map((i) => `${i.type}:${i.value}`)].join(
         "|"
       );
     } else if (format === "structured") {
-      const grouped = { R: [CS_FIRST_RULE] };
-      charsUsed = CS_FIRST_RULE.length + 10;
+      const grouped = { _: [CS_HEADER], R: [CS_FIRST_RULE] };
+      charsUsed = CS_HEADER.length + CS_FIRST_RULE.length + 15;
       for (const item of items) {
         if (charsUsed > maxChars) break;
         if (!grouped[item.type]) grouped[item.type] = [];
@@ -12850,15 +13657,15 @@ ${context2}`;
         charsUsed += item.value.length + 5;
       }
       context = JSON.stringify(grouped);
-      const candidateGrouped = { R: [CS_FIRST_RULE] };
+      const candidateGrouped = { _: [CS_HEADER], R: [CS_FIRST_RULE] };
       for (const item of items) {
         if (!candidateGrouped[item.type]) candidateGrouped[item.type] = [];
         candidateGrouped[item.type].push(item.value);
       }
       candidateContext = JSON.stringify(candidateGrouped);
     } else {
-      const lines = [CS_FIRST_RULE, "", "[CTX]"];
-      charsUsed = CS_FIRST_RULE.length + 10;
+      const lines = [CS_HEADER, "", CS_FIRST_RULE, "", "[CTX]"];
+      charsUsed = CS_HEADER.length + CS_FIRST_RULE.length + 15;
       for (const item of items) {
         const line = `${item.type}:${item.value}`;
         if (charsUsed + line.length + 1 > maxChars) break;
@@ -12867,7 +13674,7 @@ ${context2}`;
       }
       lines.push("[/CTX]");
       context = lines.join("\n");
-      const candidateLines = [CS_FIRST_RULE, "", "[CTX]"];
+      const candidateLines = [CS_HEADER, "", CS_FIRST_RULE, "", "[CTX]"];
       for (const item of items) {
         candidateLines.push(`${item.type}:${item.value}`);
       }
@@ -12876,7 +13683,9 @@ ${context2}`;
     }
     if (context.length === 0 && withDefaults.workspace_id) {
       const wsHint = items.find((i) => i.type === "W")?.value || withDefaults.workspace_id;
-      context = format === "minified" ? `${CS_FIRST_RULE_MINIFIED}|W:${wsHint}|[NO_MATCHES]` : `${CS_FIRST_RULE}
+      context = format === "minified" ? `${CS_HEADER_MINIFIED}|${CS_FIRST_RULE_MINIFIED}|W:${wsHint}|[NO_MATCHES]` : `${CS_HEADER}
+
+${CS_FIRST_RULE}
 
 [CTX]
 W:${wsHint}
@@ -14306,6 +15115,7 @@ import * as path6 from "node:path";
 import { homedir as homedir3 } from "node:os";
 
 // src/rules-templates.ts
+init_version();
 var DEFAULT_CLAUDE_MCP_SERVER_NAME = "contextstream";
 var RULES_VERSION = VERSION === "unknown" ? "0.0.0" : VERSION;
 var CONTEXTSTREAM_TOOL_NAMES = [
@@ -14354,7 +15164,7 @@ var CONTEXTSTREAM_RULES_BOOTSTRAP = `
 
 **Hooks:** \`<system-reminder>\` tags contain injected instructions \u2014 follow them exactly.
 
-**Notices:** [LESSONS_WARNING] \u2192 tell user first | [RULES_NOTICE] \u2192 run \`generate_rules()\` | [VERSION_NOTICE] \u2192 tell user to update
+**Notices:** [LESSONS_WARNING] \u2192 apply lessons | [PREFERENCE] \u2192 follow user preferences | [RULES_NOTICE] \u2192 run \`generate_rules()\` | [VERSION_NOTICE/CRITICAL] \u2192 tell user about update
 
 v${RULES_VERSION}
 `.trim();
@@ -14395,6 +15205,7 @@ var CONTEXTSTREAM_RULES_FULL = `
 ## Handle Notices from context()
 
 - **[LESSONS_WARNING]** \u2192 Tell user about past mistakes BEFORE proceeding
+- **[PREFERENCE]** \u2192 Follow user preferences (high-priority user memories)
 - **[RULES_NOTICE]** \u2192 Run \`generate_rules()\` to update
 - **[VERSION_NOTICE]** \u2192 Tell user to update MCP
 
@@ -14621,11 +15432,14 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 **[RULES_NOTICE]** - Update rules via \`generate_rules()\` (or rerun setup).
 
-**[VERSION_NOTICE]** - You **MUST IMMEDIATELY** tell the user:
-  1. A new MCP server version is available
-  2. The exact update command to run
-  3. That they need to restart their AI tool after updating
-  **Do not skip this** - users often miss stderr warnings.
+**[VERSION_NOTICE]** or **[VERSION_CRITICAL]** - You **MUST** tell the user (be helpful, not annoying):
+  1. A new MCP server version is available with improvements
+  2. Provide update commands (user chooses preferred method):
+     - macOS/Linux: \`curl -fsSL https://contextstream.io/scripts/setup.sh | bash\`
+     - Windows: \`irm https://contextstream.io/scripts/setup.ps1 | iex\`
+     - npm: \`npm install -g @contextstream/mcp-server@latest\`
+  3. Restart AI tool after updating
+  **Mention once** - don't nag. Users often miss stderr warnings so this helps.
 
 **[LESSONS_WARNING]** - You **MUST** before proceeding:
   1. Read all lessons listed
@@ -14637,9 +15451,17 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 ### Preferences & Lessons (Use Early)
 
-- If preferences/style matter: \`session(action="user_context")\`
+**Preferences ([PREFERENCE] in context response):**
+- High-priority user memories that should guide your behavior
+- Surfaced automatically via \`context()\` warnings field
+- To save: \`session(action="remember", content="...")\`
+- To retrieve explicitly: \`session(action="user_context")\`
+
+**Lessons ([LESSONS_WARNING] in context response):**
+- Past mistakes to avoid - apply prevention steps
+- Surfaced automatically via \`context()\` warnings field
 - Before risky changes: \`session(action="get_lessons", query="<topic>")\`
-- On frustration/corrections: \`session(action="capture_lesson", title="...", trigger="...", impact="...", prevention="...")\`
+- On mistakes: \`session(action="capture_lesson", title="...", trigger="...", impact="...", prevention="...")\`
 
 ---
 
@@ -14933,6 +15755,7 @@ Rules Version: ${RULES_VERSION}
 ## Handle Notices from context()
 
 - **[LESSONS_WARNING]** \u2192 Tell user about past mistakes BEFORE proceeding
+- **[PREFERENCE]** \u2192 Follow user preferences (high-priority user memories)
 - **[RULES_NOTICE]** \u2192 Run \`generate_rules()\`
 - **[VERSION_NOTICE]** \u2192 Tell user to update MCP
 
@@ -14974,9 +15797,13 @@ To disable automatic restoration:
 
 ### Notices - MUST HANDLE IMMEDIATELY
 
-- **[VERSION_NOTICE]**: Tell the user about the update and command to run
+- **[VERSION_NOTICE]** or **[VERSION_CRITICAL]**: Tell user about the update in a helpful, non-annoying way. Provide update commands:
+  - macOS/Linux: \`curl -fsSL https://contextstream.io/scripts/setup.sh | bash\`
+  - Windows: \`irm https://contextstream.io/scripts/setup.ps1 | iex\`
+  - npm: \`npm install -g @contextstream/mcp-server@latest\`
 - **[RULES_NOTICE]**: Run \`generate_rules(overwrite_existing=true)\` to update
 - **[LESSONS_WARNING]**: Read lessons, tell user about them, explain how you'll avoid past mistakes
+- **[PREFERENCE]**: Follow user preferences - these are high-priority user memories that should guide your behavior
 
 ### Plans & Tasks
 
@@ -15015,12 +15842,42 @@ You MUST follow these rules manually - there is no automatic enforcement.
    - Check response for \`indexing_status\`
    - If \`"started"\` or \`"refreshing"\`: wait before searching
 
-2. **Call \`context(user_message="<first_message>")\`** SECOND
-   - Gets task-specific rules and lessons
+2. **Generate a unique session_id** (e.g., \`"session-" + timestamp\` or a UUID)
+   - Use this SAME session_id for ALL context() calls in this conversation
+   - This groups all turns together in the transcript
+
+3. **Call \`context(user_message="<first_message>", save_exchange=true, session_id="<your-session-id>")\`**
+   - Gets task-specific rules, lessons, and preferences
    - Check for [LESSONS_WARNING] - past mistakes to avoid
+   - Check for [PREFERENCE] - user preferences to follow
    - Check for [RULES_NOTICE] - update rules if needed
+   - **save_exchange=true** saves each conversation turn for later retrieval
+
+4. **NEVER skip init/context** - you will miss critical context
+
+---
+
+## \u{1F4BE} AUTOMATIC TRANSCRIPT SAVING (CRITICAL)
+
+**This editor does NOT have hooks to auto-save transcripts.**
+You MUST save each conversation turn manually:
+
+### On EVERY message (including the first):
+\`\`\`
+context(user_message="<user's message>", save_exchange=true, session_id="<session-id>")
+\`\`\`
 
-3. **NEVER skip init/context** - you will miss critical context
+### Why save_exchange matters:
+- Transcripts enable searching past conversations
+- Allows context restoration after compaction
+- Provides conversation history for debugging
+- Required for the Transcripts page in the dashboard
+
+### Session ID Guidelines:
+- Generate ONCE at the start of the conversation
+- Use a unique identifier: \`"session-" + Date.now()\` or a UUID
+- Keep the SAME session_id for ALL context() calls in this session
+- Different sessions = different transcripts
 
 ---
 
@@ -15130,6 +15987,39 @@ memory(action="create_task", title="...", plan_id="...")
 
 \u274C DO NOT use built-in plan mode or write plans to markdown files.
 
+---
+
+## \u{1F504} VERSION UPDATES (Check Periodically)
+
+**This editor does NOT have hooks to check for updates automatically.**
+You should check for updates using \`help(action="version")\` periodically (e.g., at session start).
+
+### If the response includes [VERSION_NOTICE] or [VERSION_CRITICAL]:
+
+**Tell the user** about the available update in a helpful, non-annoying way:
+- Frame it as "new features and improvements available"
+- Provide the update commands (user can choose their preferred method)
+- Don't nag repeatedly - mention once, then only if user asks
+
+### Update Commands (provide all options):
+
+**macOS/Linux:**
+\`\`\`bash
+curl -fsSL https://contextstream.io/scripts/setup.sh | bash
+\`\`\`
+
+**Windows (PowerShell):**
+\`\`\`powershell
+irm https://contextstream.io/scripts/setup.ps1 | iex
+\`\`\`
+
+**npm (requires Node.js 18+):**
+\`\`\`bash
+npm install -g @contextstream/mcp-server@latest
+\`\`\`
+
+After updating, user should restart their AI tool.
+
 ---
 `;
 var NO_HOOKS_EDITORS = ["codex", "aider", "antigravity"];
@@ -15238,6 +16128,9 @@ function generateAllRuleFiles(options) {
   }).filter((r) => r !== null);
 }
 
+// src/tools.ts
+init_version();
+
 // src/tool-catalog.ts
 var TOOL_CATALOG = [
   {
@@ -17241,12 +18134,6 @@ function registerTools(server, client, sessionManager) {
   function getToolAccessTier(toolName) {
     return proTools.has(toolName) ? "pro" : "free";
   }
-  function getToolAccessLabel(toolName) {
-    const graphTier = graphToolTiers.get(toolName);
-    if (graphTier === "lite") return "Pro (Graph-Lite)";
-    if (graphTier === "full") return "Elite/Team (Full Graph)";
-    return getToolAccessTier(toolName) === "pro" ? "PRO" : "Free";
-  }
   async function gateIfProTool(toolName) {
     if (getToolAccessTier(toolName) !== "pro") return null;
     const planName = await client.getPlanName();
@@ -17542,22 +18429,18 @@ function registerTools(server, client, sessionManager) {
     };
   }
   function actuallyRegisterTool(name, config, handler) {
-    const accessLabel = getToolAccessLabel(name);
-    const showUpgrade = accessLabel !== "Free";
     let finalDescription;
     let finalSchema;
     if (COMPACT_SCHEMA_ENABLED) {
       finalDescription = compactifyDescription(config.description);
       finalSchema = config.inputSchema ? applyCompactParamDescriptions(config.inputSchema) : void 0;
     } else {
-      finalDescription = `${config.description}
-
-Access: ${accessLabel}${showUpgrade ? ` (upgrade: ${upgradeUrl2})` : ""}`;
+      finalDescription = config.description;
       finalSchema = config.inputSchema ? applyParamDescriptions(config.inputSchema) : void 0;
     }
     const labeledConfig = {
       ...config,
-      title: COMPACT_SCHEMA_ENABLED ? config.title : `${config.title} (${accessLabel})`,
+      title: config.title,
       description: finalDescription
     };
     const annotatedConfig = {
@@ -20935,7 +21818,8 @@ This saves ~80% tokens compared to including full chat history.`,
         context_threshold: external_exports.number().optional().describe("Custom context window threshold (defaults to 70k)"),
         save_exchange: external_exports.boolean().optional().describe("Save this exchange to the transcript for later search (background task)"),
         session_id: external_exports.string().optional().describe("Session ID for transcript association (required if save_exchange is true)"),
-        client_name: external_exports.string().optional().describe("Client name for transcript metadata (e.g., 'claude', 'cursor')")
+        client_name: external_exports.string().optional().describe("Client name for transcript metadata (e.g., 'claude', 'cursor')"),
+        assistant_message: external_exports.string().optional().describe("Previous assistant response to save along with user message (for complete exchange capture)")
       })
     },
     async (input) => {
@@ -21031,7 +21915,8 @@ This saves ~80% tokens compared to including full chat history.`,
         context_threshold: contextThreshold,
         save_exchange: input.save_exchange,
         session_id: sessionId,
-        client_name: clientName
+        client_name: clientName,
+        assistant_message: input.assistant_message
       });
       if (sessionManager && result.token_estimate) {
         sessionManager.addTokens(result.token_estimate);
@@ -24293,7 +25178,7 @@ ${formatContent(result)}`
       "project",
       {
         title: "Project",
-        description: `Project management. Actions: list, get, create, update, index (trigger indexing), overview, statistics, files, index_status, ingest_local (index local folder), team_projects (list all team projects - team plans only).`,
+        description: `Project management. Actions: list, get, create, update, index (trigger indexing), overview, statistics, files, index_status, index_history (audit trail of indexed files), ingest_local (index local folder), team_projects (list all team projects - team plans only).`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "list",
@@ -24305,6 +25190,7 @@ ${formatContent(result)}`
             "statistics",
             "files",
             "index_status",
+            "index_history",
             "ingest_local",
             "team_projects"
           ]).describe("Action to perform"),
@@ -24319,6 +25205,15 @@ ${formatContent(result)}`
           path: external_exports.string().optional().describe("Local path to ingest"),
           overwrite: external_exports.boolean().optional(),
           write_to_disk: external_exports.boolean().optional(),
+          force: external_exports.boolean().optional().describe("Force re-index all files, bypassing version check logic"),
+          // Index history filters
+          machine_id: external_exports.string().optional().describe("Filter by machine ID that indexed the files"),
+          branch: external_exports.string().optional().describe("Filter by git branch"),
+          since: external_exports.string().optional().describe("Filter files indexed after this timestamp (ISO 8601)"),
+          until: external_exports.string().optional().describe("Filter files indexed before this timestamp (ISO 8601)"),
+          path_pattern: external_exports.string().optional().describe("Filter by file path pattern (partial match)"),
+          sort_by: external_exports.enum(["path", "indexed", "size"]).optional().describe("Sort field (default: indexed)"),
+          sort_order: external_exports.enum(["asc", "desc"]).optional().describe("Sort order (default: desc)"),
           // Pagination
           page: external_exports.number().optional(),
           page_size: external_exports.number().optional()
@@ -24417,6 +25312,25 @@ ${formatContent(result)}`
               content: [{ type: "text", text: formatContent(result) }]
             };
           }
+          case "index_history": {
+            if (!projectId) {
+              return errorResult("index_history requires: project_id");
+            }
+            const result = await client.projectIndexHistory(projectId, {
+              machine_id: input.machine_id,
+              branch: input.branch,
+              since: input.since,
+              until: input.until,
+              path_pattern: input.path_pattern,
+              sort_by: input.sort_by,
+              sort_order: input.sort_order,
+              page: input.page,
+              limit: input.page_size
+            });
+            return {
+              content: [{ type: "text", text: formatContent(result) }]
+            };
+          }
           case "ingest_local": {
             if (!input.path) {
               return errorResult("ingest_local requires: path");
@@ -24430,23 +25344,26 @@ ${formatContent(result)}`
             }
             const ingestOptions = {
               ...input.write_to_disk !== void 0 && { write_to_disk: input.write_to_disk },
-              ...input.overwrite !== void 0 && { overwrite: input.overwrite }
+              ...input.overwrite !== void 0 && { overwrite: input.overwrite },
+              ...input.force !== void 0 && { force: input.force }
             };
             startBackgroundIngest(projectId, validPath.resolvedPath, ingestOptions);
+            const forceNote = input.force ? " (force mode - version checks bypassed)" : "";
             const result = {
               status: "started",
-              message: "Ingestion running in background",
+              message: `Ingestion running in background${forceNote}`,
               project_id: projectId,
               path: validPath.resolvedPath,
               ...input.write_to_disk !== void 0 && { write_to_disk: input.write_to_disk },
               ...input.overwrite !== void 0 && { overwrite: input.overwrite },
+              ...input.force !== void 0 && { force: input.force },
               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.`
+                  text: `Ingestion started in background${forceNote} for directory: ${validPath.resolvedPath}. Use 'project' with action 'index_status' to monitor progress.`
                 }
               ]
             };
@@ -24480,9 +25397,9 @@ ${formatContent(result)}`
       "workspace",
       {
         title: "Workspace",
-        description: `Workspace management. Actions: list, get, associate (link folder to workspace), bootstrap (create workspace and initialize), team_members (list members with access - team plans only).`,
+        description: `Workspace management. Actions: list, get, associate (link folder to workspace), bootstrap (create workspace and initialize), team_members (list members with access - team plans only), index_settings (get/update multi-machine sync settings - admin only).`,
         inputSchema: external_exports.object({
-          action: external_exports.enum(["list", "get", "associate", "bootstrap", "team_members"]).describe("Action to perform"),
+          action: external_exports.enum(["list", "get", "associate", "bootstrap", "team_members", "index_settings"]).describe("Action to perform"),
           workspace_id: external_exports.string().uuid().optional(),
           // Associate/bootstrap params
           folder_path: external_exports.string().optional(),
@@ -24494,6 +25411,12 @@ ${formatContent(result)}`
           visibility: external_exports.enum(["private", "public"]).optional(),
           auto_index: external_exports.boolean().optional(),
           context_hint: external_exports.string().optional(),
+          // Index settings params (for update)
+          branch_policy: external_exports.enum(["default_branch_wins", "newest_wins", "feature_branch_wins"]).optional().describe("Which branch takes priority: default_branch_wins (default), newest_wins, feature_branch_wins"),
+          conflict_resolution: external_exports.enum(["newest_timestamp", "default_branch", "manual"]).optional().describe("How to resolve conflicts: newest_timestamp (default), default_branch, manual"),
+          allowed_machines: external_exports.array(external_exports.string()).optional().describe("List of allowed machine IDs (empty = all allowed)"),
+          auto_sync_enabled: external_exports.boolean().optional().describe("Whether to auto-sync from all machines (default: true)"),
+          max_machines: external_exports.number().optional().describe("Maximum machines allowed to index (0 = unlimited)"),
           // Pagination
           page: external_exports.number().optional(),
           page_size: external_exports.number().optional()
@@ -24597,6 +25520,29 @@ ${formatContent(result)}`
               content: [{ type: "text", text: formatContent(teamMembers) }]
             };
           }
+          case "index_settings": {
+            if (!input.workspace_id) {
+              return errorResult("index_settings requires: workspace_id");
+            }
+            const hasUpdateParams = input.branch_policy !== void 0 || input.conflict_resolution !== void 0 || input.allowed_machines !== void 0 || input.auto_sync_enabled !== void 0 || input.max_machines !== void 0;
+            if (hasUpdateParams) {
+              const result = await client.updateWorkspaceIndexSettings(input.workspace_id, {
+                branch_policy: input.branch_policy,
+                conflict_resolution: input.conflict_resolution,
+                allowed_machines: input.allowed_machines,
+                auto_sync_enabled: input.auto_sync_enabled,
+                max_machines: input.max_machines
+              });
+              return {
+                content: [{ type: "text", text: formatContent(result) }]
+              };
+            } else {
+              const result = await client.getWorkspaceIndexSettings(input.workspace_id);
+              return {
+                content: [{ type: "text", text: formatContent(result) }]
+              };
+            }
+          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }
@@ -27117,7 +28063,7 @@ var SessionManager = class _SessionManager {
   buildContextSummary(context) {
     const parts = [];
     parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
-    parts.push("\u2B21 SMART CONTEXT (ContextStream)");
+    parts.push("\u2B21 ContextStream \u2014 Smart Context & Memory");
     parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
     if (context.status === "requires_workspace_name") {
       parts.push("");
@@ -27345,6 +28291,7 @@ import { createServer } from "node:http";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+init_version();
 var HOST = process.env.MCP_HTTP_HOST || "0.0.0.0";
 var PORT = Number.parseInt(process.env.MCP_HTTP_PORT || "8787", 10);
 var MCP_PATH = process.env.MCP_HTTP_PATH || "/mcp";
@@ -27623,6 +28570,7 @@ async function runHttpGateway() {
 }
 
 // src/index.ts
+init_version();
 import { existsSync as existsSync17, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir19 } from "os";
 import { join as join23 } from "path";
@@ -27633,6 +28581,7 @@ import * as path8 from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
+init_version();
 
 // src/credentials.ts
 import * as fs6 from "node:fs/promises";
@@ -27783,7 +28732,8 @@ var CONTEXTSTREAM_PREAMBLE_PATTERNS2 = [
   /^#\s+cline rules$/i,
   /^#\s+kilo code rules$/i,
   /^#\s+roo code rules$/i,
-  /^#\s+aider configuration$/i
+  /^#\s+aider configuration$/i,
+  /^#\s+antigravity agent rules$/i
 ];
 function wrapWithMarkers2(content) {
   return `${CONTEXTSTREAM_START_MARKER2}
@@ -28191,6 +29141,9 @@ function claudeDesktopConfigPath() {
     const appData = process.env.APPDATA || path8.join(home, "AppData", "Roaming");
     return path8.join(appData, "Claude", "claude_desktop_config.json");
   }
+  if (process.platform === "linux") {
+    return path8.join(home, ".config", "Claude", "claude_desktop_config.json");
+  }
   return null;
 }
 async function upsertCodexTomlConfig(filePath, params) {
@@ -28576,6 +29529,20 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     const contextPackEnabled = isPro;
     const showTiming = false;
     const restoreContextEnabled = true;
+    console.log("\nAuto-Update:");
+    console.log("  When enabled, ContextStream will automatically update to the latest version");
+    console.log("  on new sessions (checks daily). You can disable this if you prefer manual updates.");
+    const currentAutoUpdate = isAutoUpdateEnabled();
+    const autoUpdateChoice = normalizeInput(
+      await rl.question(`Enable auto-update? [${currentAutoUpdate ? "Y/n" : "y/N"}]: `)
+    ).toLowerCase();
+    const autoUpdateEnabled = autoUpdateChoice === "" ? currentAutoUpdate : autoUpdateChoice === "y" || autoUpdateChoice === "yes";
+    setAutoUpdatePreference(autoUpdateEnabled);
+    if (autoUpdateEnabled) {
+      console.log("  \u2713 Auto-update enabled (disable anytime with CONTEXTSTREAM_AUTO_UPDATE=false)");
+    } else {
+      console.log("  \u2717 Auto-update disabled");
+    }
     const editors = [
       "codex",
       "claude",