@contextstream/mcp-server 0.4.50 → 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
@@ -3154,35 +3259,1274 @@ function hasPythonHooks(settingsPath) {
         }
       }
     }
-    return false;
+    return false;
+  } catch {
+    return false;
+  }
+}
+function detectPythonHooks(cwd) {
+  const globalSettingsPath = path12.join(homedir9(), ".claude", "settings.json");
+  const projectSettingsPath = path12.join(cwd, ".claude", "settings.json");
+  return {
+    global: hasPythonHooks(globalSettingsPath),
+    project: hasPythonHooks(projectSettingsPath)
+  };
+}
+async function upgradeHooksForFolder(folderPath) {
+  const { installClaudeCodeHooks: installClaudeCodeHooks3 } = await Promise.resolve().then(() => (init_hooks_config(), hooks_config_exports));
+  await installClaudeCodeHooks3({
+    scope: "both",
+    projectPath: folderPath,
+    includePreCompact: true,
+    includeMediaAware: true,
+    includePostWrite: true,
+    includeAutoRules: true
+  });
+}
+async function runAutoRulesHook() {
+  if (!ENABLED6) {
+    process.exit(0);
+  }
+  if (hasRunRecently()) {
+    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 || 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 false;
   }
+  return stats;
 }
-function detectPythonHooks(cwd) {
-  const globalSettingsPath = path12.join(homedir9(), ".claude", "settings.json");
-  const projectSettingsPath = path12.join(cwd, ".claude", "settings.json");
-  return {
-    global: hasPythonHooks(globalSettingsPath),
-    project: hasPythonHooks(projectSettingsPath)
+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
   };
-}
-async function upgradeHooksForFolder(folderPath) {
-  const { installClaudeCodeHooks: installClaudeCodeHooks3 } = await Promise.resolve().then(() => (init_hooks_config(), hooks_config_exports));
-  await installClaudeCodeHooks3({
-    scope: "both",
-    projectPath: folderPath,
-    includePreCompact: true,
-    includeMediaAware: true,
-    includePostWrite: true,
-    includeAutoRules: true
-  });
-}
-async function runAutoRulesHook() {
-  if (!ENABLED6) {
-    process.exit(0);
+  if (WORKSPACE_ID8) {
+    payload.workspace_id = WORKSPACE_ID8;
   }
-  if (hasRunRecently()) {
+  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 = "";
@@ -3198,40 +4542,444 @@ async function runAutoRulesHook() {
   } 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) {
+  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);
   }
-  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) {
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
     process.exit(0);
   }
-  const folderPath = rulesNotice?.update_args?.folder_path || cwd;
+  let input;
   try {
-    await upgradeHooksForFolder(folderPath);
-    markAsRan();
+    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 API_URL3, API_KEY3, ENABLED6, MARKER_FILE, COOLDOWN_MS, isDirectRun6;
-var init_auto_rules = __esm({
-  "src/hooks/auto-rules.ts"() {
+var ENABLED14, SAVE_PATTERNS, LOCAL_FILE_PATTERNS, SAVE_GUIDANCE, isDirectRun14;
+var init_on_save_intent = __esm({
+  "src/hooks/on-save-intent.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));
+    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 {
+    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)}`
+    };
+  }
+}
+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 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("");
+  }
+  return result;
+}
+var init_verify_key = __esm({
+  "src/verify-key.ts"() {
+    "use strict";
   }
 });
 
@@ -3717,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
@@ -3834,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() {
@@ -7288,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");
@@ -7571,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;
@@ -7724,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) {
@@ -8379,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"
     );
@@ -8390,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;
         }
@@ -10457,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) {
@@ -14169,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).";
@@ -14202,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;
   }
@@ -14213,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;
@@ -14225,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;
@@ -15145,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) {
@@ -15156,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,
@@ -15185,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,
@@ -19798,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);
       }
@@ -23216,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}`);
               }
@@ -23269,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,
@@ -24676,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.
@@ -24867,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",
@@ -24877,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;
         }
@@ -25454,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";
@@ -26286,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(
@@ -26854,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 {
@@ -26890,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)
@@ -27005,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) {