@contextstream/mcp-server 0.4.55 → 0.4.56

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 os = platform();
+  if (os === "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;
       }
@@ -4756,10 +5480,61 @@ function parseTranscriptStats(transcriptPath) {
   }
   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) };
+  }
+}
 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}`
       };
     }
@@ -9300,179 +10080,8 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// src/version.ts
-import { createRequire } from "module";
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var UPGRADE_COMMAND = "npm 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 });
-    }
-    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;
-}
-
 // src/config.ts
+init_version();
 var DEFAULT_API_URL = "https://api.contextstream.io";
 function parseBooleanEnv(value) {
   if (value === void 0) return void 0;
@@ -10331,6 +10940,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;
@@ -12647,7 +13257,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 +13275,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 +13443,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 +13457,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 +13470,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 +13487,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 +13496,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 +14928,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 +14977,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 +15018,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 +15245,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 +15264,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 +15568,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 +15610,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 +15655,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 +15800,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 +15941,9 @@ function generateAllRuleFiles(options) {
   }).filter((r) => r !== null);
 }
 
+// src/tools.ts
+init_version();
+
 // src/tool-catalog.ts
 var TOOL_CATALOG = [
   {
@@ -17241,12 +17947,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 +18242,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 +21631,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 +21728,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);
@@ -27117,7 +27815,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 +28043,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 +28322,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 +28333,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 +28484,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 +28893,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 +29281,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",