@contextstream/mcp-server 0.4.50 → 0.4.53

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(path22, 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(path22);
           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 = (path22, originalPath, doThrow) => {
+      if (!isString(path22)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path13) {
+      if (!path22) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path13)) {
+      if (checkPath.isNotRelative(path22)) {
         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 = (path22) => REGEX_TEST_INVALID_PATH.test(path22);
     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 path22 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path13,
+          path22,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path13, cache, checkUnignored, slices);
+        return this._t(path22, cache, checkUnignored, slices);
       }
-      checkIgnore(path13) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path13)) {
-          return this.test(path13);
+      checkIgnore(path22) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path22)) {
+          return this.test(path22);
         }
-        const slices = path13.split(SLASH).filter(Boolean);
+        const slices = path22.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(path22, false, MODE_CHECK_IGNORE);
       }
-      _t(path13, cache, checkUnignored, slices) {
-        if (path13 in cache) {
-          return cache[path13];
+      _t(path22, cache, checkUnignored, slices) {
+        if (path22 in cache) {
+          return cache[path22];
         }
         if (!slices) {
-          slices = path13.split(SLASH).filter(Boolean);
+          slices = path22.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path13] = this._rules.test(path13, checkUnignored, MODE_IGNORE);
+          return cache[path22] = this._rules.test(path22, 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[path22] = parent.ignored ? parent : this._rules.test(path22, checkUnignored, MODE_IGNORE);
       }
-      ignores(path13) {
-        return this._test(path13, this._ignoreCache, false).ignored;
+      ignores(path22) {
+        return this._test(path22, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path13) => !this.ignores(path13);
+        return (path22) => !this.ignores(path22);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path13) {
-        return this._test(path13, this._testCache, true);
+      test(path22) {
+        return this._test(path22, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path13) => checkPath(path13 && checkPath.convert(path13), path13, RETURN_FALSE);
+    var isPathValid = (path22) => checkPath(path22 && checkPath.convert(path22), path22, 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 = (path22) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path22) || isNotRelative(path22);
     };
     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,23 @@ __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) {
+  const fs21 = __require("node:fs");
+  const binaryPath = "/usr/local/bin/contextstream-mcp";
+  if (fs21.existsSync(binaryPath)) {
+    return `${binaryPath} hook ${hookName}`;
+  }
+  try {
+    const __dirname = path5.dirname(fileURLToPath(import.meta.url));
+    const indexPath = path5.join(__dirname, "index.js");
+    if (fs21.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 +576,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 +613,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 +624,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 +670,7 @@ function buildHooksConfig(options) {
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook post-write",
+          command: getHookCommand("post-write"),
           timeout: 10
         }
       ]
@@ -625,12 +682,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 +745,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 +791,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 +1082,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 +1091,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 +1100,7 @@ async function installCursorHookScripts(options) {
       beforeSubmitPrompt: [
         ...filteredBeforeSubmit,
         {
-          command: "npx @contextstream/mcp-server hook user-prompt-submit",
+          command: userPromptCommand,
           type: "command",
           timeout: 5
         }
@@ -1003,8 +1110,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 +1920,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
@@ -2409,8 +2518,17 @@ function extractToolInput(input) {
   return input.tool_input || input.parameters || input.toolParameters || {};
 }
 function blockClaudeCode(message) {
-  console.error(message);
-  process.exit(2);
+  const response = {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      // Use additionalContext instead of deny - tool runs but Claude sees the message
+      additionalContext: `[CONTEXTSTREAM] ${message}`
+    }
+  };
+  fs9.appendFileSync(DEBUG_FILE, `[PreToolUse] REDIRECT (additionalContext): ${JSON.stringify(response)}
+`);
+  console.log(JSON.stringify(response));
+  process.exit(0);
 }
 function outputClineBlock(errorMessage, contextMod) {
   const result = {
@@ -2439,13 +2557,18 @@ function detectEditorFormat(input) {
   if (input.hookName !== void 0 || input.toolName !== void 0) {
     return "cline";
   }
-  if (input.hook_event_name !== void 0) {
-    return "cursor";
+  if (input.hook_event_name !== void 0 || input.tool_name !== void 0) {
+    return "claude";
   }
   return "claude";
 }
 async function runPreToolUseHook() {
+  fs9.appendFileSync(DEBUG_FILE, `[PreToolUse] Hook invoked at ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+  console.error("[PreToolUse] Hook invoked at", (/* @__PURE__ */ new Date()).toISOString());
   if (!ENABLED2) {
+    fs9.appendFileSync(DEBUG_FILE, "[PreToolUse] Hook disabled, exiting\n");
+    console.error("[PreToolUse] Hook disabled, exiting");
     process.exit(0);
   }
   let inputData = "";
@@ -2465,8 +2588,14 @@ async function runPreToolUseHook() {
   const cwd = extractCwd2(input);
   const tool = extractToolName(input);
   const toolInput = extractToolInput(input);
+  fs9.appendFileSync(DEBUG_FILE, `[PreToolUse] tool=${tool}, cwd=${cwd}, editorFormat=${editorFormat}
+`);
   const { isIndexed } = isProjectIndexed(cwd);
+  fs9.appendFileSync(DEBUG_FILE, `[PreToolUse] isIndexed=${isIndexed}
+`);
   if (!isIndexed) {
+    fs9.appendFileSync(DEBUG_FILE, `[PreToolUse] Project not indexed, allowing
+`);
     if (editorFormat === "cline") {
       outputClineAllow();
     } else if (editorFormat === "cursor") {
@@ -2476,8 +2605,12 @@ async function runPreToolUseHook() {
   }
   if (tool === "Glob") {
     const pattern = toolInput?.pattern || "";
+    fs9.appendFileSync(DEBUG_FILE, `[PreToolUse] Glob pattern=${pattern}, isDiscovery=${isDiscoveryGlob(pattern)}
+`);
     if (isDiscoveryGlob(pattern)) {
       const msg = `STOP: Use mcp__contextstream__search(mode="hybrid", query="${pattern}") instead of Glob.`;
+      fs9.appendFileSync(DEBUG_FILE, `[PreToolUse] Intercepting discovery glob: ${msg}
+`);
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
       } else if (editorFormat === "cursor") {
@@ -2554,12 +2687,13 @@ async function runPreToolUseHook() {
   }
   process.exit(0);
 }
-var ENABLED2, INDEX_STATUS_FILE, STALE_THRESHOLD_DAYS, DISCOVERY_PATTERNS, isDirectRun2;
+var ENABLED2, INDEX_STATUS_FILE, DEBUG_FILE, STALE_THRESHOLD_DAYS, DISCOVERY_PATTERNS, isDirectRun2;
 var init_pre_tool_use = __esm({
   "src/hooks/pre-tool-use.ts"() {
     "use strict";
     ENABLED2 = process.env.CONTEXTSTREAM_HOOK_ENABLED !== "false";
     INDEX_STATUS_FILE = path10.join(homedir7(), ".contextstream", "indexed-projects.json");
+    DEBUG_FILE = "/tmp/pretooluse-hook-debug.log";
     STALE_THRESHOLD_DAYS = 7;
     DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"];
     isDirectRun2 = process.argv[1]?.includes("pre-tool-use") || process.argv[2] === "pre-tool-use";
@@ -2574,6 +2708,184 @@ var user_prompt_submit_exports = {};
 __export(user_prompt_submit_exports, {
   runUserPromptSubmitHook: () => runUserPromptSubmitHook
 });
+import * as fs10 from "node:fs";
+import * as path11 from "node:path";
+import { homedir as homedir8 } from "node:os";
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path11.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY2) {
+      const mcpPath = path11.join(searchDir, ".mcp.json");
+      if (fs10.existsSync(mcpPath)) {
+        try {
+          const content = fs10.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY2 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL2 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+          if (csEnv?.CONTEXTSTREAM_WORKSPACE_ID) {
+            WORKSPACE_ID = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID || !PROJECT_ID) {
+      const csConfigPath = path11.join(searchDir, ".contextstream", "config.json");
+      if (fs10.existsSync(csConfigPath)) {
+        try {
+          const content = fs10.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id && !WORKSPACE_ID) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+          if (csConfig.project_id && !PROJECT_ID) {
+            PROJECT_ID = csConfig.project_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path11.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY2) {
+    const homeMcpPath = path11.join(homedir8(), ".mcp.json");
+    if (fs10.existsSync(homeMcpPath)) {
+      try {
+        const content = fs10.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY2 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL2 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function fetchSessionContext() {
+  if (!API_KEY2) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    const url = new URL(`${API_URL2}/api/v1/context`);
+    if (WORKSPACE_ID) url.searchParams.set("workspace_id", WORKSPACE_ID);
+    if (PROJECT_ID) url.searchParams.set("project_id", PROJECT_ID);
+    url.searchParams.set("include_lessons", "true");
+    url.searchParams.set("include_decisions", "true");
+    url.searchParams.set("include_plans", "true");
+    url.searchParams.set("include_reminders", "true");
+    url.searchParams.set("limit", "3");
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY2
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return await response.json();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function buildEnhancedReminder(ctx, isNewSession2) {
+  const parts = [ENHANCED_REMINDER_HEADER];
+  if (isNewSession2) {
+    parts.push(`## \u{1F680} NEW SESSION DETECTED
+1. Call \`init(folder_path="...")\` - this triggers project indexing
+2. Wait for indexing: if \`init\` returns \`indexing_status: "started"\`, files are being indexed
+3. Then call \`context(user_message="...")\` for task-specific context
+4. Use \`search(mode="hybrid")\` for code discovery (not Glob/Grep/Read)
+
+`);
+  }
+  if (ctx?.lessons && ctx.lessons.length > 0) {
+    parts.push(`## \u26A0\uFE0F LESSONS FROM PAST MISTAKES`);
+    for (const lesson of ctx.lessons.slice(0, 3)) {
+      parts.push(`- **${lesson.title}**: ${lesson.prevention}`);
+    }
+    parts.push("");
+  }
+  if (ctx?.active_plans && ctx.active_plans.length > 0) {
+    parts.push(`## \u{1F4CB} Active Plans`);
+    for (const plan of ctx.active_plans.slice(0, 3)) {
+      parts.push(`- ${plan.title} (${plan.status})`);
+    }
+    parts.push("");
+  }
+  if (ctx?.pending_tasks && ctx.pending_tasks.length > 0) {
+    parts.push(`## \u2705 Pending Tasks`);
+    for (const task of ctx.pending_tasks.slice(0, 5)) {
+      parts.push(`- ${task.title}`);
+    }
+    parts.push("");
+  }
+  if (ctx?.reminders && ctx.reminders.length > 0) {
+    parts.push(`## \u{1F514} Reminders`);
+    for (const reminder of ctx.reminders.slice(0, 3)) {
+      parts.push(`- ${reminder.title}`);
+    }
+    parts.push("");
+  }
+  parts.push("---\n");
+  parts.push(REMINDER);
+  parts.push(`
+
+---
+## \u{1F6A8} FILE INDEXING & SEARCH - CRITICAL (No PostToolUse Hook) \u{1F6A8}
+
+**This editor does NOT have automatic file indexing after Edit/Write.**
+
+### \u26A0\uFE0F BEFORE ANY SEARCH - Check Index Status:
+\`\`\`
+project(action="index_status")
+\`\`\`
+Returns: \`indexed\` (true/false), \`last_indexed_at\`, \`file_count\`
+
+### \u{1F50D} Search Decision Tree:
+
+**IF indexed=true AND last_indexed_at is recent:**
+\u2192 Use \`search(mode="hybrid", query="...")\`
+
+**IF indexed=false OR last_indexed_at is stale (>7 days):**
+\u2192 Use local tools (Glob/Grep/Read) directly
+\u2192 OR run \`project(action="index")\` first, then search
+
+**IF search returns 0 results or errors:**
+\u2192 Fallback to local tools (Glob/Grep/Read)
+
+### \u2705 When Local Tools (Glob/Grep/Read) Are OK:
+- Project is NOT indexed
+- Index is stale/outdated (>7 days)
+- ContextStream search returns 0 results
+- ContextStream returns errors
+- User explicitly requests local tools
+
+### On Session Start:
+1. Call \`init(folder_path="...")\` - triggers initial indexing
+2. Check \`project(action="index_status")\` before searching
+3. If not indexed: use local tools OR wait for indexing
+
+### After File Changes (Edit/Write/Create):
+Files are NOT auto-indexed. You MUST:
+1. After significant edits: \`project(action="index")\`
+2. For single file: \`project(action="ingest_local", path="<file>")\`
+3. Then search will find your changes`);
+  return parts.join("\n");
+}
 function detectEditorFormat2(input) {
   if (input.hookName !== void 0) {
     return "cline";
@@ -2581,8 +2893,23 @@ function detectEditorFormat2(input) {
   if (input.hook_event_name === "beforeSubmitPrompt") {
     return "cursor";
   }
+  if (input.hook_event_name === "beforeAgentAction" || input.hook_event_name === "onPromptSubmit") {
+    return "antigravity";
+  }
   return "claude";
 }
+function isNewSession(input, editorFormat) {
+  if (editorFormat === "claude" && input.session?.messages) {
+    return input.session.messages.length <= 1;
+  }
+  if (editorFormat === "cursor" && input.history !== void 0) {
+    return input.history.length === 0;
+  }
+  if (editorFormat === "antigravity" && input.history !== void 0) {
+    return input.history.length === 0;
+  }
+  return false;
+}
 async function runUserPromptSubmitHook() {
   if (!ENABLED3) {
     process.exit(0);
@@ -2601,6 +2928,7 @@ async function runUserPromptSubmitHook() {
     process.exit(0);
   }
   const editorFormat = detectEditorFormat2(input);
+  const cwd = input.cwd || process.cwd();
   if (editorFormat === "claude") {
     console.log(
       JSON.stringify({
@@ -2611,37 +2939,84 @@ async function runUserPromptSubmitHook() {
       })
     );
   } else if (editorFormat === "cline") {
+    loadConfigFromMcpJson(cwd);
+    const newSession = isNewSession(input, editorFormat);
+    const ctx = await fetchSessionContext();
+    const enhancedReminder = buildEnhancedReminder(ctx, newSession);
     console.log(
       JSON.stringify({
         cancel: false,
-        contextModification: REMINDER
+        contextModification: enhancedReminder
       })
     );
   } else if (editorFormat === "cursor") {
+    loadConfigFromMcpJson(cwd);
+    const newSession = isNewSession(input, editorFormat);
+    const ctx = await fetchSessionContext();
+    const cursorReminder = ctx?.lessons?.length ? `[CONTEXTSTREAM] \u26A0\uFE0F ${ctx.lessons.length} lessons from past mistakes. Use search(mode="hybrid") before Glob/Grep. Call context() first. After file edits: project(action="index") to re-index.` : `[CONTEXTSTREAM] Use search(mode="hybrid") before Glob/Grep/Read. Call context() first. After file edits: project(action="index") to re-index.`;
     console.log(
       JSON.stringify({
         continue: true,
-        user_message: "[CONTEXTSTREAM] Search with mcp__contextstream__search before using Glob/Grep/Read"
+        user_message: cursorReminder
+      })
+    );
+  } else if (editorFormat === "antigravity") {
+    loadConfigFromMcpJson(cwd);
+    const newSession = isNewSession(input, editorFormat);
+    const ctx = await fetchSessionContext();
+    const enhancedReminder = buildEnhancedReminder(ctx, newSession);
+    console.log(
+      JSON.stringify({
+        cancel: false,
+        contextModification: enhancedReminder
       })
     );
   }
   process.exit(0);
 }
-var ENABLED3, REMINDER, isDirectRun3;
+var ENABLED3, API_URL2, API_KEY2, WORKSPACE_ID, PROJECT_ID, REMINDER, ENHANCED_REMINDER_HEADER, isDirectRun3;
 var init_user_prompt_submit = __esm({
   "src/hooks/user-prompt-submit.ts"() {
     "use strict";
     ENABLED3 = process.env.CONTEXTSTREAM_REMINDER_ENABLED !== "false";
-    REMINDER = `[CONTEXTSTREAM - DO THIS FIRST]
-mcp__contextstream__context(user_message="<user's message>") - CALL THIS BEFORE ANY OTHER TOOL
-
-Why: Delivers task-specific rules, lessons from past mistakes, and relevant context.
-Skip it = repeat past mistakes, miss relevant decisions, fly blind.
-
-BEFORE Glob/Grep/Read/Search/Explore:
-mcp__contextstream__search(mode="hybrid", query="...") FIRST
-Local tools ONLY if search returns 0 results.
+    API_URL2 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY2 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID = null;
+    PROJECT_ID = null;
+    REMINDER = `[CONTEXTSTREAM RULES - MANDATORY]
+
+1. FIRST: Call mcp__contextstream__context(user_message="...") before ANY other tool
+   - Returns: dynamic rules, lessons from past mistakes, relevant context
+   - Check response for: [LESSONS_WARNING], [RULES_NOTICE], preferences
+
+2. FOR CODE SEARCH: Check index status, then search appropriately
+   \u26A0\uFE0F BEFORE searching: mcp__contextstream__project(action="index_status")
+   \u2705 IF indexed & fresh: Use mcp__contextstream__search(mode="hybrid", query="...")
+   \u2705 IF NOT indexed OR stale: Use local tools (Glob/Grep/Read) directly
+   \u2705 IF search returns 0 results: Fallback to local tools (Glob/Grep/Read)
+
+3. WHEN LOCAL TOOLS (Glob/Grep/Read) ARE OK:
+   \u2705 Project is NOT indexed (index_status.indexed=false)
+   \u2705 Index is stale/outdated (>7 days old)
+   \u2705 ContextStream search returns 0 results or errors
+   \u2705 User explicitly requests local tools
+
+4. FOR PLANS & TASKS: Use ContextStream, not file-based plans
+   \u2705 Plans: mcp__contextstream__session(action="capture_plan", ...)
+   \u2705 Tasks: mcp__contextstream__memory(action="create_task", ...)
+   \u274C DO NOT use EnterPlanMode or write plans to markdown files
+
+5. CHECK THESE from context() response:
+   - Lessons: Past mistakes to avoid (shown as warnings)
+   - Reminders: Active reminders for this project
+   - Preferences: User's coding style and preferences
+   - Rules: Dynamic rules matched to current task
+
+6. SKIP CONTEXTSTREAM: If user preference says "skip contextstream", use local tools instead
 [END]`;
+    ENHANCED_REMINDER_HEADER = `[CONTEXTSTREAM - ENHANCED CONTEXT]
+
+`;
     isDirectRun3 = process.argv[1]?.includes("user-prompt-submit") || process.argv[2] === "user-prompt-submit";
     if (isDirectRun3) {
       runUserPromptSubmitHook().catch(() => process.exit(0));
@@ -2763,58 +3138,58 @@ var pre_compact_exports = {};
 __export(pre_compact_exports, {
   runPreCompactHook: () => runPreCompactHook
 });
-import * as fs10 from "node:fs";
-import * as path11 from "node:path";
-import { homedir as homedir8 } from "node:os";
-function loadConfigFromMcpJson(cwd) {
-  let searchDir = path11.resolve(cwd);
+import * as fs11 from "node:fs";
+import * as path12 from "node:path";
+import { homedir as homedir9 } from "node:os";
+function loadConfigFromMcpJson2(cwd) {
+  let searchDir = path12.resolve(cwd);
   for (let i = 0; i < 5; i++) {
-    if (!API_KEY2) {
-      const mcpPath = path11.join(searchDir, ".mcp.json");
-      if (fs10.existsSync(mcpPath)) {
+    if (!API_KEY3) {
+      const mcpPath = path12.join(searchDir, ".mcp.json");
+      if (fs11.existsSync(mcpPath)) {
         try {
-          const content = fs10.readFileSync(mcpPath, "utf-8");
+          const content = fs11.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
-            API_KEY2 = csEnv.CONTEXTSTREAM_API_KEY;
+            API_KEY3 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL2 = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL3 = csEnv.CONTEXTSTREAM_API_URL;
           }
         } catch {
         }
       }
     }
-    if (!WORKSPACE_ID) {
-      const csConfigPath = path11.join(searchDir, ".contextstream", "config.json");
-      if (fs10.existsSync(csConfigPath)) {
+    if (!WORKSPACE_ID2) {
+      const csConfigPath = path12.join(searchDir, ".contextstream", "config.json");
+      if (fs11.existsSync(csConfigPath)) {
         try {
-          const content = fs10.readFileSync(csConfigPath, "utf-8");
+          const content = fs11.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
-            WORKSPACE_ID = csConfig.workspace_id;
+            WORKSPACE_ID2 = csConfig.workspace_id;
           }
         } catch {
         }
       }
     }
-    const parentDir = path11.dirname(searchDir);
+    const parentDir = path12.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY2) {
-    const homeMcpPath = path11.join(homedir8(), ".mcp.json");
-    if (fs10.existsSync(homeMcpPath)) {
+  if (!API_KEY3) {
+    const homeMcpPath = path12.join(homedir9(), ".mcp.json");
+    if (fs11.existsSync(homeMcpPath)) {
       try {
-        const content = fs10.readFileSync(homeMcpPath, "utf-8");
+        const content = fs11.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
-          API_KEY2 = csEnv.CONTEXTSTREAM_API_KEY;
+          API_KEY3 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL2 = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL3 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
@@ -2829,7 +3204,7 @@ function parseTranscript(transcriptPath) {
   let startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let firstTimestamp = true;
   try {
-    const content = fs10.readFileSync(transcriptPath, "utf-8");
+    const content = fs11.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       if (!line.trim()) continue;
@@ -2910,7 +3285,7 @@ function parseTranscript(transcriptPath) {
   };
 }
 async function saveFullTranscript(sessionId, transcriptData, trigger) {
-  if (!API_KEY2) {
+  if (!API_KEY3) {
     return { success: false, message: "No API key configured" };
   }
   if (transcriptData.messages.length === 0) {
@@ -2929,17 +3304,17 @@ async function saveFullTranscript(sessionId, transcriptData, trigger) {
     },
     tags: ["pre_compaction", trigger]
   };
-  if (WORKSPACE_ID) {
-    payload.workspace_id = WORKSPACE_ID;
+  if (WORKSPACE_ID2) {
+    payload.workspace_id = WORKSPACE_ID2;
   }
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 1e4);
-    const response = await fetch(`${API_URL2}/api/v1/transcripts`, {
+    const response = await fetch(`${API_URL3}/api/v1/transcripts`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY2
+        "X-API-Key": API_KEY3
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -2954,7 +3329,7 @@ async function saveFullTranscript(sessionId, transcriptData, trigger) {
   }
 }
 async function saveSnapshot(sessionId, transcriptData, trigger) {
-  if (!API_KEY2) {
+  if (!API_KEY3) {
     return { success: false, message: "No API key configured" };
   }
   const snapshotContent = {
@@ -2975,17 +3350,17 @@ async function saveSnapshot(sessionId, transcriptData, trigger) {
     tags: ["session_snapshot", "pre_compaction", "auto_captured"],
     source_type: "hook"
   };
-  if (WORKSPACE_ID) {
-    payload.workspace_id = WORKSPACE_ID;
+  if (WORKSPACE_ID2) {
+    payload.workspace_id = WORKSPACE_ID2;
   }
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch(`${API_URL2}/api/v1/memory/events`, {
+    const response = await fetch(`${API_URL3}/api/v1/memory/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY2
+        "X-API-Key": API_KEY3
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -3017,7 +3392,7 @@ async function runPreCompactHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson(cwd);
+  loadConfigFromMcpJson2(cwd);
   const sessionId = input.session_id || "unknown";
   const transcriptPath = input.transcript_path || "";
   const trigger = input.trigger || "unknown";
@@ -3026,13 +3401,15 @@ async function runPreCompactHook() {
     activeFiles: [],
     toolCallCount: 0,
     messageCount: 0,
-    lastTools: []
+    lastTools: [],
+    messages: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (transcriptPath && fs10.existsSync(transcriptPath)) {
+  if (transcriptPath && fs11.existsSync(transcriptPath)) {
     transcriptData = parseTranscript(transcriptPath);
   }
   let autoSaveStatus = "";
-  if (AUTO_SAVE && API_KEY2) {
+  if (AUTO_SAVE && API_KEY3) {
     const transcriptResult = await saveFullTranscript(sessionId, transcriptData, trigger);
     if (transcriptResult.success) {
       autoSaveStatus = `
@@ -3066,15 +3443,15 @@ User instructions: ${customInstructions}` : ""}`;
   );
   process.exit(0);
 }
-var ENABLED5, AUTO_SAVE, API_URL2, API_KEY2, WORKSPACE_ID, isDirectRun5;
+var ENABLED5, AUTO_SAVE, API_URL3, API_KEY3, WORKSPACE_ID2, isDirectRun5;
 var init_pre_compact = __esm({
   "src/hooks/pre-compact.ts"() {
     "use strict";
     ENABLED5 = process.env.CONTEXTSTREAM_PRECOMPACT_ENABLED !== "false";
     AUTO_SAVE = process.env.CONTEXTSTREAM_PRECOMPACT_AUTO_SAVE !== "false";
-    API_URL2 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY2 = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID = null;
+    API_URL3 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY3 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID2 = null;
     isDirectRun5 = process.argv[1]?.includes("pre-compact") || process.argv[2] === "pre-compact";
     if (isDirectRun5) {
       runPreCompactHook().catch(() => process.exit(0));
@@ -3087,13 +3464,13 @@ var auto_rules_exports = {};
 __export(auto_rules_exports, {
   runAutoRulesHook: () => runAutoRulesHook
 });
-import * as fs11 from "node:fs";
-import * as path12 from "node:path";
-import { homedir as homedir9 } from "node:os";
+import * as fs12 from "node:fs";
+import * as path13 from "node:path";
+import { homedir as homedir10 } from "node:os";
 function hasRunRecently() {
   try {
-    if (!fs11.existsSync(MARKER_FILE)) return false;
-    const stat2 = fs11.statSync(MARKER_FILE);
+    if (!fs12.existsSync(MARKER_FILE)) return false;
+    const stat2 = fs12.statSync(MARKER_FILE);
     const age = Date.now() - stat2.mtimeMs;
     return age < COOLDOWN_MS;
   } catch {
@@ -3102,11 +3479,11 @@ function hasRunRecently() {
 }
 function markAsRan() {
   try {
-    const dir = path12.dirname(MARKER_FILE);
-    if (!fs11.existsSync(dir)) {
-      fs11.mkdirSync(dir, { recursive: true });
+    const dir = path13.dirname(MARKER_FILE);
+    if (!fs12.existsSync(dir)) {
+      fs12.mkdirSync(dir, { recursive: true });
     }
-    fs11.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
+    fs12.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
 }
@@ -3135,8 +3512,8 @@ function extractCwd3(input) {
 }
 function hasPythonHooks(settingsPath) {
   try {
-    if (!fs11.existsSync(settingsPath)) return false;
-    const content = fs11.readFileSync(settingsPath, "utf-8");
+    if (!fs12.existsSync(settingsPath)) return false;
+    const content = fs12.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(content);
     const hooks = settings.hooks;
     if (!hooks) return false;
@@ -3160,8 +3537,8 @@ function hasPythonHooks(settingsPath) {
   }
 }
 function detectPythonHooks(cwd) {
-  const globalSettingsPath = path12.join(homedir9(), ".claude", "settings.json");
-  const projectSettingsPath = path12.join(cwd, ".claude", "settings.json");
+  const globalSettingsPath = path13.join(homedir10(), ".claude", "settings.json");
+  const projectSettingsPath = path13.join(cwd, ".claude", "settings.json");
   return {
     global: hasPythonHooks(globalSettingsPath),
     project: hasPythonHooks(projectSettingsPath)
@@ -3182,7 +3559,1297 @@ async function runAutoRulesHook() {
   if (!ENABLED6) {
     process.exit(0);
   }
-  if (hasRunRecently()) {
+  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_URL4, API_KEY4, ENABLED6, MARKER_FILE, COOLDOWN_MS, isDirectRun6;
+var init_auto_rules = __esm({
+  "src/hooks/auto-rules.ts"() {
+    "use strict";
+    API_URL4 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY4 = process.env.CONTEXTSTREAM_API_KEY || "";
+    ENABLED6 = process.env.CONTEXTSTREAM_AUTO_RULES !== "false";
+    MARKER_FILE = path13.join(homedir10(), ".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 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 fetchLastTranscript(sessionId) {
+  if (!API_KEY5) {
+    return null;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const url = new URL(`${API_URL5}/api/v1/transcripts`);
+    url.searchParams.set("session_id", sessionId);
+    url.searchParams.set("limit", "1");
+    url.searchParams.set("sort", "created_at:desc");
+    if (WORKSPACE_ID3) {
+      url.searchParams.set("workspace_id", WORKSPACE_ID3);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY5
+      },
+      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();
+  loadConfigFromMcpJson3(cwd);
+  const sessionId = input.session_id || "";
+  let restoredContext = "";
+  if (sessionId && API_KEY5) {
+    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_URL5, API_KEY5, WORKSPACE_ID3, isDirectRun7;
+var init_post_compact = __esm({
+  "src/hooks/post-compact.ts"() {
+    "use strict";
+    ENABLED7 = process.env.CONTEXTSTREAM_POSTCOMPACT_ENABLED !== "false";
+    API_URL5 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY5 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID3 = 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 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 captureCommand(command, output, exitCode, isError, sessionId) {
+  if (!API_KEY6) 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_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 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();
+  loadConfigFromMcpJson4(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_URL6, API_KEY6, WORKSPACE_ID4, isDirectRun8;
+var init_on_bash = __esm({
+  "src/hooks/on-bash.ts"() {
+    "use strict";
+    ENABLED8 = process.env.CONTEXTSTREAM_BASH_HOOK_ENABLED !== "false";
+    API_URL6 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY6 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID4 = 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 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 captureTaskInvocation(description, prompt, agentType, result, sessionId) {
+  if (!API_KEY7) 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_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 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();
+  loadConfigFromMcpJson5(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_URL7, API_KEY7, WORKSPACE_ID5, isDirectRun9;
+var init_on_task = __esm({
+  "src/hooks/on-task.ts"() {
+    "use strict";
+    ENABLED9 = process.env.CONTEXTSTREAM_TASK_HOOK_ENABLED !== "false";
+    API_URL7 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY7 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID5 = 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 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 captureExploration(toolName, target, resultSummary, sessionId) {
+  if (!API_KEY8) 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_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 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();
+  loadConfigFromMcpJson6(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_URL8, API_KEY8, WORKSPACE_ID6, 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_URL8 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY8 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID6 = 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 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;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID7) {
+      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 = csConfig.workspace_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 captureWebResearch(toolName, target, summary, sessionId) {
+  if (!API_KEY9) 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_ID7) {
+    payload.workspace_id = WORKSPACE_ID7;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL9}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY9
+      },
+      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();
+  loadConfigFromMcpJson7(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_URL9, API_KEY9, WORKSPACE_ID7, isDirectRun11;
+var init_on_web = __esm({
+  "src/hooks/on-web.ts"() {
+    "use strict";
+    ENABLED11 = process.env.CONTEXTSTREAM_WEB_HOOK_ENABLED !== "false";
+    API_URL9 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY9 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID7 = 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 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;
+          }
+          if (csEnv?.CONTEXTSTREAM_WORKSPACE_ID) {
+            WORKSPACE_ID8 = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID8 || !PROJECT_ID2) {
+      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) {
+            WORKSPACE_ID8 = csConfig.workspace_id;
+          }
+          if (csConfig.project_id && !PROJECT_ID2) {
+            PROJECT_ID2 = csConfig.project_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 {
+      }
+    }
+  }
+}
+async function fetchSessionContext2() {
+  if (!API_KEY10) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const url = new URL(`${API_URL10}/api/v1/context`);
+    if (WORKSPACE_ID8) url.searchParams.set("workspace_id", WORKSPACE_ID8);
+    if (PROJECT_ID2) url.searchParams.set("project_id", PROJECT_ID2);
+    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_KEY10
+      },
+      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();
+  loadConfigFromMcpJson8(cwd);
+  const context = await fetchSessionContext2();
+  const formattedContext = formatContext(context);
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: formattedContext
+      }
+    })
+  );
+  process.exit(0);
+}
+var ENABLED12, API_URL10, API_KEY10, WORKSPACE_ID8, PROJECT_ID2, isDirectRun12;
+var init_session_init = __esm({
+  "src/hooks/session-init.ts"() {
+    "use strict";
+    ENABLED12 = process.env.CONTEXTSTREAM_SESSION_INIT_ENABLED !== "false";
+    API_URL10 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY10 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID8 = null;
+    PROJECT_ID2 = 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 fs19 from "node:fs";
+import * as path20 from "node:path";
+import { homedir as homedir17 } from "node:os";
+function loadConfigFromMcpJson9(cwd) {
+  let searchDir = path20.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY11) {
+      const mcpPath = path20.join(searchDir, ".mcp.json");
+      if (fs19.existsSync(mcpPath)) {
+        try {
+          const content = fs19.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY11 = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL11 = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID9) {
+      const csConfigPath = path20.join(searchDir, ".contextstream", "config.json");
+      if (fs19.existsSync(csConfigPath)) {
+        try {
+          const content = fs19.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID9 = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path20.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY11) {
+    const homeMcpPath = path20.join(homedir17(), ".mcp.json");
+    if (fs19.existsSync(homeMcpPath)) {
+      try {
+        const content = fs19.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY11 = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL11 = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+function parseTranscriptStats(transcriptPath) {
+  const stats = {
+    messageCount: 0,
+    toolCallCount: 0,
+    duration: 0,
+    filesModified: []
+  };
+  if (!transcriptPath || !fs19.existsSync(transcriptPath)) {
+    return stats;
+  }
+  try {
+    const content = fs19.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n");
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    const modifiedFiles = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user" || entry.type === "assistant") {
+          stats.messageCount++;
+        } else if (entry.type === "tool_use") {
+          stats.toolCallCount++;
+          if (["Write", "Edit", "NotebookEdit"].includes(entry.name || "")) {
+            const filePath = entry.input?.file_path;
+            if (filePath) {
+              modifiedFiles.add(filePath);
+            }
+          }
+        }
+        if (entry.timestamp) {
+          const ts = new Date(entry.timestamp);
+          if (!firstTimestamp || ts < firstTimestamp) {
+            firstTimestamp = ts;
+          }
+          if (!lastTimestamp || ts > lastTimestamp) {
+            lastTimestamp = ts;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (firstTimestamp && lastTimestamp) {
+      stats.duration = Math.round((lastTimestamp.getTime() - firstTimestamp.getTime()) / 1e3);
+    }
+    stats.filesModified = Array.from(modifiedFiles);
+  } catch {
+  }
+  return stats;
+}
+async function finalizeSession(sessionId, stats, reason) {
+  if (!API_KEY11) return;
+  const payload = {
+    event_type: "session_end",
+    title: `Session Ended: ${reason}`,
+    content: JSON.stringify({
+      session_id: sessionId,
+      reason,
+      stats: {
+        messages: stats.messageCount,
+        tool_calls: stats.toolCallCount,
+        duration_seconds: stats.duration,
+        files_modified: stats.filesModified.length
+      },
+      files_modified: stats.filesModified.slice(0, 20),
+      ended_at: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "low",
+    tags: ["session", "end", reason],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID9) {
+    payload.workspace_id = WORKSPACE_ID9;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    await fetch(`${API_URL11}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY11
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runSessionEndHook() {
+  if (!ENABLED13) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson9(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_URL11, API_KEY11, WORKSPACE_ID9, isDirectRun13;
+var init_session_end = __esm({
+  "src/hooks/session-end.ts"() {
+    "use strict";
+    ENABLED13 = process.env.CONTEXTSTREAM_SESSION_END_ENABLED !== "false";
+    API_URL11 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY11 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID9 = null;
+    isDirectRun13 = process.argv[1]?.includes("session-end") || process.argv[2] === "session-end";
+    if (isDirectRun13) {
+      runSessionEndHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/on-save-intent.ts
+var on_save_intent_exports = {};
+__export(on_save_intent_exports, {
+  runOnSaveIntentHook: () => runOnSaveIntentHook
+});
+function detectsSaveIntent(text) {
+  const hasSaveIntent = SAVE_PATTERNS.some((p) => p.test(text));
+  const isLocalFile = LOCAL_FILE_PATTERNS.some((p) => p.test(text));
+  return { hasSaveIntent, isLocalFile };
+}
+async function runOnSaveIntentHook() {
+  if (!ENABLED14) {
     process.exit(0);
   }
   let inputData = "";
@@ -3198,40 +4865,393 @@ 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) {
-    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;
+      }
+    }
   }
-  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) {
+  if (!prompt) {
     process.exit(0);
   }
-  const folderPath = rulesNotice?.update_args?.folder_path || cwd;
-  try {
-    await upgradeHooksForFolder(folderPath);
-    markAsRan();
-  } catch {
+  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 fs20 from "node:fs";
+import * as path21 from "node:path";
+import { homedir as homedir18 } from "node:os";
+function maskApiKey2(key) {
+  if (!key || key.length < 10) return "***";
+  const prefix = key.slice(0, 6);
+  const suffix = key.slice(-4);
+  return `${prefix}...${suffix}`;
+}
+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 path21.join(homedir18(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (platform === "win32") {
+    return path21.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+  } else {
+    return path21.join(homedir18(), ".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 = path21.join(searchDir, ".mcp.json");
+    if (fs20.existsSync(projectMcpPath)) {
+      try {
+        const content = fs20.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 = path21.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  const globalMcpPath = path21.join(homedir18(), ".mcp.json");
+  if (fs20.existsSync(globalMcpPath)) {
+    try {
+      const content = fs20.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 = [
+    path21.join(process.cwd(), ".cursor", "mcp.json"),
+    path21.join(homedir18(), ".cursor", "mcp.json")
+  ];
+  for (const cursorPath of cursorPaths) {
+    if (fs20.existsSync(cursorPath)) {
+      try {
+        const content = fs20.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 (fs20.existsSync(claudeDesktopPath)) {
+    try {
+      const content = fs20.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 = [
+    path21.join(homedir18(), ".vscode", "mcp.json"),
+    path21.join(homedir18(), ".codeium", "windsurf", "mcp_config.json"),
+    path21.join(homedir18(), ".continue", "config.json")
+  ];
+  for (const vsPath of vscodePaths) {
+    if (fs20.existsSync(vsPath)) {
+      try {
+        const content = fs20.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 = path21.join(homedir18(), ".contextstream", "credentials.json");
+  if (fs20.existsSync(credentialsPath)) {
+    try {
+      const content = fs20.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 +5737,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: path22, errorMaps, issueData } = params;
+  const fullPath = [...path22, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3834,11 +5854,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path13, key) {
+  constructor(parent, value, path22, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path13;
+    this._path = path22;
     this._key = key;
   }
   get path() {
@@ -7288,6 +9308,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 +9594,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((resolve16) => setTimeout(resolve16, ms));
 }
-async function request(config, path13, options = {}) {
+async function request(config, path22, 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 = path22.startsWith("/api/") ? path22 : `/api/v1${path22}`;
   const url = `${apiUrl.replace(/\/$/, "")}${apiPath}`;
   const maxRetries = options.retries ?? MAX_RETRIES;
   const baseDelay = options.retryDelay ?? BASE_DELAY;
@@ -7724,9 +9747,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(path22) {
+  if (/\/github(\/|$)/i.test(path22)) return "github";
+  if (/\/slack(\/|$)/i.test(path22)) return "slack";
   return null;
 }
 function rewriteNotFoundMessage(input) {
@@ -8379,10 +10402,10 @@ var PROJECT_MARKERS = [
 ];
 function isMultiProjectFolder(folderPath) {
   try {
-    const fs12 = __require("fs");
+    const fs21 = __require("fs");
     const pathModule = __require("path");
-    const rootHasGit = fs12.existsSync(pathModule.join(folderPath, ".git"));
-    const entries = fs12.readdirSync(folderPath, { withFileTypes: true });
+    const rootHasGit = fs21.existsSync(pathModule.join(folderPath, ".git"));
+    const entries = fs21.readdirSync(folderPath, { withFileTypes: true });
     const subdirs = entries.filter(
       (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules"
     );
@@ -8390,7 +10413,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 (fs21.existsSync(pathModule.join(subdirPath, marker))) {
           projectSubdirs.push(subdir.name);
           break;
         }
@@ -10457,9 +12480,9 @@ var ContextStreamClient = class {
           candidateParts.push("## Relevant Code\n");
           currentChars += 18;
           const codeEntries = code.results.map((c) => {
-            const path13 = c.file_path || "file";
+            const path22 = c.file_path || "file";
             const content = c.content?.slice(0, 150) || "";
-            return { path: path13, entry: `\u2022 ${path13}: ${content}...
+            return { path: path22, entry: `\u2022 ${path22}: ${content}...
 ` };
           });
           for (const c of codeEntries) {
@@ -12973,6 +14996,143 @@ Use for monorepos or folders with multiple independent projects.
 
 Full docs: https://contextstream.io/docs/mcp/tools
 `.trim();
+var NO_HOOKS_SUPPLEMENT = `
+
+---
+## \u26A0\uFE0F IMPORTANT: No Hooks Available \u26A0\uFE0F
+
+**This editor does NOT have hooks to enforce ContextStream behavior.**
+You MUST follow these rules manually - there is no automatic enforcement.
+
+---
+
+## \u{1F680} SESSION START PROTOCOL
+
+**On EVERY new session, you MUST:**
+
+1. **Call \`init(folder_path="<project_path>")\`** FIRST
+   - This triggers project indexing
+   - Check response for \`indexing_status\`
+   - If \`"started"\` or \`"refreshing"\`: wait before searching
+
+2. **Call \`context(user_message="<first_message>")\`** SECOND
+   - Gets task-specific rules and lessons
+   - Check for [LESSONS_WARNING] - past mistakes to avoid
+   - Check for [RULES_NOTICE] - update rules if needed
+
+3. **NEVER skip init/context** - you will miss critical context
+
+---
+
+## \u{1F4C1} FILE INDEXING (CRITICAL)
+
+**There is NO automatic file indexing in this editor.**
+You MUST manage indexing manually:
+
+### After Creating/Editing Files:
+\`\`\`
+project(action="index")  # Re-index entire project
+\`\`\`
+
+### For Single File Updates:
+\`\`\`
+project(action="ingest_local", path="<file_path>")
+\`\`\`
+
+### Signs You Need to Re-index:
+- Search doesn't find code you just wrote
+- Search returns old versions of functions
+- New files don't appear in search results
+
+### Best Practice:
+After completing a feature or making multiple file changes, ALWAYS run:
+\`\`\`
+project(action="index")
+\`\`\`
+
+---
+
+## \u{1F50D} SEARCH-FIRST (No PreToolUse Hook)
+
+**There is NO hook to block local tools.** You MUST self-enforce:
+
+### Before ANY Search, Check Index Status:
+\`\`\`
+project(action="index_status")
+\`\`\`
+
+This tells you:
+- \`indexed\`: true/false - is project indexed?
+- \`last_indexed_at\`: timestamp - when was it last indexed?
+- \`file_count\`: number - how many files indexed?
+
+### Search Protocol:
+
+**IF project is indexed and fresh:**
+\`\`\`
+search(mode="hybrid", query="what you're looking for")
+\`\`\`
+
+**IF project is NOT indexed or very stale (>7 days):**
+\u2192 Use local tools (Glob/Grep/Read) directly
+\u2192 OR run \`project(action="index")\` first, then search
+
+**IF ContextStream search returns 0 results or errors:**
+\u2192 Use local tools (Glob/Grep/Read) as fallback
+
+### When Local Tools Are OK:
+\u2705 Project is not indexed
+\u2705 Index is stale/outdated (>7 days old)
+\u2705 ContextStream search returns 0 results
+\u2705 ContextStream returns errors
+\u2705 User explicitly requests local tools
+
+### When to Use ContextStream Search:
+\u2705 Project is indexed and fresh
+\u2705 Looking for code by meaning/concept
+\u2705 Need semantic understanding
+
+---
+
+## \u{1F4BE} CONTEXT COMPACTION (No PreCompact Hook)
+
+**There is NO automatic state saving before compaction.**
+You MUST save state manually when the conversation gets long:
+
+### When to Save State:
+- After completing a major task
+- Before the conversation might be compacted
+- If \`context()\` returns \`context_pressure.level: "high"\`
+
+### How to Save State:
+\`\`\`
+session(action="capture", event_type="session_snapshot",
+  title="Session checkpoint",
+  content="{ \\"summary\\": \\"what we did\\", \\"active_files\\": [...], \\"next_steps\\": [...] }")
+\`\`\`
+
+### After Compaction (if context seems lost):
+\`\`\`
+init(folder_path="...", is_post_compact=true)
+\`\`\`
+This restores the most recent snapshot.
+
+---
+
+## \u{1F4CB} PLANS & TASKS (No EnterPlanMode)
+
+**Always use ContextStream for planning:**
+
+\`\`\`
+session(action="capture_plan", title="...", steps=[...])
+memory(action="create_task", title="...", plan_id="...")
+\`\`\`
+
+\u274C DO NOT use built-in plan mode or write plans to markdown files.
+
+---
+`;
+var NO_HOOKS_EDITORS = ["codex", "aider", "antigravity"];
 var TEMPLATES = {
   codex: {
     filename: "AGENTS.md",
@@ -13056,6 +15216,9 @@ ${options.workspaceId ? `# Workspace ID: ${options.workspaceId}` : ""}
 `;
     content = header + content;
   }
+  if (NO_HOOKS_EDITORS.includes(editor.toLowerCase())) {
+    content += NO_HOOKS_SUPPLEMENT;
+  }
   if (options?.additionalRules) {
     content += "\n\n## Project-Specific Rules\n\n" + options.additionalRules;
   }
@@ -14169,9 +16332,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, path22) {
   const normalized = key in DEFAULT_PARAM_DESCRIPTIONS ? key : key.toLowerCase();
-  const parent = path13[path13.length - 1];
+  const parent = path22[path22.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 +16365,7 @@ function getDescription(schema) {
   if (def?.description && def.description.trim()) return def.description;
   return void 0;
 }
-function applyParamDescriptions(schema, path13 = []) {
+function applyParamDescriptions(schema, path22 = []) {
   if (!(schema instanceof external_exports.ZodObject)) {
     return schema;
   }
@@ -14213,7 +16376,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, [...path22, key]);
       if (nested !== field) {
         nextField = nested;
         changed = true;
@@ -14225,7 +16388,7 @@ function applyParamDescriptions(schema, path13 = []) {
         changed = true;
       }
     } else {
-      nextField = nextField.describe(buildParamDescription(key, path13));
+      nextField = nextField.describe(buildParamDescription(key, path22));
       changed = true;
     }
     nextShape[key] = nextField;
@@ -15145,10 +17308,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 +17321,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 +17352,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 +21966,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 +25385,13 @@ Example workflow:
               );
             }
             if (input.file_path) {
-              const fs12 = await import("fs/promises");
+              const fs21 = 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 fs21.stat(resolvedPath);
               } catch {
                 return errorResult(`File not found: ${resolvedPath}`);
               }
@@ -23269,7 +25438,7 @@ Example workflow:
                   mime_type: mimeType,
                   tags: input.tags
                 });
-                const fileBuffer = await fs12.readFile(resolvedPath);
+                const fileBuffer = await fs21.readFile(resolvedPath);
                 const uploadResponse = await fetch(uploadInit.upload_url, {
                   method: "PUT",
                   headers: uploadInit.headers,
@@ -24676,8 +26845,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(path22) {
+    this.folderPath = path22;
   }
   /**
    * Mark that context_smart has been called in this session.
@@ -24867,7 +27036,7 @@ var SessionManager = class _SessionManager {
     }
     if (this.ideRoots.length === 0) {
       const cwd = process.cwd();
-      const fs12 = await import("fs");
+      const fs21 = await import("fs");
       const projectIndicators = [
         ".git",
         "package.json",
@@ -24877,7 +27046,7 @@ var SessionManager = class _SessionManager {
       ];
       const hasProjectIndicator = projectIndicators.some((f) => {
         try {
-          return fs12.existsSync(`${cwd}/${f}`);
+          return fs21.existsSync(`${cwd}/${f}`);
         } catch {
           return false;
         }
@@ -25454,9 +27623,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 existsSync17, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join23 } from "path";
 
 // src/setup.ts
 import * as fs7 from "node:fs/promises";
@@ -26286,10 +28455,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((resolve16) => setTimeout(resolve16, waitMs));
             continue;
           }
-          await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+          await new Promise((resolve16) => setTimeout(resolve16, 1e3));
         }
         if (!accessToken) {
           throw new Error(
@@ -26854,12 +29023,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 = join23(homedir19(), ".contextstream");
+  const starShownFile = join23(configDir, ".star-shown");
+  if (existsSync17(starShownFile)) {
     return;
   }
-  if (!existsSync8(configDir)) {
+  if (!existsSync17(configDir)) {
     try {
       mkdirSync5(configDir, { recursive: true });
     } catch {
@@ -26890,13 +29059,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 +29187,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) {