@contextstream/mcp-server 0.4.49 → 0.4.51

package/dist/index.js

@@ -335,7 +335,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path13, checkUnignored, mode) {
+      test(path21, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -344,7 +344,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path13);
+          const matched = rule[mode].test(path21);
           if (!matched) {
             return;
           }
@@ -365,17 +365,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path13, originalPath, doThrow) => {
-      if (!isString(path13)) {
+    var checkPath = (path21, originalPath, doThrow) => {
+      if (!isString(path21)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path13) {
+      if (!path21) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path13)) {
+      if (checkPath.isNotRelative(path21)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -384,7 +384,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path13) => REGEX_TEST_INVALID_PATH.test(path13);
+    var isNotRelative = (path21) => REGEX_TEST_INVALID_PATH.test(path21);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -414,19 +414,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path13 = originalPath && checkPath.convert(originalPath);
+        const path21 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path13,
+          path21,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path13, cache, checkUnignored, slices);
+        return this._t(path21, cache, checkUnignored, slices);
       }
-      checkIgnore(path13) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path13)) {
-          return this.test(path13);
+      checkIgnore(path21) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path21)) {
+          return this.test(path21);
         }
-        const slices = path13.split(SLASH).filter(Boolean);
+        const slices = path21.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -439,18 +439,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path13, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path21, false, MODE_CHECK_IGNORE);
       }
-      _t(path13, cache, checkUnignored, slices) {
-        if (path13 in cache) {
-          return cache[path13];
+      _t(path21, cache, checkUnignored, slices) {
+        if (path21 in cache) {
+          return cache[path21];
         }
         if (!slices) {
-          slices = path13.split(SLASH).filter(Boolean);
+          slices = path21.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path13] = this._rules.test(path13, checkUnignored, MODE_IGNORE);
+          return cache[path21] = this._rules.test(path21, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -458,29 +458,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path13] = parent.ignored ? parent : this._rules.test(path13, checkUnignored, MODE_IGNORE);
+        return cache[path21] = parent.ignored ? parent : this._rules.test(path21, checkUnignored, MODE_IGNORE);
       }
-      ignores(path13) {
-        return this._test(path13, this._ignoreCache, false).ignored;
+      ignores(path21) {
+        return this._test(path21, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path13) => !this.ignores(path13);
+        return (path21) => !this.ignores(path21);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path13) {
-        return this._test(path13, this._testCache, true);
+      test(path21) {
+        return this._test(path21, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path13) => checkPath(path13 && checkPath.convert(path13), path13, RETURN_FALSE);
+    var isPathValid = (path21) => checkPath(path21 && checkPath.convert(path21), path21, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path13) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path13) || isNotRelative(path13);
+      checkPath.isNotRelative = (path21) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path21) || isNotRelative(path21);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -514,6 +514,7 @@ __export(hooks_config_exports, {
   getClineHooksDir: () => getClineHooksDir,
   getCursorHooksConfigPath: () => getCursorHooksConfigPath,
   getCursorHooksDir: () => getCursorHooksDir,
+  getHookCommand: () => getHookCommand,
   getHooksDir: () => getHooksDir,
   getIndexStatusPath: () => getIndexStatusPath,
   getKiloCodeHooksDir: () => getKiloCodeHooksDir,
@@ -539,6 +540,19 @@ __export(hooks_config_exports, {
 import * as fs4 from "node:fs/promises";
 import * as path5 from "node:path";
 import { homedir as homedir2 } from "node:os";
+import { fileURLToPath } from "node:url";
+function getHookCommand(hookName) {
+  try {
+    const __dirname = path5.dirname(fileURLToPath(import.meta.url));
+    const indexPath = path5.join(__dirname, "index.js");
+    const fs20 = __require("node:fs");
+    if (fs20.existsSync(indexPath)) {
+      return `node ${indexPath} hook ${hookName}`;
+    }
+  } catch {
+  }
+  return `npx @contextstream/mcp-server hook ${hookName}`;
+}
 function getClaudeSettingsPath(scope, projectPath) {
   if (scope === "user") {
     return path5.join(homedir2(), ".claude", "settings.json");
@@ -558,19 +572,31 @@ function buildHooksConfig(options) {
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook user-prompt-submit",
+          command: getHookCommand("user-prompt-submit"),
           timeout: 5
         }
       ]
     }
   ];
+  if (options?.includeOnSaveIntent !== false) {
+    userPromptHooks.push({
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-save-intent"),
+          timeout: 5
+        }
+      ]
+    });
+  }
   if (options?.includeMediaAware !== false) {
     userPromptHooks.push({
       matcher: "*",
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook media-aware",
+          command: getHookCommand("media-aware"),
           timeout: 5
         }
       ]
@@ -583,7 +609,7 @@ function buildHooksConfig(options) {
         hooks: [
           {
             type: "command",
-            command: "npx @contextstream/mcp-server hook pre-tool-use",
+            command: getHookCommand("pre-tool-use"),
             timeout: 5
           }
         ]
@@ -594,12 +620,39 @@ function buildHooksConfig(options) {
   if (options?.includePreCompact !== false) {
     config.PreCompact = [
       {
-        // Match both manual (/compact) and automatic compaction
         matcher: "*",
         hooks: [
           {
             type: "command",
-            command: "npx @contextstream/mcp-server hook pre-compact",
+            command: getHookCommand("pre-compact"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  if (options?.includeSessionInit !== false) {
+    config.SessionStart = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("session-init"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  if (options?.includeSessionEnd !== false) {
+    config.Stop = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("session-end"),
             timeout: 10
           }
         ]
@@ -613,7 +666,7 @@ function buildHooksConfig(options) {
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook post-write",
+          command: getHookCommand("post-write"),
           timeout: 10
         }
       ]
@@ -625,12 +678,60 @@ function buildHooksConfig(options) {
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook auto-rules",
+          command: getHookCommand("auto-rules"),
           timeout: 15
         }
       ]
     });
   }
+  if (options?.includeOnBash !== false) {
+    postToolUseHooks.push({
+      matcher: "Bash",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-bash"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnTask !== false) {
+    postToolUseHooks.push({
+      matcher: "Task",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-task"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnRead !== false) {
+    postToolUseHooks.push({
+      matcher: "Read|Glob|Grep",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-read"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnWeb !== false) {
+    postToolUseHooks.push({
+      matcher: "WebFetch|WebSearch",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-web"),
+          timeout: 5
+        }
+      ]
+    });
+  }
   if (postToolUseHooks.length > 0) {
     config.PostToolUse = postToolUseHooks;
   }
@@ -640,17 +741,17 @@ async function installHookScripts(options) {
   const hooksDir = getHooksDir();
   await fs4.mkdir(hooksDir, { recursive: true });
   const result = {
-    preToolUse: "npx @contextstream/mcp-server hook pre-tool-use",
-    userPrompt: "npx @contextstream/mcp-server hook user-prompt-submit"
+    preToolUse: getHookCommand("pre-tool-use"),
+    userPrompt: getHookCommand("user-prompt-submit")
   };
   if (options?.includePreCompact !== false) {
-    result.preCompact = "npx @contextstream/mcp-server hook pre-compact";
+    result.preCompact = getHookCommand("pre-compact");
   }
   if (options?.includeMediaAware !== false) {
-    result.mediaAware = "npx @contextstream/mcp-server hook media-aware";
+    result.mediaAware = getHookCommand("media-aware");
   }
   if (options?.includeAutoRules !== false) {
-    result.autoRules = "npx @contextstream/mcp-server hook auto-rules";
+    result.autoRules = getHookCommand("auto-rules");
   }
   return result;
 }
@@ -686,20 +787,20 @@ function mergeHooksIntoSettings(existingSettings, newHooks) {
 async function installClaudeCodeHooks(options) {
   const result = { scripts: [], settings: [] };
   result.scripts.push(
-    "npx @contextstream/mcp-server hook pre-tool-use",
-    "npx @contextstream/mcp-server hook user-prompt-submit"
+    getHookCommand("pre-tool-use"),
+    getHookCommand("user-prompt-submit")
   );
   if (options.includePreCompact !== false) {
-    result.scripts.push("npx @contextstream/mcp-server hook pre-compact");
+    result.scripts.push(getHookCommand("pre-compact"));
   }
   if (options.includeMediaAware !== false) {
-    result.scripts.push("npx @contextstream/mcp-server hook media-aware");
+    result.scripts.push(getHookCommand("media-aware"));
   }
   if (options.includePostWrite !== false) {
-    result.scripts.push("npx @contextstream/mcp-server hook post-write");
+    result.scripts.push(getHookCommand("post-write"));
   }
   if (options.includeAutoRules !== false) {
-    result.scripts.push("npx @contextstream/mcp-server hook auto-rules");
+    result.scripts.push(getHookCommand("auto-rules"));
   }
   const hooksConfig = buildHooksConfig({
     includePreCompact: options.includePreCompact,
@@ -977,6 +1078,8 @@ async function installCursorHookScripts(options) {
   };
   const filteredPreToolUse = filterContextStreamHooks(existingConfig.hooks.preToolUse);
   const filteredBeforeSubmit = filterContextStreamHooks(existingConfig.hooks.beforeSubmitPrompt);
+  const preToolUseCommand = getHookCommand("pre-tool-use");
+  const userPromptCommand = getHookCommand("user-prompt-submit");
   const config = {
     version: 1,
     hooks: {
@@ -984,7 +1087,7 @@ async function installCursorHookScripts(options) {
       preToolUse: [
         ...filteredPreToolUse,
         {
-          command: "npx @contextstream/mcp-server hook pre-tool-use",
+          command: preToolUseCommand,
           type: "command",
           timeout: 5,
           matcher: { tool_name: "Glob|Grep|search_files|list_files|ripgrep" }
@@ -993,7 +1096,7 @@ async function installCursorHookScripts(options) {
       beforeSubmitPrompt: [
         ...filteredBeforeSubmit,
         {
-          command: "npx @contextstream/mcp-server hook user-prompt-submit",
+          command: userPromptCommand,
           type: "command",
           timeout: 5
         }
@@ -1003,8 +1106,8 @@ async function installCursorHookScripts(options) {
   await writeCursorHooksConfig(config, options.scope, options.projectPath);
   const configPath = getCursorHooksConfigPath(options.scope, options.projectPath);
   return {
-    preToolUse: "npx @contextstream/mcp-server hook pre-tool-use",
-    beforeSubmitPrompt: "npx @contextstream/mcp-server hook user-prompt-submit",
+    preToolUse: preToolUseCommand,
+    beforeSubmitPrompt: userPromptCommand,
     config: configPath
   };
 }
@@ -1813,11 +1916,13 @@ esac
 
 exit 0
 `;
-    CLINE_HOOK_WRAPPER = (hookName) => `#!/bin/bash
+    CLINE_HOOK_WRAPPER = (hookName) => {
+      const command = getHookCommand(hookName);
+      return `#!/bin/bash
 # ContextStream ${hookName} Hook Wrapper for Cline/Roo/Kilo Code
-# Calls the Node.js hook via npx
-exec npx @contextstream/mcp-server hook ${hookName}
+exec ${command}
 `;
+    };
     CURSOR_PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
 """
 ContextStream PreToolUse Hook for Cursor
@@ -2825,6 +2930,9 @@ function parseTranscript(transcriptPath) {
   const activeFiles = /* @__PURE__ */ new Set();
   const recentMessages = [];
   const toolCalls = [];
+  const messages = [];
+  let startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let firstTimestamp = true;
   try {
     const content = fs10.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
@@ -2833,6 +2941,11 @@ function parseTranscript(transcriptPath) {
       try {
         const entry = JSON.parse(line);
         const msgType = entry.type || "";
+        const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+        if (firstTimestamp && entry.timestamp) {
+          startedAt = entry.timestamp;
+          firstTimestamp = false;
+        }
         if (msgType === "tool_use") {
           const toolName = entry.name || "";
           const toolInput = entry.input || {};
@@ -2848,11 +2961,40 @@ function parseTranscript(transcriptPath) {
               activeFiles.add(`[glob:${pattern}]`);
             }
           }
-        }
-        if (msgType === "assistant" && entry.content) {
-          const content2 = entry.content;
-          if (typeof content2 === "string" && content2.length > 50) {
-            recentMessages.push(content2.slice(0, 500));
+          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);
+          messages.push({
+            role: "tool",
+            content: resultContent,
+            timestamp,
+            tool_results: { name: entry.name }
+          });
+        } else if (msgType === "user" || entry.role === "user") {
+          const userContent = typeof entry.content === "string" ? entry.content : "";
+          if (userContent) {
+            messages.push({
+              role: "user",
+              content: userContent,
+              timestamp
+            });
+          }
+        } else if (msgType === "assistant" || entry.role === "assistant") {
+          const assistantContent = typeof entry.content === "string" ? entry.content : "";
+          if (assistantContent) {
+            messages.push({
+              role: "assistant",
+              content: assistantContent,
+              timestamp
+            });
+            if (assistantContent.length > 50) {
+              recentMessages.push(assistantContent.slice(0, 500));
+            }
           }
         }
       } catch {
@@ -2865,10 +3007,56 @@ function parseTranscript(transcriptPath) {
     activeFiles: Array.from(activeFiles).slice(-20),
     // Last 20 files
     toolCallCount: toolCalls.length,
-    messageCount: recentMessages.length,
-    lastTools: toolCalls.slice(-10).map((t) => t.name)
+    messageCount: messages.length,
+    lastTools: toolCalls.slice(-10).map((t) => t.name),
     // Last 10 tool names
+    messages,
+    startedAt
+  };
+}
+async function saveFullTranscript(sessionId, transcriptData, trigger) {
+  if (!API_KEY2) {
+    return { success: false, message: "No API key configured" };
+  }
+  if (transcriptData.messages.length === 0) {
+    return { success: false, message: "No messages to save" };
+  }
+  const payload = {
+    session_id: sessionId,
+    messages: transcriptData.messages,
+    started_at: transcriptData.startedAt,
+    source_type: "pre_compact",
+    title: `Pre-compaction save (${trigger})`,
+    metadata: {
+      trigger,
+      active_files: transcriptData.activeFiles,
+      tool_call_count: transcriptData.toolCallCount
+    },
+    tags: ["pre_compaction", trigger]
   };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    const response = await fetch(`${API_URL2}/api/v1/transcripts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY2
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return { success: true, message: `Transcript saved (${transcriptData.messages.length} messages)` };
+    }
+    return { success: false, message: `API error: ${response.status}` };
+  } catch (error) {
+    return { success: false, message: String(error) };
+  }
 }
 async function saveSnapshot(sessionId, transcriptData, trigger) {
   if (!API_KEY2) {
@@ -2950,13 +3138,19 @@ async function runPreCompactHook() {
   }
   let autoSaveStatus = "";
   if (AUTO_SAVE && API_KEY2) {
-    const { success, message } = await saveSnapshot(sessionId, transcriptData, trigger);
-    if (success) {
+    const transcriptResult = await saveFullTranscript(sessionId, transcriptData, trigger);
+    if (transcriptResult.success) {
       autoSaveStatus = `
-[ContextStream: Auto-saved snapshot with ${transcriptData.activeFiles.length} active files]`;
+[ContextStream: ${transcriptResult.message}]`;
     } else {
-      autoSaveStatus = `
+      const { success, message } = await saveSnapshot(sessionId, transcriptData, trigger);
+      if (success) {
+        autoSaveStatus = `
+[ContextStream: Auto-saved snapshot with ${transcriptData.activeFiles.length} active files (transcript save failed: ${transcriptResult.message})]`;
+      } else {
+        autoSaveStatus = `
 [ContextStream: Auto-save failed - ${message}]`;
+      }
     }
   }
   const filesList = transcriptData.activeFiles.slice(0, 5).join(", ") || "none detected";
@@ -3103,46 +3297,1689 @@ async function runAutoRulesHook() {
   if (!inputData.trim()) {
     process.exit(0);
   }
-  let input;
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const toolName = input.tool_name || input.toolName || "";
+  const isContextTool = toolName.includes("init") || toolName.includes("context") || toolName.includes("session_init") || toolName.includes("context_smart");
+  if (!isContextTool) {
+    process.exit(0);
+  }
+  const cwd = extractCwd3(input);
+  const pythonHooks = detectPythonHooks(cwd);
+  const hasPythonHooksToUpgrade = pythonHooks.global || pythonHooks.project;
+  const rulesNotice = extractRulesNotice(input);
+  const rulesNeedUpdate = rulesNotice && rulesNotice.status !== "current";
+  if (!hasPythonHooksToUpgrade && !rulesNeedUpdate) {
+    process.exit(0);
+  }
+  const folderPath = rulesNotice?.update_args?.folder_path || cwd;
+  try {
+    await upgradeHooksForFolder(folderPath);
+    markAsRan();
+  } catch {
+  }
+  process.exit(0);
+}
+var API_URL3, API_KEY3, ENABLED6, MARKER_FILE, COOLDOWN_MS, isDirectRun6;
+var init_auto_rules = __esm({
+  "src/hooks/auto-rules.ts"() {
+    "use strict";
+    API_URL3 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY3 = process.env.CONTEXTSTREAM_API_KEY || "";
+    ENABLED6 = process.env.CONTEXTSTREAM_AUTO_RULES !== "false";
+    MARKER_FILE = path12.join(homedir9(), ".contextstream", ".auto-rules-ran");
+    COOLDOWN_MS = 4 * 60 * 60 * 1e3;
+    isDirectRun6 = process.argv[1]?.includes("auto-rules") || process.argv[2] === "auto-rules";
+    if (isDirectRun6) {
+      runAutoRulesHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/post-compact.ts
+var post_compact_exports = {};
+__export(post_compact_exports, {
+  runPostCompactHook: () => runPostCompactHook
+});
+import * as fs12 from "node:fs";
+import * as path13 from "node:path";
+import { homedir as homedir10 } from "node:os";
+function loadConfigFromMcpJson2(cwd) {
+  let searchDir = path13.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY4) {
+      const mcpPath = path13.join(searchDir, ".mcp.json");
+      if (fs12.existsSync(mcpPath)) {
+        try {
+          const content = fs12.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY4 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL4 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID2) {
+      const csConfigPath = path13.join(searchDir, ".contextstream", "config.json");
+      if (fs12.existsSync(csConfigPath)) {
+        try {
+          const content = fs12.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID2 = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path13.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY4) {
+    const homeMcpPath = path13.join(homedir10(), ".mcp.json");
+    if (fs12.existsSync(homeMcpPath)) {
+      try {
+        const content = fs12.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY4 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL4 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function fetchLastTranscript(sessionId) {
+  if (!API_KEY4) {
+    return null;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const url = new URL(`${API_URL4}/api/v1/transcripts`);
+    url.searchParams.set("session_id", sessionId);
+    url.searchParams.set("limit", "1");
+    url.searchParams.set("sort", "created_at:desc");
+    if (WORKSPACE_ID2) {
+      url.searchParams.set("workspace_id", WORKSPACE_ID2);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY4
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      const data = await response.json();
+      if (data.transcripts && data.transcripts.length > 0) {
+        return data.transcripts[0];
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatTranscriptSummary(transcript) {
+  const messages = transcript.messages || [];
+  const activeFiles = transcript.metadata?.active_files || [];
+  const toolCallCount = transcript.metadata?.tool_call_count || 0;
+  const userMessages = messages.filter((m) => m.role === "user").slice(-3).map((m) => `- "${m.content.slice(0, 100)}${m.content.length > 100 ? "..." : ""}"`).join("\n");
+  const lastAssistant = messages.filter((m) => m.role === "assistant" && !m.content.startsWith("[Tool:")).slice(-1)[0];
+  const lastWork = lastAssistant ? lastAssistant.content.slice(0, 300) + (lastAssistant.content.length > 300 ? "..." : "") : "None recorded";
+  return `## Pre-Compaction State Restored
+
+### Active Files (${activeFiles.length})
+${activeFiles.slice(0, 10).map((f) => `- ${f}`).join("\n") || "None tracked"}
+
+### Recent User Requests
+${userMessages || "None recorded"}
+
+### Last Work in Progress
+${lastWork}
+
+### Session Stats
+- Tool calls: ${toolCallCount}
+- Messages: ${messages.length}
+- Saved at: ${transcript.created_at}`;
+}
+async function runPostCompactHook() {
+  if (!ENABLED7) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson2(cwd);
+  const sessionId = input.session_id || "";
+  let restoredContext = "";
+  if (sessionId && API_KEY4) {
+    const transcript = await fetchLastTranscript(sessionId);
+    if (transcript) {
+      restoredContext = formatTranscriptSummary(transcript);
+    }
+  }
+  const context = `[POST-COMPACTION - Context Restored]
+
+${restoredContext || "No saved state found. Starting fresh."}
+
+**IMPORTANT:** Call \`mcp__contextstream__context(user_message="resuming after compaction")\` to get full context and any pending tasks.
+
+The conversation was compacted to save memory. The above summary was automatically restored from ContextStream.`;
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PostCompact",
+        additionalContext: context
+      }
+    })
+  );
+  process.exit(0);
+}
+var ENABLED7, API_URL4, API_KEY4, WORKSPACE_ID2, isDirectRun7;
+var init_post_compact = __esm({
+  "src/hooks/post-compact.ts"() {
+    "use strict";
+    ENABLED7 = process.env.CONTEXTSTREAM_POSTCOMPACT_ENABLED !== "false";
+    API_URL4 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY4 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID2 = null;
+    isDirectRun7 = process.argv[1]?.includes("post-compact") || process.argv[2] === "post-compact";
+    if (isDirectRun7) {
+      runPostCompactHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/on-bash.ts
+var on_bash_exports = {};
+__export(on_bash_exports, {
+  runOnBashHook: () => runOnBashHook
+});
+import * as fs13 from "node:fs";
+import * as path14 from "node:path";
+import { homedir as homedir11 } from "node:os";
+function loadConfigFromMcpJson3(cwd) {
+  let searchDir = path14.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY5) {
+      const mcpPath = path14.join(searchDir, ".mcp.json");
+      if (fs13.existsSync(mcpPath)) {
+        try {
+          const content = fs13.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY5 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL5 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID3) {
+      const csConfigPath = path14.join(searchDir, ".contextstream", "config.json");
+      if (fs13.existsSync(csConfigPath)) {
+        try {
+          const content = fs13.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID3 = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path14.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY5) {
+    const homeMcpPath = path14.join(homedir11(), ".mcp.json");
+    if (fs13.existsSync(homeMcpPath)) {
+      try {
+        const content = fs13.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY5 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL5 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function captureCommand(command, output, exitCode, isError, sessionId) {
+  if (!API_KEY5) return;
+  const payload = {
+    event_type: isError ? "bash_error" : "bash_command",
+    title: isError ? `Bash Error: ${command.slice(0, 50)}...` : `Command: ${command.slice(0, 50)}...`,
+    content: JSON.stringify({
+      command,
+      output: output.slice(0, 2e3),
+      exit_code: exitCode,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: isError ? "high" : "low",
+    tags: isError ? ["bash", "error", "command"] : ["bash", "command"],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID3) {
+    payload.workspace_id = WORKSPACE_ID3;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL5}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY5
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function suggestLesson(command, error) {
+  const errorPatterns = [
+    {
+      pattern: /command not found/i,
+      lesson: `The command "${command.split(" ")[0]}" is not installed. Check if the package needs to be installed first.`
+    },
+    {
+      pattern: /permission denied/i,
+      lesson: "Permission denied. May need sudo or to check file permissions."
+    },
+    {
+      pattern: /no such file or directory/i,
+      lesson: "Path does not exist. Verify the file/directory path before running commands."
+    },
+    {
+      pattern: /EADDRINUSE|address already in use/i,
+      lesson: "Port is already in use. Kill the existing process or use a different port."
+    },
+    {
+      pattern: /npm ERR!|ERESOLVE/i,
+      lesson: "npm dependency conflict. Try `npm install --legacy-peer-deps` or check package versions."
+    },
+    {
+      pattern: /ENOENT.*package\.json/i,
+      lesson: "No package.json found. Make sure you're in the right directory or run `npm init`."
+    },
+    {
+      pattern: /git.*not a git repository/i,
+      lesson: "Not in a git repository. Run `git init` or navigate to a git repo."
+    }
+  ];
+  for (const { pattern, lesson } of errorPatterns) {
+    if (pattern.test(error)) {
+      return lesson;
+    }
+  }
+  return null;
+}
+async function runOnBashHook() {
+  if (!ENABLED8) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  if (input.tool_name !== "Bash") {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson3(cwd);
+  const command = input.tool_input?.command || "";
+  const output = input.tool_result?.output || input.tool_result?.error || "";
+  const exitCode = input.tool_result?.exit_code ?? 0;
+  const sessionId = input.session_id || "unknown";
+  const isError = exitCode !== 0 || !!input.tool_result?.error;
+  captureCommand(command, output, exitCode, isError, sessionId).catch(() => {
+  });
+  if (isError) {
+    const lesson = await suggestLesson(command, output);
+    if (lesson) {
+      console.log(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: `[ContextStream Insight] ${lesson}`
+          }
+        })
+      );
+      process.exit(0);
+    }
+  }
+  process.exit(0);
+}
+var ENABLED8, API_URL5, API_KEY5, WORKSPACE_ID3, isDirectRun8;
+var init_on_bash = __esm({
+  "src/hooks/on-bash.ts"() {
+    "use strict";
+    ENABLED8 = process.env.CONTEXTSTREAM_BASH_HOOK_ENABLED !== "false";
+    API_URL5 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY5 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID3 = null;
+    isDirectRun8 = process.argv[1]?.includes("on-bash") || process.argv[2] === "on-bash";
+    if (isDirectRun8) {
+      runOnBashHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/on-task.ts
+var on_task_exports = {};
+__export(on_task_exports, {
+  runOnTaskHook: () => runOnTaskHook
+});
+import * as fs14 from "node:fs";
+import * as path15 from "node:path";
+import { homedir as homedir12 } from "node:os";
+function loadConfigFromMcpJson4(cwd) {
+  let searchDir = path15.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY6) {
+      const mcpPath = path15.join(searchDir, ".mcp.json");
+      if (fs14.existsSync(mcpPath)) {
+        try {
+          const content = fs14.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY6 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL6 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID4) {
+      const csConfigPath = path15.join(searchDir, ".contextstream", "config.json");
+      if (fs14.existsSync(csConfigPath)) {
+        try {
+          const content = fs14.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID4 = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path15.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY6) {
+    const homeMcpPath = path15.join(homedir12(), ".mcp.json");
+    if (fs14.existsSync(homeMcpPath)) {
+      try {
+        const content = fs14.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY6 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL6 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function captureTaskInvocation(description, prompt, agentType, result, sessionId) {
+  if (!API_KEY6) return;
+  const payload = {
+    event_type: "task_agent",
+    title: `Agent: ${agentType} - ${description}`,
+    content: JSON.stringify({
+      description,
+      prompt: prompt.slice(0, 1e3),
+      agent_type: agentType,
+      result: result.slice(0, 2e3),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "medium",
+    tags: ["task", "agent", agentType.toLowerCase()],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID4) {
+    payload.workspace_id = WORKSPACE_ID4;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL6}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY6
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runOnTaskHook() {
+  if (!ENABLED9) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  if (input.tool_name !== "Task") {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson4(cwd);
+  const description = input.tool_input?.description || "Unknown task";
+  const prompt = input.tool_input?.prompt || "";
+  const agentType = input.tool_input?.subagent_type || "general-purpose";
+  const result = input.tool_result?.output || "";
+  const sessionId = input.session_id || "unknown";
+  captureTaskInvocation(description, prompt, agentType, result, sessionId).catch(() => {
+  });
+  process.exit(0);
+}
+var ENABLED9, API_URL6, API_KEY6, WORKSPACE_ID4, isDirectRun9;
+var init_on_task = __esm({
+  "src/hooks/on-task.ts"() {
+    "use strict";
+    ENABLED9 = process.env.CONTEXTSTREAM_TASK_HOOK_ENABLED !== "false";
+    API_URL6 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY6 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID4 = null;
+    isDirectRun9 = process.argv[1]?.includes("on-task") || process.argv[2] === "on-task";
+    if (isDirectRun9) {
+      runOnTaskHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/on-read.ts
+var on_read_exports = {};
+__export(on_read_exports, {
+  runOnReadHook: () => runOnReadHook
+});
+import * as fs15 from "node:fs";
+import * as path16 from "node:path";
+import { homedir as homedir13 } from "node:os";
+function loadConfigFromMcpJson5(cwd) {
+  let searchDir = path16.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY7) {
+      const mcpPath = path16.join(searchDir, ".mcp.json");
+      if (fs15.existsSync(mcpPath)) {
+        try {
+          const content = fs15.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY7 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL7 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID5) {
+      const csConfigPath = path16.join(searchDir, ".contextstream", "config.json");
+      if (fs15.existsSync(csConfigPath)) {
+        try {
+          const content = fs15.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID5 = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path16.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY7) {
+    const homeMcpPath = path16.join(homedir13(), ".mcp.json");
+    if (fs15.existsSync(homeMcpPath)) {
+      try {
+        const content = fs15.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY7 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL7 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function captureExploration(toolName, target, resultSummary, sessionId) {
+  if (!API_KEY7) return;
+  const cacheKey = `${toolName}:${target}`;
+  if (recentCaptures.has(cacheKey)) {
+    return;
+  }
+  recentCaptures.add(cacheKey);
+  setTimeout(() => recentCaptures.delete(cacheKey), CAPTURE_WINDOW_MS);
+  const payload = {
+    event_type: "file_exploration",
+    title: `${toolName}: ${target.slice(0, 50)}`,
+    content: JSON.stringify({
+      tool: toolName,
+      target,
+      result_summary: resultSummary.slice(0, 500),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "low",
+    tags: ["exploration", toolName.toLowerCase()],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID5) {
+    payload.workspace_id = WORKSPACE_ID5;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL7}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY7
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runOnReadHook() {
+  if (!ENABLED10) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const toolName = input.tool_name || "";
+  if (!["Read", "Glob", "Grep"].includes(toolName)) {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson5(cwd);
+  const sessionId = input.session_id || "unknown";
+  let target = "";
+  let resultSummary = "";
+  switch (toolName) {
+    case "Read":
+      target = input.tool_input?.file_path || "";
+      resultSummary = `Read file: ${target}`;
+      break;
+    case "Glob":
+      target = input.tool_input?.pattern || "";
+      const globFiles = input.tool_result?.files || [];
+      resultSummary = `Found ${globFiles.length} files matching ${target}`;
+      break;
+    case "Grep":
+      target = input.tool_input?.pattern || "";
+      const matches = input.tool_result?.matches || 0;
+      resultSummary = `Found ${matches} matches for "${target}"`;
+      break;
+  }
+  if (target) {
+    captureExploration(toolName, target, resultSummary, sessionId).catch(() => {
+    });
+  }
+  process.exit(0);
+}
+var ENABLED10, API_URL7, API_KEY7, WORKSPACE_ID5, recentCaptures, CAPTURE_WINDOW_MS, isDirectRun10;
+var init_on_read = __esm({
+  "src/hooks/on-read.ts"() {
+    "use strict";
+    ENABLED10 = process.env.CONTEXTSTREAM_READ_HOOK_ENABLED !== "false";
+    API_URL7 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY7 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID5 = null;
+    recentCaptures = /* @__PURE__ */ new Set();
+    CAPTURE_WINDOW_MS = 6e4;
+    isDirectRun10 = process.argv[1]?.includes("on-read") || process.argv[2] === "on-read";
+    if (isDirectRun10) {
+      runOnReadHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/on-web.ts
+var on_web_exports = {};
+__export(on_web_exports, {
+  runOnWebHook: () => runOnWebHook
+});
+import * as fs16 from "node:fs";
+import * as path17 from "node:path";
+import { homedir as homedir14 } from "node:os";
+function loadConfigFromMcpJson6(cwd) {
+  let searchDir = path17.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY8) {
+      const mcpPath = path17.join(searchDir, ".mcp.json");
+      if (fs16.existsSync(mcpPath)) {
+        try {
+          const content = fs16.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY8 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL8 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID6) {
+      const csConfigPath = path17.join(searchDir, ".contextstream", "config.json");
+      if (fs16.existsSync(csConfigPath)) {
+        try {
+          const content = fs16.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID6 = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path17.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY8) {
+    const homeMcpPath = path17.join(homedir14(), ".mcp.json");
+    if (fs16.existsSync(homeMcpPath)) {
+      try {
+        const content = fs16.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY8 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL8 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function captureWebResearch(toolName, target, summary, sessionId) {
+  if (!API_KEY8) return;
+  const payload = {
+    event_type: "web_research",
+    title: `${toolName}: ${target.slice(0, 60)}`,
+    content: JSON.stringify({
+      tool: toolName,
+      target,
+      summary: summary.slice(0, 1e3),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "medium",
+    tags: ["research", "web", toolName.toLowerCase()],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID6) {
+    payload.workspace_id = WORKSPACE_ID6;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL8}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY8
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runOnWebHook() {
+  if (!ENABLED11) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const toolName = input.tool_name || "";
+  if (!["WebFetch", "WebSearch"].includes(toolName)) {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson6(cwd);
+  const sessionId = input.session_id || "unknown";
+  let target = "";
+  let summary = "";
+  switch (toolName) {
+    case "WebFetch":
+      target = input.tool_input?.url || "";
+      const prompt = input.tool_input?.prompt || "fetched content";
+      const content = input.tool_result?.output || input.tool_result?.content || "";
+      summary = `Fetched ${target} (${prompt}): ${content.slice(0, 300)}`;
+      break;
+    case "WebSearch":
+      target = input.tool_input?.query || "";
+      const results = input.tool_result?.results || [];
+      const topResults = results.slice(0, 3).map((r) => `- ${r.title}: ${r.url}`).join("\n");
+      summary = `Search: "${target}"
+Top results:
+${topResults}`;
+      break;
+  }
+  if (target) {
+    captureWebResearch(toolName, target, summary, sessionId).catch(() => {
+    });
+  }
+  process.exit(0);
+}
+var ENABLED11, API_URL8, API_KEY8, WORKSPACE_ID6, isDirectRun11;
+var init_on_web = __esm({
+  "src/hooks/on-web.ts"() {
+    "use strict";
+    ENABLED11 = process.env.CONTEXTSTREAM_WEB_HOOK_ENABLED !== "false";
+    API_URL8 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY8 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID6 = null;
+    isDirectRun11 = process.argv[1]?.includes("on-web") || process.argv[2] === "on-web";
+    if (isDirectRun11) {
+      runOnWebHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/session-init.ts
+var session_init_exports = {};
+__export(session_init_exports, {
+  runSessionInitHook: () => runSessionInitHook
+});
+import * as fs17 from "node:fs";
+import * as path18 from "node:path";
+import { homedir as homedir15 } from "node:os";
+function loadConfigFromMcpJson7(cwd) {
+  let searchDir = path18.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY9) {
+      const mcpPath = path18.join(searchDir, ".mcp.json");
+      if (fs17.existsSync(mcpPath)) {
+        try {
+          const content = fs17.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY9 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL9 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+          if (csEnv?.CONTEXTSTREAM_WORKSPACE_ID) {
+            WORKSPACE_ID7 = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID7 || !PROJECT_ID) {
+      const csConfigPath = path18.join(searchDir, ".contextstream", "config.json");
+      if (fs17.existsSync(csConfigPath)) {
+        try {
+          const content = fs17.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id && !WORKSPACE_ID7) {
+            WORKSPACE_ID7 = csConfig.workspace_id;
+          }
+          if (csConfig.project_id && !PROJECT_ID) {
+            PROJECT_ID = csConfig.project_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path18.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY9) {
+    const homeMcpPath = path18.join(homedir15(), ".mcp.json");
+    if (fs17.existsSync(homeMcpPath)) {
+      try {
+        const content = fs17.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY9 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL9 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function fetchSessionContext() {
+  if (!API_KEY9) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const url = new URL(`${API_URL9}/api/v1/context`);
+    if (WORKSPACE_ID7) url.searchParams.set("workspace_id", WORKSPACE_ID7);
+    if (PROJECT_ID) url.searchParams.set("project_id", PROJECT_ID);
+    url.searchParams.set("include_rules", "true");
+    url.searchParams.set("include_lessons", "true");
+    url.searchParams.set("include_decisions", "true");
+    url.searchParams.set("include_plans", "true");
+    url.searchParams.set("limit", "5");
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY9
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return await response.json();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatContext(ctx) {
+  if (!ctx) {
+    return `[ContextStream Session Start]
+
+No stored context found. Call \`mcp__contextstream__context(user_message="starting new session")\` to initialize.`;
+  }
+  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)) {
+      parts.push(`- **${lesson.title}**: ${lesson.prevention}`);
+    }
+  }
+  if (ctx.active_plans && ctx.active_plans.length > 0) {
+    parts.push("\n## \u{1F4CB} Active Plans");
+    for (const plan of ctx.active_plans.slice(0, 3)) {
+      parts.push(`- ${plan.title} (${plan.status})`);
+    }
+  }
+  if (ctx.pending_tasks && ctx.pending_tasks.length > 0) {
+    parts.push("\n## \u2705 Pending Tasks");
+    for (const task of ctx.pending_tasks.slice(0, 5)) {
+      parts.push(`- ${task.title}`);
+    }
+  }
+  if (ctx.recent_decisions && ctx.recent_decisions.length > 0) {
+    parts.push("\n## \u{1F4DD} Recent Decisions");
+    for (const decision of ctx.recent_decisions.slice(0, 3)) {
+      parts.push(`- **${decision.title}**`);
+    }
+  }
+  parts.push("\n---");
+  parts.push('Call `mcp__contextstream__context(user_message="...")` for task-specific context.');
+  return parts.join("\n");
+}
+async function runSessionInitHook() {
+  if (!ENABLED12) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson7(cwd);
+  const context = await fetchSessionContext();
+  const formattedContext = formatContext(context);
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: formattedContext
+      }
+    })
+  );
+  process.exit(0);
+}
+var ENABLED12, API_URL9, API_KEY9, WORKSPACE_ID7, PROJECT_ID, isDirectRun12;
+var init_session_init = __esm({
+  "src/hooks/session-init.ts"() {
+    "use strict";
+    ENABLED12 = process.env.CONTEXTSTREAM_SESSION_INIT_ENABLED !== "false";
+    API_URL9 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY9 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID7 = null;
+    PROJECT_ID = null;
+    isDirectRun12 = process.argv[1]?.includes("session-init") || process.argv[2] === "session-init";
+    if (isDirectRun12) {
+      runSessionInitHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/session-end.ts
+var session_end_exports = {};
+__export(session_end_exports, {
+  runSessionEndHook: () => runSessionEndHook
+});
+import * as fs18 from "node:fs";
+import * as path19 from "node:path";
+import { homedir as homedir16 } from "node:os";
+function loadConfigFromMcpJson8(cwd) {
+  let searchDir = path19.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY10) {
+      const mcpPath = path19.join(searchDir, ".mcp.json");
+      if (fs18.existsSync(mcpPath)) {
+        try {
+          const content = fs18.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY10 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL10 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID8) {
+      const csConfigPath = path19.join(searchDir, ".contextstream", "config.json");
+      if (fs18.existsSync(csConfigPath)) {
+        try {
+          const content = fs18.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID8 = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path19.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY10) {
+    const homeMcpPath = path19.join(homedir16(), ".mcp.json");
+    if (fs18.existsSync(homeMcpPath)) {
+      try {
+        const content = fs18.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY10 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL10 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+function parseTranscriptStats(transcriptPath) {
+  const stats = {
+    messageCount: 0,
+    toolCallCount: 0,
+    duration: 0,
+    filesModified: []
+  };
+  if (!transcriptPath || !fs18.existsSync(transcriptPath)) {
+    return stats;
+  }
+  try {
+    const content = fs18.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n");
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    const modifiedFiles = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      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);
+            }
+          }
+        }
+        if (entry.timestamp) {
+          const ts = new Date(entry.timestamp);
+          if (!firstTimestamp || ts < firstTimestamp) {
+            firstTimestamp = ts;
+          }
+          if (!lastTimestamp || ts > lastTimestamp) {
+            lastTimestamp = ts;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (firstTimestamp && lastTimestamp) {
+      stats.duration = Math.round((lastTimestamp.getTime() - firstTimestamp.getTime()) / 1e3);
+    }
+    stats.filesModified = Array.from(modifiedFiles);
+  } catch {
+  }
+  return stats;
+}
+async function finalizeSession(sessionId, stats, reason) {
+  if (!API_KEY10) return;
+  const payload = {
+    event_type: "session_end",
+    title: `Session Ended: ${reason}`,
+    content: JSON.stringify({
+      session_id: sessionId,
+      reason,
+      stats: {
+        messages: stats.messageCount,
+        tool_calls: stats.toolCallCount,
+        duration_seconds: stats.duration,
+        files_modified: stats.filesModified.length
+      },
+      files_modified: stats.filesModified.slice(0, 20),
+      ended_at: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "low",
+    tags: ["session", "end", reason],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID8) {
+    payload.workspace_id = WORKSPACE_ID8;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    await fetch(`${API_URL10}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY10
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runSessionEndHook() {
+  if (!ENABLED13) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson8(cwd);
+  const sessionId = input.session_id || "unknown";
+  const transcriptPath = input.transcript_path || "";
+  const reason = input.reason || "user_exit";
+  const stats = parseTranscriptStats(transcriptPath);
+  await finalizeSession(sessionId, stats, reason);
+  process.exit(0);
+}
+var ENABLED13, API_URL10, API_KEY10, WORKSPACE_ID8, isDirectRun13;
+var init_session_end = __esm({
+  "src/hooks/session-end.ts"() {
+    "use strict";
+    ENABLED13 = process.env.CONTEXTSTREAM_SESSION_END_ENABLED !== "false";
+    API_URL10 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY10 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID8 = null;
+    isDirectRun13 = process.argv[1]?.includes("session-end") || process.argv[2] === "session-end";
+    if (isDirectRun13) {
+      runSessionEndHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/on-save-intent.ts
+var on_save_intent_exports = {};
+__export(on_save_intent_exports, {
+  runOnSaveIntentHook: () => runOnSaveIntentHook
+});
+function detectsSaveIntent(text) {
+  const hasSaveIntent = SAVE_PATTERNS.some((p) => p.test(text));
+  const isLocalFile = LOCAL_FILE_PATTERNS.some((p) => p.test(text));
+  return { hasSaveIntent, isLocalFile };
+}
+async function runOnSaveIntentHook() {
+  if (!ENABLED14) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  let prompt = input.prompt || "";
+  if (!prompt && input.session?.messages) {
+    for (const msg of [...input.session.messages].reverse()) {
+      if (msg.role === "user") {
+        if (typeof msg.content === "string") {
+          prompt = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text" && block.text) {
+              prompt = block.text;
+              break;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  if (!prompt) {
+    process.exit(0);
+  }
+  const { hasSaveIntent, isLocalFile } = detectsSaveIntent(prompt);
+  if (hasSaveIntent || isLocalFile) {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: SAVE_GUIDANCE
+        }
+      })
+    );
+  }
+  process.exit(0);
+}
+var ENABLED14, SAVE_PATTERNS, LOCAL_FILE_PATTERNS, SAVE_GUIDANCE, isDirectRun14;
+var init_on_save_intent = __esm({
+  "src/hooks/on-save-intent.ts"() {
+    "use strict";
+    ENABLED14 = process.env.CONTEXTSTREAM_SAVE_INTENT_ENABLED !== "false";
+    SAVE_PATTERNS = [
+      // Direct save requests
+      /\b(save|store|record|capture|log|document|write down|note down|keep track)\b.*\b(this|that|it|the)\b/i,
+      /\b(save|store|record|capture|log)\b.*\b(to|in|for)\b.*\b(contextstream|memory|later|reference|future)\b/i,
+      // Document creation
+      /\b(create|make|write|draft)\b.*\b(a|the)\b.*\b(document|doc|note|summary|report|spec|design)\b/i,
+      /\b(document|summarize|write up)\b.*\b(this|that|the|our)\b.*\b(decision|discussion|conversation|meeting|finding)\b/i,
+      // Memory/reference requests
+      /\b(remember|don't forget|keep in mind|note that|important to remember)\b/i,
+      /\bfor\s+(future|later)\s+reference\b/i,
+      /\b(add|put)\s+(this|it|that)\s+(to|in)\s+(memory|notes|docs)\b/i,
+      // Decision tracking
+      /\b(we\s+)?(decided|agreed|concluded|determined)\b.*\b(to|that)\b/i,
+      /\blet('s|s)\s+document\b/i,
+      /\bsave\s+(this|the)\s+(decision|choice|approach)\b/i,
+      // Implementation/design docs
+      /\b(implementation|design|architecture|spec)\s+(doc|document|plan)\b/i,
+      /\bwrite\s+(the|a|an)\s+.*(md|markdown|readme)\b/i
+    ];
+    LOCAL_FILE_PATTERNS = [
+      /\b(save|write|create)\s+(it|this|the\s+\w+)\s+(to|in|as)\s+[./~]/i,
+      /\b(save|write)\s+to\s+.*(\.md|\.txt|\.json|docs\/|notes\/)/i,
+      /\bcreate\s+(a|the)\s+file\b/i
+    ];
+    SAVE_GUIDANCE = `[CONTEXTSTREAM DOCUMENT STORAGE]
+The user wants to save/store content. Use ContextStream instead of local files:
+
+**For decisions/notes:**
+\`\`\`
+mcp__contextstream__session(
+  action="capture",
+  event_type="decision|note|insight",
+  title="...",
+  content="...",
+  importance="high|medium|low"
+)
+\`\`\`
+
+**For documents/specs:**
+\`\`\`
+mcp__contextstream__docs(
+  action="create",
+  title="...",
+  content="...",
+  doc_type="implementation|design|spec|guide"
+)
+\`\`\`
+
+**For plans:**
+\`\`\`
+mcp__contextstream__session(
+  action="capture_plan",
+  title="...",
+  steps=[...]
+)
+\`\`\`
+
+**Why ContextStream?**
+- Persists across sessions (local files don't)
+- Searchable and retrievable
+- Shows up in context automatically
+- Can be shared with team
+
+Only save to local files if user explicitly requests a specific file path.
+[END GUIDANCE]`;
+    isDirectRun14 = process.argv[1]?.includes("on-save-intent") || process.argv[2] === "on-save-intent";
+    if (isDirectRun14) {
+      runOnSaveIntentHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/verify-key.ts
+var verify_key_exports = {};
+__export(verify_key_exports, {
+  loadApiKey: () => loadApiKey,
+  maskApiKey: () => maskApiKey2,
+  runVerifyKey: () => runVerifyKey,
+  validateApiKey: () => validateApiKey
+});
+import * as fs19 from "node:fs";
+import * as path20 from "node:path";
+import { homedir as homedir17 } 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}`;
+}
+function extractFromMcpConfig(config) {
+  if (!config.mcpServers) return {};
+  const priorityNames = ["contextstream", "ContextStream", "context-stream"];
+  for (const name of priorityNames) {
+    const server = config.mcpServers[name];
+    if (server?.env?.CONTEXTSTREAM_API_KEY) {
+      return {
+        apiKey: server.env.CONTEXTSTREAM_API_KEY,
+        apiUrl: server.env.CONTEXTSTREAM_API_URL
+      };
+    }
+  }
+  for (const [, server] of Object.entries(config.mcpServers)) {
+    if (server?.env?.CONTEXTSTREAM_API_KEY) {
+      return {
+        apiKey: server.env.CONTEXTSTREAM_API_KEY,
+        apiUrl: server.env.CONTEXTSTREAM_API_URL
+      };
+    }
+  }
+  return {};
+}
+function getClaudeDesktopConfigPath() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return path20.join(homedir17(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (platform === "win32") {
+    return path20.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+  } else {
+    return path20.join(homedir17(), ".config", "Claude", "claude_desktop_config.json");
+  }
+}
+function loadApiKey() {
+  let apiKey = null;
+  let apiUrl = "https://api.contextstream.io";
+  let source = "none";
+  if (process.env.CONTEXTSTREAM_API_KEY) {
+    apiKey = process.env.CONTEXTSTREAM_API_KEY;
+    source = "environment";
+    if (process.env.CONTEXTSTREAM_API_URL) {
+      apiUrl = process.env.CONTEXTSTREAM_API_URL;
+    }
+    return { apiKey, apiUrl, source };
+  }
+  let searchDir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const projectMcpPath = path20.join(searchDir, ".mcp.json");
+    if (fs19.existsSync(projectMcpPath)) {
+      try {
+        const content = fs19.readFileSync(projectMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const extracted = extractFromMcpConfig(config);
+        if (extracted.apiKey) {
+          apiKey = extracted.apiKey;
+          source = `${projectMcpPath}`;
+          if (extracted.apiUrl) {
+            apiUrl = extracted.apiUrl;
+          }
+          return { apiKey, apiUrl, source };
+        }
+      } catch {
+      }
+    }
+    const parentDir = path20.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  const globalMcpPath = path20.join(homedir17(), ".mcp.json");
+  if (fs19.existsSync(globalMcpPath)) {
+    try {
+      const content = fs19.readFileSync(globalMcpPath, "utf-8");
+      const config = JSON.parse(content);
+      const extracted = extractFromMcpConfig(config);
+      if (extracted.apiKey) {
+        apiKey = extracted.apiKey;
+        source = "~/.mcp.json";
+        if (extracted.apiUrl) {
+          apiUrl = extracted.apiUrl;
+        }
+        return { apiKey, apiUrl, source };
+      }
+    } catch {
+    }
+  }
+  const cursorPaths = [
+    path20.join(process.cwd(), ".cursor", "mcp.json"),
+    path20.join(homedir17(), ".cursor", "mcp.json")
+  ];
+  for (const cursorPath of cursorPaths) {
+    if (fs19.existsSync(cursorPath)) {
+      try {
+        const content = fs19.readFileSync(cursorPath, "utf-8");
+        const config = JSON.parse(content);
+        const extracted = extractFromMcpConfig(config);
+        if (extracted.apiKey) {
+          apiKey = extracted.apiKey;
+          source = cursorPath;
+          if (extracted.apiUrl) {
+            apiUrl = extracted.apiUrl;
+          }
+          return { apiKey, apiUrl, source };
+        }
+      } catch {
+      }
+    }
+  }
+  const claudeDesktopPath = getClaudeDesktopConfigPath();
+  if (fs19.existsSync(claudeDesktopPath)) {
+    try {
+      const content = fs19.readFileSync(claudeDesktopPath, "utf-8");
+      const config = JSON.parse(content);
+      const extracted = extractFromMcpConfig(config);
+      if (extracted.apiKey) {
+        apiKey = extracted.apiKey;
+        source = claudeDesktopPath;
+        if (extracted.apiUrl) {
+          apiUrl = extracted.apiUrl;
+        }
+        return { apiKey, apiUrl, source };
+      }
+    } catch {
+    }
+  }
+  const vscodePaths = [
+    path20.join(homedir17(), ".vscode", "mcp.json"),
+    path20.join(homedir17(), ".codeium", "windsurf", "mcp_config.json"),
+    path20.join(homedir17(), ".continue", "config.json")
+  ];
+  for (const vsPath of vscodePaths) {
+    if (fs19.existsSync(vsPath)) {
+      try {
+        const content = fs19.readFileSync(vsPath, "utf-8");
+        const config = JSON.parse(content);
+        const extracted = extractFromMcpConfig(config);
+        if (extracted.apiKey) {
+          apiKey = extracted.apiKey;
+          source = vsPath;
+          if (extracted.apiUrl) {
+            apiUrl = extracted.apiUrl;
+          }
+          return { apiKey, apiUrl, source };
+        }
+      } catch {
+      }
+    }
+  }
+  const credentialsPath = path20.join(homedir17(), ".contextstream", "credentials.json");
+  if (fs19.existsSync(credentialsPath)) {
+    try {
+      const content = fs19.readFileSync(credentialsPath, "utf-8");
+      const creds = JSON.parse(content);
+      if (creds.api_key) {
+        apiKey = creds.api_key;
+        source = "~/.contextstream/credentials.json";
+        if (creds.api_url) {
+          apiUrl = creds.api_url;
+        }
+        return { apiKey, apiUrl, source };
+      }
+    } catch {
+    }
+  }
+  return { apiKey, apiUrl, source };
+}
+async function validateApiKey(apiKey, apiUrl) {
   try {
-    input = JSON.parse(inputData);
-  } catch {
-    process.exit(0);
-  }
-  const toolName = input.tool_name || input.toolName || "";
-  const isContextTool = toolName.includes("init") || toolName.includes("context") || toolName.includes("session_init") || toolName.includes("context_smart");
-  if (!isContextTool) {
-    process.exit(0);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    const response = await fetch(`${apiUrl}/api/v1/auth/me`, {
+      method: "GET",
+      headers: {
+        "X-API-Key": apiKey
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      const data = await response.json();
+      return {
+        valid: true,
+        masked_key: maskApiKey2(apiKey),
+        email: data.email,
+        name: data.name || data.full_name,
+        plan: data.plan_name || data.plan || "free",
+        workspace_name: data.workspace?.name
+      };
+    } else if (response.status === 401) {
+      return {
+        valid: false,
+        masked_key: maskApiKey2(apiKey),
+        error: "Invalid or expired API key"
+      };
+    } else {
+      return {
+        valid: false,
+        masked_key: maskApiKey2(apiKey),
+        error: `API error: ${response.status}`
+      };
+    }
+  } catch (error) {
+    return {
+      valid: false,
+      masked_key: maskApiKey2(apiKey),
+      error: `Connection error: ${error instanceof Error ? error.message : String(error)}`
+    };
   }
-  const cwd = extractCwd3(input);
-  const pythonHooks = detectPythonHooks(cwd);
-  const hasPythonHooksToUpgrade = pythonHooks.global || pythonHooks.project;
-  const rulesNotice = extractRulesNotice(input);
-  const rulesNeedUpdate = rulesNotice && rulesNotice.status !== "current";
-  if (!hasPythonHooksToUpgrade && !rulesNeedUpdate) {
-    process.exit(0);
+}
+async function runVerifyKey(outputJson) {
+  const { apiKey, apiUrl, source } = loadApiKey();
+  if (!apiKey) {
+    const result2 = {
+      valid: false,
+      masked_key: "",
+      error: "No API key found. Run 'contextstream-mcp setup' to configure."
+    };
+    if (outputJson) {
+      console.log(JSON.stringify(result2));
+    } else {
+      console.log("\u274C No API key found");
+      console.log("   Run 'contextstream-mcp setup' to configure your API key.");
+    }
+    return result2;
   }
-  const folderPath = rulesNotice?.update_args?.folder_path || cwd;
-  try {
-    await upgradeHooksForFolder(folderPath);
-    markAsRan();
-  } catch {
+  const result = await validateApiKey(apiKey, apiUrl);
+  if (outputJson) {
+    console.log(JSON.stringify({ ...result, source }));
+  } else {
+    console.log("");
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\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.log("   ContextStream API Key");
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\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.log("");
+    console.log(`  Key:     ${result.masked_key}`);
+    console.log(`  Source:  ${source}`);
+    if (result.valid) {
+      console.log(`  Status:  \u2713 Valid`);
+      if (result.email) {
+        console.log(`  Account: ${result.email}`);
+      }
+      if (result.name) {
+        console.log(`  Name:    ${result.name}`);
+      }
+      if (result.plan) {
+        console.log(`  Plan:    ${result.plan}`);
+      }
+      if (result.workspace_name) {
+        console.log(`  Workspace: ${result.workspace_name}`);
+      }
+    } else {
+      console.log(`  Status:  \u2717 Invalid`);
+      console.log(`  Error:   ${result.error}`);
+    }
+    console.log("");
   }
-  process.exit(0);
+  return result;
 }
-var API_URL3, API_KEY3, ENABLED6, MARKER_FILE, COOLDOWN_MS, isDirectRun6;
-var init_auto_rules = __esm({
-  "src/hooks/auto-rules.ts"() {
+var init_verify_key = __esm({
+  "src/verify-key.ts"() {
     "use strict";
-    API_URL3 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY3 = process.env.CONTEXTSTREAM_API_KEY || "";
-    ENABLED6 = process.env.CONTEXTSTREAM_AUTO_RULES !== "false";
-    MARKER_FILE = path12.join(homedir9(), ".contextstream", ".auto-rules-ran");
-    COOLDOWN_MS = 4 * 60 * 60 * 1e3;
-    isDirectRun6 = process.argv[1]?.includes("auto-rules") || process.argv[2] === "auto-rules";
-    if (isDirectRun6) {
-      runAutoRulesHook().catch(() => process.exit(0));
-    }
   }
 });
 
@@ -3628,8 +5465,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path13, errorMaps, issueData } = params;
-  const fullPath = [...path13, ...issueData.path || []];
+  const { data, path: path21, errorMaps, issueData } = params;
+  const fullPath = [...path21, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3745,11 +5582,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path13, key) {
+  constructor(parent, value, path21, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path13;
+    this._path = path21;
     this._key = key;
   }
   get path() {
@@ -7199,6 +9036,9 @@ 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");
@@ -7482,14 +9322,14 @@ var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504])
 var MAX_RETRIES = 3;
 var BASE_DELAY = 1e3;
 async function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
-async function request(config, path13, options = {}) {
+async function request(config, path21, options = {}) {
   const { apiUrl, userAgent } = config;
   const authOverride = getAuthOverride();
   const apiKey = authOverride?.apiKey ?? config.apiKey;
   const jwt = authOverride?.jwt ?? config.jwt;
-  const apiPath = path13.startsWith("/api/") ? path13 : `/api/v1${path13}`;
+  const apiPath = path21.startsWith("/api/") ? path21 : `/api/v1${path21}`;
   const url = `${apiUrl.replace(/\/$/, "")}${apiPath}`;
   const maxRetries = options.retries ?? MAX_RETRIES;
   const baseDelay = options.retryDelay ?? BASE_DELAY;
@@ -7635,9 +9475,9 @@ function extractErrorCode(payload) {
   if (typeof payload.code === "string" && payload.code.trim()) return payload.code.trim();
   return null;
 }
-function detectIntegrationProvider(path13) {
-  if (/\/github(\/|$)/i.test(path13)) return "github";
-  if (/\/slack(\/|$)/i.test(path13)) return "slack";
+function detectIntegrationProvider(path21) {
+  if (/\/github(\/|$)/i.test(path21)) return "github";
+  if (/\/slack(\/|$)/i.test(path21)) return "slack";
   return null;
 }
 function rewriteNotFoundMessage(input) {
@@ -8290,10 +10130,10 @@ var PROJECT_MARKERS = [
 ];
 function isMultiProjectFolder(folderPath) {
   try {
-    const fs12 = __require("fs");
+    const fs20 = __require("fs");
     const pathModule = __require("path");
-    const rootHasGit = fs12.existsSync(pathModule.join(folderPath, ".git"));
-    const entries = fs12.readdirSync(folderPath, { withFileTypes: true });
+    const rootHasGit = fs20.existsSync(pathModule.join(folderPath, ".git"));
+    const entries = fs20.readdirSync(folderPath, { withFileTypes: true });
     const subdirs = entries.filter(
       (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules"
     );
@@ -8301,7 +10141,7 @@ function isMultiProjectFolder(folderPath) {
     for (const subdir of subdirs) {
       const subdirPath = pathModule.join(folderPath, subdir.name);
       for (const marker of PROJECT_MARKERS) {
-        if (fs12.existsSync(pathModule.join(subdirPath, marker))) {
+        if (fs20.existsSync(pathModule.join(subdirPath, marker))) {
           projectSubdirs.push(subdir.name);
           break;
         }
@@ -9935,6 +11775,35 @@ var ContextStreamClient = class {
       }
     });
   }
+  /**
+   * Capture a memory event with a direct event_type.
+   * Used for auto-save session snapshots and other system events.
+   */
+  async captureMemoryEvent(params) {
+    const withDefaults = this.withDefaults(params);
+    const metadata = {
+      ...params.metadata || {}
+    };
+    if (params.tags && params.tags.length > 0) {
+      metadata.tags = params.tags;
+    }
+    if (!metadata.captured_at) {
+      metadata.captured_at = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (!metadata.source) {
+      metadata.source = "mcp_auto_capture";
+    }
+    return this.createMemoryEvent({
+      workspace_id: withDefaults.workspace_id,
+      project_id: withDefaults.project_id,
+      event_type: params.event_type,
+      title: params.title,
+      content: params.content,
+      provenance: params.provenance,
+      code_refs: params.code_refs,
+      metadata
+    });
+  }
   submitContextFeedback(body) {
     return request(this.config, "/context/smart/feedback", { body: this.withDefaults(body) });
   }
@@ -10339,9 +12208,9 @@ var ContextStreamClient = class {
           candidateParts.push("## Relevant Code\n");
           currentChars += 18;
           const codeEntries = code.results.map((c) => {
-            const path13 = c.file_path || "file";
+            const path21 = c.file_path || "file";
             const content = c.content?.slice(0, 150) || "";
-            return { path: path13, entry: `\u2022 ${path13}: ${content}...
+            return { path: path21, entry: `\u2022 ${path21}: ${content}...
 ` };
           });
           for (const c of codeEntries) {
@@ -10502,7 +12371,11 @@ var ContextStreamClient = class {
           notice_inline: false,
           // Session token tracking for context pressure
           ...params.session_tokens !== void 0 && { session_tokens: params.session_tokens },
-          ...params.context_threshold !== void 0 && { context_threshold: params.context_threshold }
+          ...params.context_threshold !== void 0 && { context_threshold: params.context_threshold },
+          // 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 }
         }
       });
       const data = unwrapApiResponse(apiResult);
@@ -12064,6 +13937,95 @@ ${context}`;
     uuidSchema.parse(params.doc_id);
     return request(this.config, `/docs/${params.doc_id}`, { method: "DELETE" });
   }
+  // -------------------------------------------------------------------------
+  // Transcript methods (conversation session storage)
+  // -------------------------------------------------------------------------
+  /**
+   * List transcripts for a workspace/project
+   */
+  async listTranscripts(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const query = new URLSearchParams();
+    if (withDefaults.workspace_id) query.set("workspace_id", withDefaults.workspace_id);
+    if (withDefaults.project_id) query.set("project_id", withDefaults.project_id);
+    if (params?.session_id) query.set("session_id", params.session_id);
+    if (params?.client_name) query.set("client_name", params.client_name);
+    if (params?.started_after) query.set("started_after", params.started_after);
+    if (params?.started_before) query.set("started_before", params.started_before);
+    if (params?.limit) query.set("per_page", String(params.limit));
+    if (params?.page) query.set("page", String(params.page));
+    if (params?.per_page) query.set("per_page", String(params.per_page));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/transcripts${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get a specific transcript by ID
+   */
+  async getTranscript(transcript_id) {
+    uuidSchema.parse(transcript_id);
+    return request(this.config, `/transcripts/${transcript_id}`, { method: "GET" });
+  }
+  /**
+   * Search transcripts by content
+   */
+  async searchTranscripts(params) {
+    const withDefaults = this.withDefaults(params);
+    const queryParams = new URLSearchParams();
+    if (withDefaults.workspace_id) queryParams.set("workspace_id", withDefaults.workspace_id);
+    queryParams.set("query", params.query);
+    if (params.limit) queryParams.set("limit", String(params.limit));
+    return request(this.config, `/transcripts/search?${queryParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Delete a transcript
+   */
+  async deleteTranscript(transcript_id) {
+    uuidSchema.parse(transcript_id);
+    return request(this.config, `/transcripts/${transcript_id}`, { method: "DELETE" });
+  }
+  // -------------------------------------------------------------------------
+  // Suggested Rules methods (ML-generated rule suggestions)
+  // -------------------------------------------------------------------------
+  /**
+   * List suggested rules
+   */
+  async listSuggestedRules(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const queryParams = new URLSearchParams();
+    if (withDefaults.workspace_id) queryParams.set("workspace_id", withDefaults.workspace_id);
+    if (params?.status) queryParams.set("status", params.status);
+    if (params?.source_type) queryParams.set("source_type", params.source_type);
+    if (params?.min_confidence) queryParams.set("min_confidence", String(params.min_confidence));
+    if (params?.limit) queryParams.set("limit", String(params.limit));
+    if (params?.offset) queryParams.set("offset", String(params.offset));
+    return request(this.config, `/suggested-rules?${queryParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Get pending suggested rules count
+   */
+  async getSuggestedRulesPendingCount(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const queryParams = new URLSearchParams();
+    if (withDefaults.workspace_id) queryParams.set("workspace_id", withDefaults.workspace_id);
+    return request(this.config, `/suggested-rules/pending-count?${queryParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Get suggested rules feedback stats
+   */
+  async getSuggestedRulesStats(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const queryParams = new URLSearchParams();
+    if (withDefaults.workspace_id) queryParams.set("workspace_id", withDefaults.workspace_id);
+    return request(this.config, `/suggested-rules/stats?${queryParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Perform action on suggested rule (accept/reject/modify)
+   */
+  async suggestedRuleAction(params) {
+    uuidSchema.parse(params.rule_id);
+    const { rule_id, ...body } = params;
+    return request(this.config, `/suggested-rules/${rule_id}/action`, { method: "POST", body });
+  }
 };
 
 // src/tools.ts
@@ -13110,111 +15072,84 @@ function trackToolTokenSavings(client, tool, contextText, params, extraMetadata)
   }
 }
 
-// src/educational-microcopy.ts
-var SESSION_INIT_TIPS = [
-  "AI work that doesn't disappear.",
-  "Every conversation builds context. Every artifact persists.",
-  "Your AI remembers. Now you can see what it knows.",
-  "Context that survives sessions.",
-  "The bridge between AI conversations and human artifacts."
-];
+// src/microcopy.ts
 function getSessionInitTip(sessionId) {
-  const index = sessionId ? Math.abs(hashString(sessionId)) % SESSION_INIT_TIPS.length : Math.floor(Math.random() * SESSION_INIT_TIPS.length);
-  return SESSION_INIT_TIPS[index];
-}
-var CAPTURE_HINTS = {
-  // Core event types
-  decision: "Future you will thank present you.",
-  preference: "Noted. This will inform future suggestions.",
-  insight: "Captured for future reference.",
-  note: "Saved. Won't disappear when the chat does.",
-  implementation: "Implementation recorded.",
-  task: "Task tracked.",
-  bug: "Bug logged for tracking.",
-  feature: "Feature request captured.",
-  plan: "This plan will be here when you come back.",
-  correction: "Correction noted. Learning from this.",
-  lesson: "Learn once, remember forever.",
-  warning: "Warning logged.",
-  frustration: "Feedback captured. We're listening.",
-  conversation: "Conversation preserved.",
-  session_snapshot: "Session state saved. Ready to resume anytime."
-};
+  return `Session ${sessionId.slice(0, 8)}... initialized. Use context(user_message="...") to get relevant context.`;
+}
 function getCaptureHint(eventType) {
-  return CAPTURE_HINTS[eventType] || "Captured. This will survive when the chat disappears.";
-}
-var EMPTY_STATE_HINTS = {
-  // Plans
-  list_plans: "No plans yet. Plans live here, not in chat transcripts.",
-  get_plan: "Plan not found. Create one to track implementation across sessions.",
-  // Memory & Search
-  recall: "Nothing found yet. Context builds over time.",
-  search: "No matches. Try a different query or let context accumulate.",
-  list_events: "No events yet. Start capturing decisions and insights.",
-  decisions: "No decisions captured yet. Record the 'why' behind your choices.",
-  timeline: "Timeline empty. Events will appear as you work.",
-  // Lessons
-  get_lessons: "No lessons yet. Capture mistakes to learn from them.",
-  // Tasks
-  list_tasks: "No tasks yet. Break plans into trackable tasks.",
-  // Todos
-  list_todos: "No todos yet. Action items will appear here.",
-  // Diagrams
-  list_diagrams: "No diagrams yet. AI-generated diagrams persist here.",
-  // Docs
-  list_docs: "No docs yet. Turn AI explanations into shareable documentation.",
-  // Reminders
-  list_reminders: "No reminders set. Schedule follow-ups that won't be forgotten.",
-  // Generic
-  default: "Nothing yet. Start a conversation\u2014context builds over time."
-};
-function getEmptyStateHint(action) {
-  return EMPTY_STATE_HINTS[action] || EMPTY_STATE_HINTS.default;
+  switch (eventType) {
+    case "decision":
+      return "Decision captured. It will surface in future context() calls when relevant.";
+    case "preference":
+      return "Preference saved. Future sessions will respect this preference.";
+    case "insight":
+      return "Insight captured. Use recall() to retrieve it later.";
+    case "task":
+      return "Task captured. Use list_tasks() to view all tasks.";
+    case "lesson":
+      return "Lesson saved. It will warn you before similar mistakes.";
+    case "session_snapshot":
+      return "Session state saved. Use restore_context() after compaction.";
+    default:
+      return "Event captured. Use recall() to retrieve related events.";
+  }
+}
+function getEmptyStateHint(operation) {
+  switch (operation) {
+    case "get_lessons":
+      return "No lessons found. Lessons are captured when mistakes occur.";
+    case "recall":
+      return "No memories found. Use capture() or remember() to save context.";
+    case "list_plans":
+      return "No plans found. Use capture_plan() to create an implementation plan.";
+    case "list_events":
+      return "No events found. Events are captured as you work.";
+    case "list_tasks":
+      return "No tasks found. Use create_task() to add tasks.";
+    case "list_todos":
+      return "No todos found. Use create_todo() to add quick todos.";
+    case "list_diagrams":
+      return "No diagrams found. Use create_diagram() to save a Mermaid diagram.";
+    case "list_docs":
+      return "No docs found. Use create_doc() to save documentation.";
+    default:
+      return "No results found.";
+  }
 }
-var POST_COMPACT_HINTS = {
-  restored: "Picked up where you left off. Session ended, memory didn't.",
-  restored_with_session: (sessionId) => `Restored from session ${sessionId}. Session ended, memory didn't.`,
-  no_snapshot: "No prior session found. Fresh start\u2014context will build as you work.",
-  failed: "Couldn't restore previous session. Use context to retrieve what you need."
-};
-var PLAN_HINTS = {
-  created: "Plan saved. It will be here when you come back.",
-  activated: "Plan is now active. Track progress across sessions.",
-  completed: "Plan completed. The journey is preserved for future reference.",
-  abandoned: "Plan archived. Abandoned plans still teach.",
-  updated: "Plan updated. Changes are preserved."
-};
 function getPlanStatusHint(status) {
-  const statusMap = {
-    draft: PLAN_HINTS.created,
-    active: PLAN_HINTS.activated,
-    completed: PLAN_HINTS.completed,
-    abandoned: PLAN_HINTS.abandoned,
-    archived: PLAN_HINTS.abandoned
-  };
-  return statusMap[status] || PLAN_HINTS.updated;
+  switch (status) {
+    case "draft":
+      return "Plan saved as draft. Update status to 'active' when ready.";
+    case "active":
+      return "Plan is now active. Create tasks to track implementation.";
+    case "completed":
+      return "Plan completed. Great work!";
+    case "archived":
+      return "Plan archived. It will still appear in searches.";
+    case "abandoned":
+      return "Plan abandoned. Consider capturing lessons learned.";
+    default:
+      return "Plan updated. Changes are preserved.";
+  }
 }
-var TASK_HINTS = {
-  created: "Task tracked. It won't disappear when the chat does.",
-  completed: "Task done. Progress is preserved.",
-  blocked: "Task blocked. Capture what's blocking for future reference.",
-  cancelled: "Task cancelled. The history remains."
+var POST_COMPACT_HINTS = {
+  restored: "Context restored from pre-compaction snapshot.",
+  restored_with_session: (sessionId) => `Context restored from session ${sessionId.slice(0, 8)}... snapshot.`,
+  no_snapshot: "No snapshot found. Session state may be incomplete.",
+  failed: "Failed to restore context. Try recall() to find relevant memories."
 };
 var INTEGRATION_HINTS = {
-  not_connected: "Connect integrations to sync context where your team already works.",
-  slack: "Context from Slack conversations, connected.",
-  github: "Issues and PRs linked to the decisions behind them.",
-  notion: "Decisions synced to where your team documents."
+  connected: "Integration connected and syncing.",
+  not_connected: "Integration not connected. Connect at:",
+  sync_in_progress: "Sync in progress. Results may be incomplete.",
+  sync_complete: "Sync complete. All data is current."
+};
+var TASK_HINTS = {
+  created: "Task created. Use update_task() to change status.",
+  completed: "Task completed. Well done!",
+  blocked: "Task blocked. Add blocked_reason for context.",
+  linked_to_plan: "Task linked to plan. Progress will be tracked."
 };
-function hashString(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return hash;
-}
 
 // src/tools.ts
 var LOG_LEVEL = (process.env.CONTEXTSTREAM_LOG_LEVEL || "normal").toLowerCase();
@@ -13985,9 +15920,9 @@ function humanizeKey(raw) {
   const withSpaces = raw.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ");
   return withSpaces.toLowerCase();
 }
-function buildParamDescription(key, path13) {
+function buildParamDescription(key, path21) {
   const normalized = key in DEFAULT_PARAM_DESCRIPTIONS ? key : key.toLowerCase();
-  const parent = path13[path13.length - 1];
+  const parent = path21[path21.length - 1];
   if (parent === "target") {
     if (key === "id") return "Target identifier (module path, function id, etc.).";
     if (key === "type") return "Target type (module, file, function, type, variable).";
@@ -14018,7 +15953,7 @@ function getDescription(schema) {
   if (def?.description && def.description.trim()) return def.description;
   return void 0;
 }
-function applyParamDescriptions(schema, path13 = []) {
+function applyParamDescriptions(schema, path21 = []) {
   if (!(schema instanceof external_exports.ZodObject)) {
     return schema;
   }
@@ -14029,7 +15964,7 @@ function applyParamDescriptions(schema, path13 = []) {
     let nextField = field;
     const existingDescription = getDescription(field);
     if (field instanceof external_exports.ZodObject) {
-      const nested = applyParamDescriptions(field, [...path13, key]);
+      const nested = applyParamDescriptions(field, [...path21, key]);
       if (nested !== field) {
         nextField = nested;
         changed = true;
@@ -14041,7 +15976,7 @@ function applyParamDescriptions(schema, path13 = []) {
         changed = true;
       }
     } else {
-      nextField = nextField.describe(buildParamDescription(key, path13));
+      nextField = nextField.describe(buildParamDescription(key, path21));
       changed = true;
     }
     nextShape[key] = nextField;
@@ -14880,7 +16815,10 @@ function registerTools(server, client, sessionManager) {
     "notion_stats",
     "notion_activity",
     "notion_knowledge",
-    "notion_summary"
+    "notion_summary",
+    // Media operations (credit-metered)
+    "media_index",
+    "media_search"
   ]);
   const proTools = (() => {
     const raw = process.env.CONTEXTSTREAM_PRO_TOOLS;
@@ -14958,10 +16896,12 @@ function registerTools(server, client, sessionManager) {
   function isTeamPlanCached() {
     return teamStatus.checked ? teamStatus.isTeamPlan : false;
   }
-  let integrationStatus = { checked: false, slack: false, github: false, notion: false };
+  const INTEGRATION_CACHE_TTL_MS = 5 * 60 * 1e3;
+  let integrationStatus = { checked: false, checkedAt: 0, slack: false, github: false, notion: false };
   let toolsListChangedNotified = false;
   async function checkIntegrationStatus(workspaceId) {
-    if (integrationStatus.checked && integrationStatus.workspaceId === workspaceId) {
+    const cacheAge = Date.now() - integrationStatus.checkedAt;
+    if (integrationStatus.checked && integrationStatus.workspaceId === workspaceId && cacheAge < INTEGRATION_CACHE_TTL_MS) {
       return { slack: integrationStatus.slack, github: integrationStatus.github, notion: integrationStatus.notion };
     }
     if (!workspaceId) {
@@ -14969,17 +16909,19 @@ function registerTools(server, client, sessionManager) {
     }
     try {
       const status = await client.integrationsStatus({ workspace_id: workspaceId });
+      const isConnectedStatus = (s) => s === "connected" || s === "syncing";
       const slackConnected = status?.some(
-        (s) => s.provider === "slack" && s.status === "connected"
+        (s) => s.provider === "slack" && isConnectedStatus(s.status)
       ) ?? false;
       const githubConnected = status?.some(
-        (s) => s.provider === "github" && s.status === "connected"
+        (s) => s.provider === "github" && isConnectedStatus(s.status)
       ) ?? false;
       const notionConnected = status?.some(
-        (s) => s.provider === "notion" && s.status === "connected"
+        (s) => s.provider === "notion" && isConnectedStatus(s.status)
       ) ?? false;
       integrationStatus = {
         checked: true,
+        checkedAt: Date.now(),
         slack: slackConnected,
         github: githubConnected,
         notion: notionConnected,
@@ -14998,6 +16940,7 @@ function registerTools(server, client, sessionManager) {
     const hadNotion = integrationStatus.notion;
     integrationStatus = {
       checked: true,
+      checkedAt: Date.now(),
       slack: status.slack,
       github: status.github,
       notion: status.notion,
@@ -18577,7 +20520,10 @@ This saves ~80% tokens compared to including full chat history.`,
         mode: external_exports.enum(["standard", "pack"]).optional().describe("Context pack mode (default: pack when enabled)"),
         distill: external_exports.boolean().optional().describe("Use distillation for context pack (default: true)"),
         session_tokens: external_exports.number().optional().describe("Cumulative session token count for context pressure calculation"),
-        context_threshold: external_exports.number().optional().describe("Custom context window threshold (defaults to 70k)")
+        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')")
       })
     },
     async (input) => {
@@ -18653,6 +20599,14 @@ This saves ~80% tokens compared to including full chat history.`,
           logDebug(`Failed to restore post-compact context: ${err}`);
         }
       }
+      let sessionId = input.session_id;
+      if (!sessionId && sessionManager && input.save_exchange) {
+        sessionId = sessionManager.getSessionId();
+      }
+      let clientName = input.client_name;
+      if (!clientName && detectedClientInfo) {
+        clientName = detectedClientInfo.name;
+      }
       const result = await client.getSmartContext({
         user_message: input.user_message,
         workspace_id: workspaceId,
@@ -18662,7 +20616,10 @@ This saves ~80% tokens compared to including full chat history.`,
         mode: input.mode,
         distill: input.distill,
         session_tokens: sessionTokens,
-        context_threshold: contextThreshold
+        context_threshold: contextThreshold,
+        save_exchange: input.save_exchange,
+        session_id: sessionId,
+        client_name: clientName
       });
       if (sessionManager && result.token_estimate) {
         sessionManager.addTokens(result.token_estimate);
@@ -19597,14 +21554,15 @@ Use this to verify integrations are healthy and syncing properly.`,
       }
       const result = await client.integrationsStatus({ workspace_id: workspaceId });
       if (AUTO_HIDE_INTEGRATIONS) {
+        const isConnectedStatus = (s) => s === "connected" || s === "syncing";
         const slackConnected = result?.some(
-          (s) => s.provider === "slack" && s.status === "connected"
+          (s) => s.provider === "slack" && isConnectedStatus(s.status)
         ) ?? false;
         const githubConnected = result?.some(
-          (s) => s.provider === "github" && s.status === "connected"
+          (s) => s.provider === "github" && isConnectedStatus(s.status)
         ) ?? false;
         const notionConnected = result?.some(
-          (s) => s.provider === "notion" && s.status === "connected"
+          (s) => s.provider === "notion" && isConnectedStatus(s.status)
         ) ?? false;
         updateIntegrationStatus({ slack: slackConnected, github: githubConnected, notion: notionConnected }, workspaceId);
       }
@@ -19959,7 +21917,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       "session",
       {
         title: "Session",
-        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance), restore_context (restore state after compaction). Plan actions: capture_plan (save implementation plan), get_plan (retrieve plan with tasks), update_plan (modify plan), list_plans (list all plans). Team actions (team plans only): team_decisions (team-wide decisions), team_lessons (team-wide lessons), team_plans (plans across team workspaces).`,
+        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance), restore_context (restore state after compaction). Plan actions: capture_plan (save implementation plan), get_plan (retrieve plan with tasks), update_plan (modify plan), list_plans (list all plans). Suggested rules actions: list_suggested_rules (view ML-generated rule suggestions), suggested_rule_action (accept/reject/modify a suggestion), suggested_rules_stats (view ML accuracy stats). Team actions (team plans only): team_decisions (team-wide decisions), team_lessons (team-wide lessons), team_plans (plans across team workspaces).`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "capture",
@@ -19983,7 +21941,11 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             // Team actions (team plans only)
             "team_decisions",
             "team_lessons",
-            "team_plans"
+            "team_plans",
+            // Suggested rules actions (ML-generated)
+            "list_suggested_rules",
+            "suggested_rule_action",
+            "suggested_rules_stats"
           ]).describe("Action to perform"),
           workspace_id: external_exports.string().uuid().optional(),
           project_id: external_exports.string().uuid().optional(),
@@ -20060,7 +22022,13 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           is_personal: external_exports.boolean().optional().describe("Mark plan as personal (only visible to creator). For capture_plan/list_plans."),
           // Restore context params
           snapshot_id: external_exports.string().uuid().optional().describe("Specific snapshot ID to restore (defaults to most recent)"),
-          max_snapshots: external_exports.number().optional().default(1).describe("Number of recent snapshots to consider (default: 1)")
+          max_snapshots: external_exports.number().optional().default(1).describe("Number of recent snapshots to consider (default: 1)"),
+          // Suggested rules params
+          rule_id: external_exports.string().uuid().optional().describe("Suggested rule ID for actions"),
+          rule_action: external_exports.enum(["accept", "reject", "modify"]).optional().describe("Action to perform on suggested rule"),
+          modified_keywords: external_exports.array(external_exports.string()).optional().describe("Modified keywords when action is modify"),
+          modified_instruction: external_exports.string().optional().describe("Modified instruction when action is modify"),
+          min_confidence: external_exports.number().optional().describe("Minimum confidence threshold for listing rules")
         })
       },
       async (input) => {
@@ -20636,6 +22604,81 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               ]
             };
           }
+          case "list_suggested_rules": {
+            const result = await client.listSuggestedRules({
+              workspace_id: workspaceId,
+              status: input.status,
+              min_confidence: input.min_confidence,
+              limit: input.limit
+            });
+            const rules = result?.data?.items || result?.items || [];
+            if (rules.length === 0) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: formatContent({
+                      suggested_rules: [],
+                      hint: "No pending rule suggestions. The ML system learns from your lessons and will suggest rules when patterns are detected."
+                    })
+                  }
+                ]
+              };
+            }
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatContent({
+                    suggested_rules: rules,
+                    total: result?.data?.total || rules.length,
+                    hint: "Use suggested_rule_action to accept, reject, or modify these suggestions."
+                  })
+                }
+              ]
+            };
+          }
+          case "suggested_rule_action": {
+            if (!input.rule_id || !input.rule_action) {
+              return errorResult("suggested_rule_action requires: rule_id, rule_action (accept/reject/modify)");
+            }
+            const result = await client.suggestedRuleAction({
+              rule_id: input.rule_id,
+              action: input.rule_action,
+              modified_keywords: input.modified_keywords,
+              modified_instruction: input.modified_instruction
+            });
+            const actionVerb = input.rule_action === "accept" ? "accepted" : input.rule_action === "reject" ? "rejected" : "modified";
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatContent({
+                    success: true,
+                    message: `Rule ${actionVerb} successfully`,
+                    rule: result?.data || result,
+                    hint: input.rule_action === "accept" ? "This rule will now be applied to future context() calls." : input.rule_action === "reject" ? "This pattern will have reduced confidence for future suggestions." : "The modified rule will be applied to future context() calls."
+                  })
+                }
+              ]
+            };
+          }
+          case "suggested_rules_stats": {
+            const result = await client.getSuggestedRulesStats({
+              workspace_id: workspaceId
+            });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatContent({
+                    stats: result?.data || result,
+                    hint: "These stats show ML vs Grok accuracy. The blend weight auto-adjusts based on these metrics."
+                  })
+                }
+              ]
+            };
+          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }
@@ -20645,7 +22688,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       "memory",
       {
         title: "Memory",
-        description: `Memory operations for events and nodes. Event actions: create_event, get_event, update_event, delete_event, list_events, distill_event, import_batch (bulk import array of events). Node actions: create_node, get_node, update_node, delete_node, list_nodes, supersede_node. Query actions: search, decisions, timeline, summary. Task actions: create_task (create task, optionally linked to plan), get_task, update_task (can link/unlink task to plan via plan_id), delete_task, list_tasks, reorder_tasks. Todo actions: create_todo, list_todos, get_todo, update_todo, delete_todo, complete_todo. Diagram actions: create_diagram, list_diagrams, get_diagram, update_diagram, delete_diagram. Doc actions: create_doc, list_docs, get_doc, update_doc, delete_doc, create_roadmap. Team actions (team plans only): team_tasks, team_todos, team_diagrams, team_docs.`,
+        description: `Memory operations for events and nodes. Event actions: create_event, get_event, update_event, delete_event, list_events, distill_event, import_batch (bulk import array of events). Node actions: create_node, get_node, update_node, delete_node, list_nodes, supersede_node. Query actions: search, decisions, timeline, summary. Task actions: create_task (create task, optionally linked to plan), get_task, update_task (can link/unlink task to plan via plan_id), delete_task, list_tasks, reorder_tasks. Todo actions: create_todo, list_todos, get_todo, update_todo, delete_todo, complete_todo. Diagram actions: create_diagram, list_diagrams, get_diagram, update_diagram, delete_diagram. Doc actions: create_doc, list_docs, get_doc, update_doc, delete_doc, create_roadmap. Transcript actions: list_transcripts (list saved conversations), get_transcript (get full transcript by ID), search_transcripts (semantic search across conversations), delete_transcript. Team actions (team plans only): team_tasks, team_todos, team_diagrams, team_docs.`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "create_event",
@@ -20693,6 +22736,11 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "update_doc",
             "delete_doc",
             "create_roadmap",
+            // Transcript actions
+            "list_transcripts",
+            "get_transcript",
+            "search_transcripts",
+            "delete_transcript",
             // Team actions
             "team_tasks",
             "team_todos",
@@ -20798,7 +22846,13 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             })
           ).optional().describe("Milestones for create_roadmap action"),
           // Personal items param
-          is_personal: external_exports.boolean().optional().describe("Mark as personal (only visible to creator). For create/list actions on todos, diagrams, docs.")
+          is_personal: external_exports.boolean().optional().describe("Mark as personal (only visible to creator). For create/list actions on todos, diagrams, docs."),
+          // Transcript params
+          transcript_id: external_exports.string().uuid().optional().describe("Transcript ID for get_transcript/delete_transcript"),
+          session_id: external_exports.string().optional().describe("Session ID filter for list_transcripts"),
+          client_name: external_exports.string().optional().describe("Client name filter for list_transcripts (e.g., 'claude', 'cursor')"),
+          started_after: external_exports.string().optional().describe("ISO timestamp - filter transcripts started after this time"),
+          started_before: external_exports.string().optional().describe("ISO timestamp - filter transcripts started before this time")
         })
       },
       async (input) => {
@@ -21572,6 +23626,54 @@ ${formatContent(result)}`
               ]
             };
           }
+          // Transcript actions
+          case "list_transcripts": {
+            const result = await client.listTranscripts({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              session_id: input.session_id,
+              client_name: input.client_name,
+              started_after: input.started_after,
+              started_before: input.started_before,
+              limit: input.limit
+            });
+            const transcripts = result?.data?.items || result?.items || result?.data || [];
+            const resultWithHint = Array.isArray(transcripts) && transcripts.length === 0 ? { ...result, hint: "No transcripts found. Enable save_exchange in context() calls to save conversations." } : result;
+            return {
+              content: [{ type: "text", text: formatContent(resultWithHint) }]
+            };
+          }
+          case "get_transcript": {
+            if (!input.transcript_id) {
+              return errorResult("get_transcript requires: transcript_id");
+            }
+            const result = await client.getTranscript(input.transcript_id);
+            return {
+              content: [{ type: "text", text: formatContent(result) }]
+            };
+          }
+          case "search_transcripts": {
+            if (!input.query) {
+              return errorResult("search_transcripts requires: query");
+            }
+            const result = await client.searchTranscripts({
+              workspace_id: workspaceId,
+              query: input.query,
+              limit: input.limit
+            });
+            return {
+              content: [{ type: "text", text: formatContent(result) }]
+            };
+          }
+          case "delete_transcript": {
+            if (!input.transcript_id) {
+              return errorResult("delete_transcript requires: transcript_id");
+            }
+            const result = await client.deleteTranscript(input.transcript_id);
+            return {
+              content: [{ type: "text", text: formatContent(result) }]
+            };
+          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }
@@ -22860,6 +24962,8 @@ Example workflow:
         const projectId = resolveProjectId(input.project_id);
         switch (input.action) {
           case "index": {
+            const indexGate = await gateIfProTool("media_index");
+            if (indexGate) return indexGate;
             if (!input.file_path && !input.external_url) {
               return errorResult("index requires: file_path or external_url");
             }
@@ -22869,13 +24973,13 @@ Example workflow:
               );
             }
             if (input.file_path) {
-              const fs12 = await import("fs/promises");
+              const fs20 = await import("fs/promises");
               const pathModule = await import("path");
               const filePath = input.file_path.startsWith("~") ? input.file_path.replace("~", process.env.HOME || "") : input.file_path;
               const resolvedPath = pathModule.resolve(filePath);
               let fileStats;
               try {
-                fileStats = await fs12.stat(resolvedPath);
+                fileStats = await fs20.stat(resolvedPath);
               } catch {
                 return errorResult(`File not found: ${resolvedPath}`);
               }
@@ -22922,7 +25026,7 @@ Example workflow:
                   mime_type: mimeType,
                   tags: input.tags
                 });
-                const fileBuffer = await fs12.readFile(resolvedPath);
+                const fileBuffer = await fs20.readFile(resolvedPath);
                 const uploadResponse = await fetch(uploadInit.upload_url, {
                   method: "PUT",
                   headers: uploadInit.headers,
@@ -23024,6 +25128,8 @@ Created: ${content.created_at}`
             }
           }
           case "search": {
+            const searchGate = await gateIfProTool("media_search");
+            if (searchGate) return searchGate;
             if (!input.query) {
               return errorResult("search requires: query");
             }
@@ -24244,6 +26350,7 @@ function registerPrompts(server) {
 }
 
 // src/session-manager.ts
+import { randomUUID as randomUUID2 } from "crypto";
 var SessionManager = class _SessionManager {
   constructor(server, client) {
     this.server = server;
@@ -24275,12 +26382,20 @@ var SessionManager = class _SessionManager {
     this.lastHighPressureAt = null;
     this.lastHighPressureTokens = 0;
     this.postCompactRestoreCompleted = false;
+    this.sessionId = `mcp-${randomUUID2()}`;
   }
   static {
     // Each conversation turn typically includes: user message (~500), AI response (~1500),
     // system prompt overhead (~500), and reasoning (~1500). Conservative estimate: 3000/turn
     this.TOKENS_PER_TURN_ESTIMATE = 3e3;
   }
+  /**
+   * Get the unique session ID for this MCP connection.
+   * Used for transcript saving and session association.
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
   /**
    * Check if session has been auto-initialized
    */
@@ -24318,8 +26433,8 @@ var SessionManager = class _SessionManager {
   /**
    * Set the folder path hint (can be passed from tools that know the workspace path)
    */
-  setFolderPath(path13) {
-    this.folderPath = path13;
+  setFolderPath(path21) {
+    this.folderPath = path21;
   }
   /**
    * Mark that context_smart has been called in this session.
@@ -24509,7 +26624,7 @@ var SessionManager = class _SessionManager {
     }
     if (this.ideRoots.length === 0) {
       const cwd = process.cwd();
-      const fs12 = await import("fs");
+      const fs20 = await import("fs");
       const projectIndicators = [
         ".git",
         "package.json",
@@ -24519,7 +26634,7 @@ var SessionManager = class _SessionManager {
       ];
       const hasProjectIndicator = projectIndicators.some((f) => {
         try {
-          return fs12.existsSync(`${cwd}/${f}`);
+          return fs20.existsSync(`${cwd}/${f}`);
         } catch {
           return false;
         }
@@ -24815,7 +26930,7 @@ var SessionManager = class _SessionManager {
 
 // src/http-gateway.ts
 import { createServer } from "node:http";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 var HOST = process.env.MCP_HTTP_HOST || "0.0.0.0";
@@ -24992,7 +27107,7 @@ async function createSession() {
     registerPrompts(server);
   }
   const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: () => randomUUID2(),
+    sessionIdGenerator: () => randomUUID3(),
     enableJsonResponse: ENABLE_JSON_RESPONSE,
     onsessionclosed: (sessionId) => {
       sessions.delete(sessionId);
@@ -25096,9 +27211,9 @@ async function runHttpGateway() {
 }
 
 // src/index.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir18 } from "os";
+import { join as join22 } from "path";
 
 // src/setup.ts
 import * as fs7 from "node:fs/promises";
@@ -25928,10 +28043,10 @@ Code: ${device.user_code}`);
           if (poll && poll.status === "pending") {
             const intervalSeconds = typeof poll.interval === "number" ? poll.interval : 5;
             const waitMs = Math.max(1, intervalSeconds) * 1e3;
-            await new Promise((resolve8) => setTimeout(resolve8, waitMs));
+            await new Promise((resolve15) => setTimeout(resolve15, waitMs));
             continue;
           }
-          await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+          await new Promise((resolve15) => setTimeout(resolve15, 1e3));
         }
         if (!accessToken) {
           throw new Error(
@@ -26496,12 +28611,12 @@ Applying to ${projects.length} project(s)...`);
 // src/index.ts
 var ENABLE_PROMPTS2 = (process.env.CONTEXTSTREAM_ENABLE_PROMPTS || "true").toLowerCase() !== "false";
 function showFirstRunMessage() {
-  const configDir = join14(homedir10(), ".contextstream");
-  const starShownFile = join14(configDir, ".star-shown");
-  if (existsSync8(starShownFile)) {
+  const configDir = join22(homedir18(), ".contextstream");
+  const starShownFile = join22(configDir, ".star-shown");
+  if (existsSync16(starShownFile)) {
     return;
   }
-  if (!existsSync8(configDir)) {
+  if (!existsSync16(configDir)) {
     try {
       mkdirSync5(configDir, { recursive: true });
     } catch {
@@ -26532,13 +28647,26 @@ Usage:
 
 Commands:
   setup                      Interactive onboarding wizard (rules + workspace mapping)
+  verify-key [--json]        Verify API key and show account info
+  update-hooks [flags]       Update hooks for all editors (Claude, Cursor, Cline, Roo, Kilo)
+    --scope=global           Install hooks globally (default)
+    --scope=project, -p      Install hooks for current project only
+    --path=/path             Specify project path (implies --scope=project)
   http                       Run HTTP MCP gateway (streamable HTTP transport)
   hook pre-tool-use          PreToolUse hook - blocks discovery tools, redirects to ContextStream
   hook user-prompt-submit    UserPromptSubmit hook - injects ContextStream rules reminder
   hook media-aware           Media-aware hook - detects media prompts, injects media tool guidance
   hook pre-compact           PreCompact hook - saves conversation state before compaction
+  hook post-compact          PostCompact hook - restores context after compaction
   hook post-write            PostToolUse hook - real-time file indexing after Edit/Write
   hook auto-rules            PostToolUse hook - auto-updates rules when behind (silent)
+  hook on-bash               PostToolUse hook - captures bash commands, learns from errors
+  hook on-task               PostToolUse hook - tracks Task agent work
+  hook on-read               PostToolUse hook - tracks file exploration (Read/Glob/Grep)
+  hook on-web                PostToolUse hook - captures web research (WebFetch/WebSearch)
+  hook session-init          SessionStart hook - full context injection on session start
+  hook session-end           Stop hook - finalizes session, saves state
+  hook on-save-intent        UserPromptSubmit hook - redirects doc saves to ContextStream
 
 Environment variables:
   CONTEXTSTREAM_API_URL   Base API URL (e.g. https://api.contextstream.io)
@@ -26647,12 +28775,90 @@ async function main() {
         await runAutoRulesHook2();
         return;
       }
+      case "post-compact": {
+        const { runPostCompactHook: runPostCompactHook2 } = await Promise.resolve().then(() => (init_post_compact(), post_compact_exports));
+        await runPostCompactHook2();
+        return;
+      }
+      case "on-bash": {
+        const { runOnBashHook: runOnBashHook2 } = await Promise.resolve().then(() => (init_on_bash(), on_bash_exports));
+        await runOnBashHook2();
+        return;
+      }
+      case "on-task": {
+        const { runOnTaskHook: runOnTaskHook2 } = await Promise.resolve().then(() => (init_on_task(), on_task_exports));
+        await runOnTaskHook2();
+        return;
+      }
+      case "on-read": {
+        const { runOnReadHook: runOnReadHook2 } = await Promise.resolve().then(() => (init_on_read(), on_read_exports));
+        await runOnReadHook2();
+        return;
+      }
+      case "on-web": {
+        const { runOnWebHook: runOnWebHook2 } = await Promise.resolve().then(() => (init_on_web(), on_web_exports));
+        await runOnWebHook2();
+        return;
+      }
+      case "session-init": {
+        const { runSessionInitHook: runSessionInitHook2 } = await Promise.resolve().then(() => (init_session_init(), session_init_exports));
+        await runSessionInitHook2();
+        return;
+      }
+      case "session-end": {
+        const { runSessionEndHook: runSessionEndHook2 } = await Promise.resolve().then(() => (init_session_end(), session_end_exports));
+        await runSessionEndHook2();
+        return;
+      }
+      case "on-save-intent": {
+        const { runOnSaveIntentHook: runOnSaveIntentHook2 } = await Promise.resolve().then(() => (init_on_save_intent(), on_save_intent_exports));
+        await runOnSaveIntentHook2();
+        return;
+      }
       default:
         console.error(`Unknown hook: ${hookName}`);
-        console.error("Available hooks: pre-tool-use, user-prompt-submit, media-aware, pre-compact, post-write, auto-rules");
+        console.error("Available hooks: pre-tool-use, user-prompt-submit, media-aware, pre-compact, post-compact, post-write, auto-rules, on-bash, on-task, on-read, on-web, session-init, session-end, on-save-intent");
         process.exit(1);
     }
   }
+  if (args[0] === "verify-key") {
+    const { runVerifyKey: runVerifyKey2 } = await Promise.resolve().then(() => (init_verify_key(), verify_key_exports));
+    const outputJson = args.includes("--json");
+    const result = await runVerifyKey2(outputJson);
+    process.exit(result.valid ? 0 : 1);
+  }
+  if (args[0] === "update-hooks") {
+    const { installAllEditorHooks: installAllEditorHooks2 } = await Promise.resolve().then(() => (init_hooks_config(), hooks_config_exports));
+    let scope = "global";
+    let projectPath;
+    for (const arg of args.slice(1)) {
+      if (arg === "--scope=project" || arg === "-p") {
+        scope = "project";
+        projectPath = projectPath || process.cwd();
+      } else if (arg === "--scope=global" || arg === "-g") {
+        scope = "global";
+      } else if (arg.startsWith("--path=")) {
+        projectPath = arg.replace("--path=", "");
+        scope = "project";
+      }
+    }
+    const scopeLabel = scope === "project" ? `project (${projectPath || process.cwd()})` : "global";
+    console.error(`Updating hooks for all editors (${scopeLabel})...`);
+    try {
+      const results = await installAllEditorHooks2({
+        scope,
+        projectPath: scope === "project" ? projectPath || process.cwd() : void 0
+      });
+      for (const result of results) {
+        console.error(`\u2713 ${result.editor}: ${result.installed.length} hooks installed`);
+      }
+      console.error("\u2713 Hooks updated successfully");
+    } catch (error) {
+      console.error("Failed to update hooks:", error);
+      process.exit(1);
+    }
+    return;
+  }
   if (!process.env.CONTEXTSTREAM_API_KEY && !process.env.CONTEXTSTREAM_JWT) {
     const saved = await readSavedCredentials();
     if (saved) {