@contextstream/mcp-server 0.4.51 → 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(path21, 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(path21);
+          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 = (path21, originalPath, doThrow) => {
-      if (!isString(path21)) {
+    var checkPath = (path22, originalPath, doThrow) => {
+      if (!isString(path22)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path21) {
+      if (!path22) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path21)) {
+      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 = (path21) => REGEX_TEST_INVALID_PATH.test(path21);
+    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 path21 = originalPath && checkPath.convert(originalPath);
+        const path22 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path21,
+          path22,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path21, cache, checkUnignored, slices);
+        return this._t(path22, cache, checkUnignored, slices);
       }
-      checkIgnore(path21) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path21)) {
-          return this.test(path21);
+      checkIgnore(path22) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path22)) {
+          return this.test(path22);
         }
-        const slices = path21.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(path21, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path22, false, MODE_CHECK_IGNORE);
       }
-      _t(path21, cache, checkUnignored, slices) {
-        if (path21 in cache) {
-          return cache[path21];
+      _t(path22, cache, checkUnignored, slices) {
+        if (path22 in cache) {
+          return cache[path22];
         }
         if (!slices) {
-          slices = path21.split(SLASH).filter(Boolean);
+          slices = path22.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path21] = this._rules.test(path21, 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[path21] = parent.ignored ? parent : this._rules.test(path21, checkUnignored, MODE_IGNORE);
+        return cache[path22] = parent.ignored ? parent : this._rules.test(path22, checkUnignored, MODE_IGNORE);
       }
-      ignores(path21) {
-        return this._test(path21, this._ignoreCache, false).ignored;
+      ignores(path22) {
+        return this._test(path22, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path21) => !this.ignores(path21);
+        return (path22) => !this.ignores(path22);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path21) {
-        return this._test(path21, this._testCache, true);
+      test(path22) {
+        return this._test(path22, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path21) => checkPath(path21 && checkPath.convert(path21), path21, 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 = (path21) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path21) || isNotRelative(path21);
+      checkPath.isNotRelative = (path22) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path22) || isNotRelative(path22);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -542,11 +542,15 @@ 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");
-    const fs20 = __require("node:fs");
-    if (fs20.existsSync(indexPath)) {
+    if (fs21.existsSync(indexPath)) {
       return `node ${indexPath} hook ${hookName}`;
     }
   } catch {
@@ -2514,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 = {
@@ -2544,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 = "";
@@ -2570,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") {
@@ -2581,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") {
@@ -2659,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";
@@ -2679,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";
@@ -2686,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);
@@ -2706,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({
@@ -2716,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));
@@ -2868,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 {
       }
@@ -2934,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;
@@ -3015,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) {
@@ -3034,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
@@ -3059,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 = {
@@ -3080,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
@@ -3122,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";
@@ -3131,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 = `
@@ -3171,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));
@@ -3192,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 {
@@ -3207,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 {
   }
 }
@@ -3240,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;
@@ -3265,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)
@@ -3324,14 +3596,14 @@ async function runAutoRulesHook() {
   }
   process.exit(0);
 }
-var API_URL3, API_KEY3, ENABLED6, MARKER_FILE, COOLDOWN_MS, isDirectRun6;
+var API_URL4, API_KEY4, ENABLED6, MARKER_FILE, COOLDOWN_MS, isDirectRun6;
 var init_auto_rules = __esm({
   "src/hooks/auto-rules.ts"() {
     "use strict";
-    API_URL3 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY3 = process.env.CONTEXTSTREAM_API_KEY || "";
+    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 = path12.join(homedir9(), ".contextstream", ".auto-rules-ran");
+    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) {
@@ -3345,58 +3617,58 @@ var post_compact_exports = {};
 __export(post_compact_exports, {
   runPostCompactHook: () => runPostCompactHook
 });
-import * as fs12 from "node:fs";
-import * as path13 from "node:path";
-import { homedir as homedir10 } from "node:os";
-function loadConfigFromMcpJson2(cwd) {
-  let searchDir = path13.resolve(cwd);
+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_KEY4) {
-      const mcpPath = path13.join(searchDir, ".mcp.json");
-      if (fs12.existsSync(mcpPath)) {
+    if (!API_KEY5) {
+      const mcpPath = path14.join(searchDir, ".mcp.json");
+      if (fs13.existsSync(mcpPath)) {
         try {
-          const content = fs12.readFileSync(mcpPath, "utf-8");
+          const content = fs13.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
-            API_KEY4 = csEnv.CONTEXTSTREAM_API_KEY;
+            API_KEY5 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL4 = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL5 = csEnv.CONTEXTSTREAM_API_URL;
           }
         } catch {
         }
       }
     }
-    if (!WORKSPACE_ID2) {
-      const csConfigPath = path13.join(searchDir, ".contextstream", "config.json");
-      if (fs12.existsSync(csConfigPath)) {
+    if (!WORKSPACE_ID3) {
+      const csConfigPath = path14.join(searchDir, ".contextstream", "config.json");
+      if (fs13.existsSync(csConfigPath)) {
         try {
-          const content = fs12.readFileSync(csConfigPath, "utf-8");
+          const content = fs13.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
-            WORKSPACE_ID2 = csConfig.workspace_id;
+            WORKSPACE_ID3 = csConfig.workspace_id;
           }
         } catch {
         }
       }
     }
-    const parentDir = path13.dirname(searchDir);
+    const parentDir = path14.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY4) {
-    const homeMcpPath = path13.join(homedir10(), ".mcp.json");
-    if (fs12.existsSync(homeMcpPath)) {
+  if (!API_KEY5) {
+    const homeMcpPath = path14.join(homedir11(), ".mcp.json");
+    if (fs13.existsSync(homeMcpPath)) {
       try {
-        const content = fs12.readFileSync(homeMcpPath, "utf-8");
+        const content = fs13.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
-          API_KEY4 = csEnv.CONTEXTSTREAM_API_KEY;
+          API_KEY5 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL4 = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL5 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
@@ -3404,23 +3676,23 @@ function loadConfigFromMcpJson2(cwd) {
   }
 }
 async function fetchLastTranscript(sessionId) {
-  if (!API_KEY4) {
+  if (!API_KEY5) {
     return null;
   }
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    const url = new URL(`${API_URL4}/api/v1/transcripts`);
+    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_ID2) {
-      url.searchParams.set("workspace_id", WORKSPACE_ID2);
+    if (WORKSPACE_ID3) {
+      url.searchParams.set("workspace_id", WORKSPACE_ID3);
     }
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "X-API-Key": API_KEY4
+        "X-API-Key": API_KEY5
       },
       signal: controller.signal
     });
@@ -3477,10 +3749,10 @@ async function runPostCompactHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson2(cwd);
+  loadConfigFromMcpJson3(cwd);
   const sessionId = input.session_id || "";
   let restoredContext = "";
-  if (sessionId && API_KEY4) {
+  if (sessionId && API_KEY5) {
     const transcript = await fetchLastTranscript(sessionId);
     if (transcript) {
       restoredContext = formatTranscriptSummary(transcript);
@@ -3503,14 +3775,14 @@ The conversation was compacted to save memory. The above summary was automatical
   );
   process.exit(0);
 }
-var ENABLED7, API_URL4, API_KEY4, WORKSPACE_ID2, isDirectRun7;
+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_URL4 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY4 = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID2 = null;
+    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));
@@ -3523,58 +3795,58 @@ var on_bash_exports = {};
 __export(on_bash_exports, {
   runOnBashHook: () => runOnBashHook
 });
-import * as fs13 from "node:fs";
-import * as path14 from "node:path";
-import { homedir as homedir11 } from "node:os";
-function loadConfigFromMcpJson3(cwd) {
-  let searchDir = path14.resolve(cwd);
+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_KEY5) {
-      const mcpPath = path14.join(searchDir, ".mcp.json");
-      if (fs13.existsSync(mcpPath)) {
+    if (!API_KEY6) {
+      const mcpPath = path15.join(searchDir, ".mcp.json");
+      if (fs14.existsSync(mcpPath)) {
         try {
-          const content = fs13.readFileSync(mcpPath, "utf-8");
+          const content = fs14.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;
+            API_KEY6 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL5 = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL6 = csEnv.CONTEXTSTREAM_API_URL;
           }
         } catch {
         }
       }
     }
-    if (!WORKSPACE_ID3) {
-      const csConfigPath = path14.join(searchDir, ".contextstream", "config.json");
-      if (fs13.existsSync(csConfigPath)) {
+    if (!WORKSPACE_ID4) {
+      const csConfigPath = path15.join(searchDir, ".contextstream", "config.json");
+      if (fs14.existsSync(csConfigPath)) {
         try {
-          const content = fs13.readFileSync(csConfigPath, "utf-8");
+          const content = fs14.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
-            WORKSPACE_ID3 = csConfig.workspace_id;
+            WORKSPACE_ID4 = csConfig.workspace_id;
           }
         } catch {
         }
       }
     }
-    const parentDir = path14.dirname(searchDir);
+    const parentDir = path15.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY5) {
-    const homeMcpPath = path14.join(homedir11(), ".mcp.json");
-    if (fs13.existsSync(homeMcpPath)) {
+  if (!API_KEY6) {
+    const homeMcpPath = path15.join(homedir12(), ".mcp.json");
+    if (fs14.existsSync(homeMcpPath)) {
       try {
-        const content = fs13.readFileSync(homeMcpPath, "utf-8");
+        const content = fs14.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;
+          API_KEY6 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL5 = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL6 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
@@ -3582,7 +3854,7 @@ function loadConfigFromMcpJson3(cwd) {
   }
 }
 async function captureCommand(command, output, exitCode, isError, sessionId) {
-  if (!API_KEY5) return;
+  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)}...`,
@@ -3597,17 +3869,17 @@ async function captureCommand(command, output, exitCode, isError, sessionId) {
     source_type: "hook",
     session_id: sessionId
   };
-  if (WORKSPACE_ID3) {
-    payload.workspace_id = WORKSPACE_ID3;
+  if (WORKSPACE_ID4) {
+    payload.workspace_id = WORKSPACE_ID4;
   }
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 3e3);
-    await fetch(`${API_URL5}/api/v1/memory/events`, {
+    await fetch(`${API_URL6}/api/v1/memory/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY5
+        "X-API-Key": API_KEY6
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -3675,7 +3947,7 @@ async function runOnBashHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson3(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;
@@ -3699,14 +3971,14 @@ async function runOnBashHook() {
   }
   process.exit(0);
 }
-var ENABLED8, API_URL5, API_KEY5, WORKSPACE_ID3, isDirectRun8;
+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_URL5 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY5 = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID3 = null;
+    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));
@@ -3719,58 +3991,58 @@ var on_task_exports = {};
 __export(on_task_exports, {
   runOnTaskHook: () => runOnTaskHook
 });
-import * as fs14 from "node:fs";
-import * as path15 from "node:path";
-import { homedir as homedir12 } from "node:os";
-function loadConfigFromMcpJson4(cwd) {
-  let searchDir = path15.resolve(cwd);
+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_KEY6) {
-      const mcpPath = path15.join(searchDir, ".mcp.json");
-      if (fs14.existsSync(mcpPath)) {
+    if (!API_KEY7) {
+      const mcpPath = path16.join(searchDir, ".mcp.json");
+      if (fs15.existsSync(mcpPath)) {
         try {
-          const content = fs14.readFileSync(mcpPath, "utf-8");
+          const content = fs15.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;
+            API_KEY7 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL6 = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL7 = csEnv.CONTEXTSTREAM_API_URL;
           }
         } catch {
         }
       }
     }
-    if (!WORKSPACE_ID4) {
-      const csConfigPath = path15.join(searchDir, ".contextstream", "config.json");
-      if (fs14.existsSync(csConfigPath)) {
+    if (!WORKSPACE_ID5) {
+      const csConfigPath = path16.join(searchDir, ".contextstream", "config.json");
+      if (fs15.existsSync(csConfigPath)) {
         try {
-          const content = fs14.readFileSync(csConfigPath, "utf-8");
+          const content = fs15.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
-            WORKSPACE_ID4 = csConfig.workspace_id;
+            WORKSPACE_ID5 = csConfig.workspace_id;
           }
         } catch {
         }
       }
     }
-    const parentDir = path15.dirname(searchDir);
+    const parentDir = path16.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY6) {
-    const homeMcpPath = path15.join(homedir12(), ".mcp.json");
-    if (fs14.existsSync(homeMcpPath)) {
+  if (!API_KEY7) {
+    const homeMcpPath = path16.join(homedir13(), ".mcp.json");
+    if (fs15.existsSync(homeMcpPath)) {
       try {
-        const content = fs14.readFileSync(homeMcpPath, "utf-8");
+        const content = fs15.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;
+          API_KEY7 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL6 = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL7 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
@@ -3778,7 +4050,7 @@ function loadConfigFromMcpJson4(cwd) {
   }
 }
 async function captureTaskInvocation(description, prompt, agentType, result, sessionId) {
-  if (!API_KEY6) return;
+  if (!API_KEY7) return;
   const payload = {
     event_type: "task_agent",
     title: `Agent: ${agentType} - ${description}`,
@@ -3794,17 +4066,17 @@ async function captureTaskInvocation(description, prompt, agentType, result, ses
     source_type: "hook",
     session_id: sessionId
   };
-  if (WORKSPACE_ID4) {
-    payload.workspace_id = WORKSPACE_ID4;
+  if (WORKSPACE_ID5) {
+    payload.workspace_id = WORKSPACE_ID5;
   }
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 3e3);
-    await fetch(`${API_URL6}/api/v1/memory/events`, {
+    await fetch(`${API_URL7}/api/v1/memory/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY6
+        "X-API-Key": API_KEY7
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -3834,7 +4106,7 @@ async function runOnTaskHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson4(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";
@@ -3844,14 +4116,14 @@ async function runOnTaskHook() {
   });
   process.exit(0);
 }
-var ENABLED9, API_URL6, API_KEY6, WORKSPACE_ID4, isDirectRun9;
+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_URL6 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY6 = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID4 = null;
+    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));
@@ -3864,58 +4136,58 @@ var on_read_exports = {};
 __export(on_read_exports, {
   runOnReadHook: () => runOnReadHook
 });
-import * as fs15 from "node:fs";
-import * as path16 from "node:path";
-import { homedir as homedir13 } from "node:os";
-function loadConfigFromMcpJson5(cwd) {
-  let searchDir = path16.resolve(cwd);
+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_KEY7) {
-      const mcpPath = path16.join(searchDir, ".mcp.json");
-      if (fs15.existsSync(mcpPath)) {
+    if (!API_KEY8) {
+      const mcpPath = path17.join(searchDir, ".mcp.json");
+      if (fs16.existsSync(mcpPath)) {
         try {
-          const content = fs15.readFileSync(mcpPath, "utf-8");
+          const content = fs16.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;
+            API_KEY8 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL7 = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL8 = csEnv.CONTEXTSTREAM_API_URL;
           }
         } catch {
         }
       }
-    }
-    if (!WORKSPACE_ID5) {
-      const csConfigPath = path16.join(searchDir, ".contextstream", "config.json");
-      if (fs15.existsSync(csConfigPath)) {
+    }
+    if (!WORKSPACE_ID6) {
+      const csConfigPath = path17.join(searchDir, ".contextstream", "config.json");
+      if (fs16.existsSync(csConfigPath)) {
         try {
-          const content = fs15.readFileSync(csConfigPath, "utf-8");
+          const content = fs16.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
-            WORKSPACE_ID5 = csConfig.workspace_id;
+            WORKSPACE_ID6 = csConfig.workspace_id;
           }
         } catch {
         }
       }
     }
-    const parentDir = path16.dirname(searchDir);
+    const parentDir = path17.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY7) {
-    const homeMcpPath = path16.join(homedir13(), ".mcp.json");
-    if (fs15.existsSync(homeMcpPath)) {
+  if (!API_KEY8) {
+    const homeMcpPath = path17.join(homedir14(), ".mcp.json");
+    if (fs16.existsSync(homeMcpPath)) {
       try {
-        const content = fs15.readFileSync(homeMcpPath, "utf-8");
+        const content = fs16.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;
+          API_KEY8 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL7 = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL8 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
@@ -3923,7 +4195,7 @@ function loadConfigFromMcpJson5(cwd) {
   }
 }
 async function captureExploration(toolName, target, resultSummary, sessionId) {
-  if (!API_KEY7) return;
+  if (!API_KEY8) return;
   const cacheKey = `${toolName}:${target}`;
   if (recentCaptures.has(cacheKey)) {
     return;
@@ -3944,17 +4216,17 @@ async function captureExploration(toolName, target, resultSummary, sessionId) {
     source_type: "hook",
     session_id: sessionId
   };
-  if (WORKSPACE_ID5) {
-    payload.workspace_id = WORKSPACE_ID5;
+  if (WORKSPACE_ID6) {
+    payload.workspace_id = WORKSPACE_ID6;
   }
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 3e3);
-    await fetch(`${API_URL7}/api/v1/memory/events`, {
+    await fetch(`${API_URL8}/api/v1/memory/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY7
+        "X-API-Key": API_KEY8
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -3985,7 +4257,7 @@ async function runOnReadHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson5(cwd);
+  loadConfigFromMcpJson6(cwd);
   const sessionId = input.session_id || "unknown";
   let target = "";
   let resultSummary = "";
@@ -4011,14 +4283,14 @@ async function runOnReadHook() {
   }
   process.exit(0);
 }
-var ENABLED10, API_URL7, API_KEY7, WORKSPACE_ID5, recentCaptures, CAPTURE_WINDOW_MS, isDirectRun10;
+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_URL7 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY7 = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID5 = null;
+    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";
@@ -4033,58 +4305,58 @@ var on_web_exports = {};
 __export(on_web_exports, {
   runOnWebHook: () => runOnWebHook
 });
-import * as fs16 from "node:fs";
-import * as path17 from "node:path";
-import { homedir as homedir14 } from "node:os";
-function loadConfigFromMcpJson6(cwd) {
-  let searchDir = path17.resolve(cwd);
+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_KEY8) {
-      const mcpPath = path17.join(searchDir, ".mcp.json");
-      if (fs16.existsSync(mcpPath)) {
+    if (!API_KEY9) {
+      const mcpPath = path18.join(searchDir, ".mcp.json");
+      if (fs17.existsSync(mcpPath)) {
         try {
-          const content = fs16.readFileSync(mcpPath, "utf-8");
+          const content = fs17.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;
+            API_KEY9 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL8 = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL9 = csEnv.CONTEXTSTREAM_API_URL;
           }
         } catch {
         }
       }
     }
-    if (!WORKSPACE_ID6) {
-      const csConfigPath = path17.join(searchDir, ".contextstream", "config.json");
-      if (fs16.existsSync(csConfigPath)) {
+    if (!WORKSPACE_ID7) {
+      const csConfigPath = path18.join(searchDir, ".contextstream", "config.json");
+      if (fs17.existsSync(csConfigPath)) {
         try {
-          const content = fs16.readFileSync(csConfigPath, "utf-8");
+          const content = fs17.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
-            WORKSPACE_ID6 = csConfig.workspace_id;
+            WORKSPACE_ID7 = csConfig.workspace_id;
           }
         } catch {
         }
       }
     }
-    const parentDir = path17.dirname(searchDir);
+    const parentDir = path18.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY8) {
-    const homeMcpPath = path17.join(homedir14(), ".mcp.json");
-    if (fs16.existsSync(homeMcpPath)) {
+  if (!API_KEY9) {
+    const homeMcpPath = path18.join(homedir15(), ".mcp.json");
+    if (fs17.existsSync(homeMcpPath)) {
       try {
-        const content = fs16.readFileSync(homeMcpPath, "utf-8");
+        const content = fs17.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;
+          API_KEY9 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL8 = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL9 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
@@ -4092,7 +4364,7 @@ function loadConfigFromMcpJson6(cwd) {
   }
 }
 async function captureWebResearch(toolName, target, summary, sessionId) {
-  if (!API_KEY8) return;
+  if (!API_KEY9) return;
   const payload = {
     event_type: "web_research",
     title: `${toolName}: ${target.slice(0, 60)}`,
@@ -4107,17 +4379,17 @@ async function captureWebResearch(toolName, target, summary, sessionId) {
     source_type: "hook",
     session_id: sessionId
   };
-  if (WORKSPACE_ID6) {
-    payload.workspace_id = WORKSPACE_ID6;
+  if (WORKSPACE_ID7) {
+    payload.workspace_id = WORKSPACE_ID7;
   }
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 3e3);
-    await fetch(`${API_URL8}/api/v1/memory/events`, {
+    await fetch(`${API_URL9}/api/v1/memory/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY8
+        "X-API-Key": API_KEY9
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -4148,7 +4420,7 @@ async function runOnWebHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson6(cwd);
+  loadConfigFromMcpJson7(cwd);
   const sessionId = input.session_id || "unknown";
   let target = "";
   let summary = "";
@@ -4174,14 +4446,14 @@ ${topResults}`;
   }
   process.exit(0);
 }
-var ENABLED11, API_URL8, API_KEY8, WORKSPACE_ID6, isDirectRun11;
+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_URL8 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY8 = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID6 = null;
+    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));
@@ -4194,78 +4466,78 @@ var session_init_exports = {};
 __export(session_init_exports, {
   runSessionInitHook: () => runSessionInitHook
 });
-import * as fs17 from "node:fs";
-import * as path18 from "node:path";
-import { homedir as homedir15 } from "node:os";
-function loadConfigFromMcpJson7(cwd) {
-  let searchDir = path18.resolve(cwd);
+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_KEY9) {
-      const mcpPath = path18.join(searchDir, ".mcp.json");
-      if (fs17.existsSync(mcpPath)) {
+    if (!API_KEY10) {
+      const mcpPath = path19.join(searchDir, ".mcp.json");
+      if (fs18.existsSync(mcpPath)) {
         try {
-          const content = fs17.readFileSync(mcpPath, "utf-8");
+          const content = fs18.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;
+            API_KEY10 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL9 = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL10 = csEnv.CONTEXTSTREAM_API_URL;
           }
           if (csEnv?.CONTEXTSTREAM_WORKSPACE_ID) {
-            WORKSPACE_ID7 = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
+            WORKSPACE_ID8 = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
           }
         } catch {
         }
       }
     }
-    if (!WORKSPACE_ID7 || !PROJECT_ID) {
-      const csConfigPath = path18.join(searchDir, ".contextstream", "config.json");
-      if (fs17.existsSync(csConfigPath)) {
+    if (!WORKSPACE_ID8 || !PROJECT_ID2) {
+      const csConfigPath = path19.join(searchDir, ".contextstream", "config.json");
+      if (fs18.existsSync(csConfigPath)) {
         try {
-          const content = fs17.readFileSync(csConfigPath, "utf-8");
+          const content = fs18.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
-          if (csConfig.workspace_id && !WORKSPACE_ID7) {
-            WORKSPACE_ID7 = csConfig.workspace_id;
+          if (csConfig.workspace_id && !WORKSPACE_ID8) {
+            WORKSPACE_ID8 = csConfig.workspace_id;
           }
-          if (csConfig.project_id && !PROJECT_ID) {
-            PROJECT_ID = csConfig.project_id;
+          if (csConfig.project_id && !PROJECT_ID2) {
+            PROJECT_ID2 = csConfig.project_id;
           }
         } catch {
         }
       }
     }
-    const parentDir = path18.dirname(searchDir);
+    const parentDir = path19.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY9) {
-    const homeMcpPath = path18.join(homedir15(), ".mcp.json");
-    if (fs17.existsSync(homeMcpPath)) {
+  if (!API_KEY10) {
+    const homeMcpPath = path19.join(homedir16(), ".mcp.json");
+    if (fs18.existsSync(homeMcpPath)) {
       try {
-        const content = fs17.readFileSync(homeMcpPath, "utf-8");
+        const content = fs18.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;
+          API_KEY10 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL9 = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL10 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
     }
   }
 }
-async function fetchSessionContext() {
-  if (!API_KEY9) return null;
+async function fetchSessionContext2() {
+  if (!API_KEY10) return null;
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    const url = new URL(`${API_URL9}/api/v1/context`);
-    if (WORKSPACE_ID7) url.searchParams.set("workspace_id", WORKSPACE_ID7);
-    if (PROJECT_ID) url.searchParams.set("project_id", PROJECT_ID);
+    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");
@@ -4274,7 +4546,7 @@ async function fetchSessionContext() {
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "X-API-Key": API_KEY9
+        "X-API-Key": API_KEY10
       },
       signal: controller.signal
     });
@@ -4340,8 +4612,8 @@ async function runSessionInitHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson7(cwd);
-  const context = await fetchSessionContext();
+  loadConfigFromMcpJson8(cwd);
+  const context = await fetchSessionContext2();
   const formattedContext = formatContext(context);
   console.log(
     JSON.stringify({
@@ -4353,15 +4625,15 @@ async function runSessionInitHook() {
   );
   process.exit(0);
 }
-var ENABLED12, API_URL9, API_KEY9, WORKSPACE_ID7, PROJECT_ID, isDirectRun12;
+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_URL9 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY9 = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID7 = null;
-    PROJECT_ID = null;
+    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));
@@ -4374,58 +4646,58 @@ var session_end_exports = {};
 __export(session_end_exports, {
   runSessionEndHook: () => runSessionEndHook
 });
-import * as fs18 from "node:fs";
-import * as path19 from "node:path";
-import { homedir as homedir16 } from "node:os";
-function loadConfigFromMcpJson8(cwd) {
-  let searchDir = path19.resolve(cwd);
+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_KEY10) {
-      const mcpPath = path19.join(searchDir, ".mcp.json");
-      if (fs18.existsSync(mcpPath)) {
+    if (!API_KEY11) {
+      const mcpPath = path20.join(searchDir, ".mcp.json");
+      if (fs19.existsSync(mcpPath)) {
         try {
-          const content = fs18.readFileSync(mcpPath, "utf-8");
+          const content = fs19.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;
+            API_KEY11 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL10 = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL11 = csEnv.CONTEXTSTREAM_API_URL;
           }
         } catch {
         }
       }
     }
-    if (!WORKSPACE_ID8) {
-      const csConfigPath = path19.join(searchDir, ".contextstream", "config.json");
-      if (fs18.existsSync(csConfigPath)) {
+    if (!WORKSPACE_ID9) {
+      const csConfigPath = path20.join(searchDir, ".contextstream", "config.json");
+      if (fs19.existsSync(csConfigPath)) {
         try {
-          const content = fs18.readFileSync(csConfigPath, "utf-8");
+          const content = fs19.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
-            WORKSPACE_ID8 = csConfig.workspace_id;
+            WORKSPACE_ID9 = csConfig.workspace_id;
           }
         } catch {
         }
       }
     }
-    const parentDir = path19.dirname(searchDir);
+    const parentDir = path20.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY10) {
-    const homeMcpPath = path19.join(homedir16(), ".mcp.json");
-    if (fs18.existsSync(homeMcpPath)) {
+  if (!API_KEY11) {
+    const homeMcpPath = path20.join(homedir17(), ".mcp.json");
+    if (fs19.existsSync(homeMcpPath)) {
       try {
-        const content = fs18.readFileSync(homeMcpPath, "utf-8");
+        const content = fs19.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;
+          API_KEY11 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL10 = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL11 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
@@ -4439,11 +4711,11 @@ function parseTranscriptStats(transcriptPath) {
     duration: 0,
     filesModified: []
   };
-  if (!transcriptPath || !fs18.existsSync(transcriptPath)) {
+  if (!transcriptPath || !fs19.existsSync(transcriptPath)) {
     return stats;
   }
   try {
-    const content = fs18.readFileSync(transcriptPath, "utf-8");
+    const content = fs19.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
     let firstTimestamp = null;
     let lastTimestamp = null;
@@ -4485,7 +4757,7 @@ function parseTranscriptStats(transcriptPath) {
   return stats;
 }
 async function finalizeSession(sessionId, stats, reason) {
-  if (!API_KEY10) return;
+  if (!API_KEY11) return;
   const payload = {
     event_type: "session_end",
     title: `Session Ended: ${reason}`,
@@ -4506,17 +4778,17 @@ async function finalizeSession(sessionId, stats, reason) {
     source_type: "hook",
     session_id: sessionId
   };
-  if (WORKSPACE_ID8) {
-    payload.workspace_id = WORKSPACE_ID8;
+  if (WORKSPACE_ID9) {
+    payload.workspace_id = WORKSPACE_ID9;
   }
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    await fetch(`${API_URL10}/api/v1/memory/events`, {
+    await fetch(`${API_URL11}/api/v1/memory/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY10
+        "X-API-Key": API_KEY11
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -4543,7 +4815,7 @@ async function runSessionEndHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson8(cwd);
+  loadConfigFromMcpJson9(cwd);
   const sessionId = input.session_id || "unknown";
   const transcriptPath = input.transcript_path || "";
   const reason = input.reason || "user_exit";
@@ -4551,14 +4823,14 @@ async function runSessionEndHook() {
   await finalizeSession(sessionId, stats, reason);
   process.exit(0);
 }
-var ENABLED13, API_URL10, API_KEY10, WORKSPACE_ID8, isDirectRun13;
+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_URL10 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY10 = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID8 = null;
+    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));
@@ -4712,9 +4984,9 @@ __export(verify_key_exports, {
   runVerifyKey: () => runVerifyKey,
   validateApiKey: () => validateApiKey
 });
-import * as fs19 from "node:fs";
-import * as path20 from "node:path";
-import { homedir as homedir17 } from "node:os";
+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);
@@ -4746,11 +5018,11 @@ function extractFromMcpConfig(config) {
 function getClaudeDesktopConfigPath() {
   const platform = process.platform;
   if (platform === "darwin") {
-    return path20.join(homedir17(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return path21.join(homedir18(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   } else if (platform === "win32") {
-    return path20.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+    return path21.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
   } else {
-    return path20.join(homedir17(), ".config", "Claude", "claude_desktop_config.json");
+    return path21.join(homedir18(), ".config", "Claude", "claude_desktop_config.json");
   }
 }
 function loadApiKey() {
@@ -4767,10 +5039,10 @@ function loadApiKey() {
   }
   let searchDir = process.cwd();
   for (let i = 0; i < 5; i++) {
-    const projectMcpPath = path20.join(searchDir, ".mcp.json");
-    if (fs19.existsSync(projectMcpPath)) {
+    const projectMcpPath = path21.join(searchDir, ".mcp.json");
+    if (fs20.existsSync(projectMcpPath)) {
       try {
-        const content = fs19.readFileSync(projectMcpPath, "utf-8");
+        const content = fs20.readFileSync(projectMcpPath, "utf-8");
         const config = JSON.parse(content);
         const extracted = extractFromMcpConfig(config);
         if (extracted.apiKey) {
@@ -4784,14 +5056,14 @@ function loadApiKey() {
       } catch {
       }
     }
-    const parentDir = path20.dirname(searchDir);
+    const parentDir = path21.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  const globalMcpPath = path20.join(homedir17(), ".mcp.json");
-  if (fs19.existsSync(globalMcpPath)) {
+  const globalMcpPath = path21.join(homedir18(), ".mcp.json");
+  if (fs20.existsSync(globalMcpPath)) {
     try {
-      const content = fs19.readFileSync(globalMcpPath, "utf-8");
+      const content = fs20.readFileSync(globalMcpPath, "utf-8");
       const config = JSON.parse(content);
       const extracted = extractFromMcpConfig(config);
       if (extracted.apiKey) {
@@ -4806,13 +5078,13 @@ function loadApiKey() {
     }
   }
   const cursorPaths = [
-    path20.join(process.cwd(), ".cursor", "mcp.json"),
-    path20.join(homedir17(), ".cursor", "mcp.json")
+    path21.join(process.cwd(), ".cursor", "mcp.json"),
+    path21.join(homedir18(), ".cursor", "mcp.json")
   ];
   for (const cursorPath of cursorPaths) {
-    if (fs19.existsSync(cursorPath)) {
+    if (fs20.existsSync(cursorPath)) {
       try {
-        const content = fs19.readFileSync(cursorPath, "utf-8");
+        const content = fs20.readFileSync(cursorPath, "utf-8");
         const config = JSON.parse(content);
         const extracted = extractFromMcpConfig(config);
         if (extracted.apiKey) {
@@ -4828,9 +5100,9 @@ function loadApiKey() {
     }
   }
   const claudeDesktopPath = getClaudeDesktopConfigPath();
-  if (fs19.existsSync(claudeDesktopPath)) {
+  if (fs20.existsSync(claudeDesktopPath)) {
     try {
-      const content = fs19.readFileSync(claudeDesktopPath, "utf-8");
+      const content = fs20.readFileSync(claudeDesktopPath, "utf-8");
       const config = JSON.parse(content);
       const extracted = extractFromMcpConfig(config);
       if (extracted.apiKey) {
@@ -4845,14 +5117,14 @@ function loadApiKey() {
     }
   }
   const vscodePaths = [
-    path20.join(homedir17(), ".vscode", "mcp.json"),
-    path20.join(homedir17(), ".codeium", "windsurf", "mcp_config.json"),
-    path20.join(homedir17(), ".continue", "config.json")
+    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 (fs19.existsSync(vsPath)) {
+    if (fs20.existsSync(vsPath)) {
       try {
-        const content = fs19.readFileSync(vsPath, "utf-8");
+        const content = fs20.readFileSync(vsPath, "utf-8");
         const config = JSON.parse(content);
         const extracted = extractFromMcpConfig(config);
         if (extracted.apiKey) {
@@ -4867,10 +5139,10 @@ function loadApiKey() {
       }
     }
   }
-  const credentialsPath = path20.join(homedir17(), ".contextstream", "credentials.json");
-  if (fs19.existsSync(credentialsPath)) {
+  const credentialsPath = path21.join(homedir18(), ".contextstream", "credentials.json");
+  if (fs20.existsSync(credentialsPath)) {
     try {
-      const content = fs19.readFileSync(credentialsPath, "utf-8");
+      const content = fs20.readFileSync(credentialsPath, "utf-8");
       const creds = JSON.parse(content);
       if (creds.api_key) {
         apiKey = creds.api_key;
@@ -5465,8 +5737,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path21, errorMaps, issueData } = params;
-  const fullPath = [...path21, ...issueData.path || []];
+  const { data, path: path22, errorMaps, issueData } = params;
+  const fullPath = [...path22, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5582,11 +5854,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path21, key) {
+  constructor(parent, value, path22, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path21;
+    this._path = path22;
     this._key = key;
   }
   get path() {
@@ -9322,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((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
-async function request(config, path21, 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 = path21.startsWith("/api/") ? path21 : `/api/v1${path21}`;
+  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;
@@ -9475,9 +9747,9 @@ function extractErrorCode(payload) {
   if (typeof payload.code === "string" && payload.code.trim()) return payload.code.trim();
   return null;
 }
-function detectIntegrationProvider(path21) {
-  if (/\/github(\/|$)/i.test(path21)) return "github";
-  if (/\/slack(\/|$)/i.test(path21)) return "slack";
+function detectIntegrationProvider(path22) {
+  if (/\/github(\/|$)/i.test(path22)) return "github";
+  if (/\/slack(\/|$)/i.test(path22)) return "slack";
   return null;
 }
 function rewriteNotFoundMessage(input) {
@@ -10130,10 +10402,10 @@ var PROJECT_MARKERS = [
 ];
 function isMultiProjectFolder(folderPath) {
   try {
-    const fs20 = __require("fs");
+    const fs21 = __require("fs");
     const pathModule = __require("path");
-    const rootHasGit = fs20.existsSync(pathModule.join(folderPath, ".git"));
-    const entries = fs20.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"
     );
@@ -10141,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 (fs20.existsSync(pathModule.join(subdirPath, marker))) {
+        if (fs21.existsSync(pathModule.join(subdirPath, marker))) {
           projectSubdirs.push(subdir.name);
           break;
         }
@@ -12208,9 +12480,9 @@ var ContextStreamClient = class {
           candidateParts.push("## Relevant Code\n");
           currentChars += 18;
           const codeEntries = code.results.map((c) => {
-            const path21 = c.file_path || "file";
+            const path22 = c.file_path || "file";
             const content = c.content?.slice(0, 150) || "";
-            return { path: path21, entry: `\u2022 ${path21}: ${content}...
+            return { path: path22, entry: `\u2022 ${path22}: ${content}...
 ` };
           });
           for (const c of codeEntries) {
@@ -14724,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",
@@ -14807,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;
   }
@@ -15920,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, path21) {
+function buildParamDescription(key, path22) {
   const normalized = key in DEFAULT_PARAM_DESCRIPTIONS ? key : key.toLowerCase();
-  const parent = path21[path21.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).";
@@ -15953,7 +16365,7 @@ function getDescription(schema) {
   if (def?.description && def.description.trim()) return def.description;
   return void 0;
 }
-function applyParamDescriptions(schema, path21 = []) {
+function applyParamDescriptions(schema, path22 = []) {
   if (!(schema instanceof external_exports.ZodObject)) {
     return schema;
   }
@@ -15964,7 +16376,7 @@ function applyParamDescriptions(schema, path21 = []) {
     let nextField = field;
     const existingDescription = getDescription(field);
     if (field instanceof external_exports.ZodObject) {
-      const nested = applyParamDescriptions(field, [...path21, key]);
+      const nested = applyParamDescriptions(field, [...path22, key]);
       if (nested !== field) {
         nextField = nested;
         changed = true;
@@ -15976,7 +16388,7 @@ function applyParamDescriptions(schema, path21 = []) {
         changed = true;
       }
     } else {
-      nextField = nextField.describe(buildParamDescription(key, path21));
+      nextField = nextField.describe(buildParamDescription(key, path22));
       changed = true;
     }
     nextShape[key] = nextField;
@@ -24973,13 +25385,13 @@ Example workflow:
               );
             }
             if (input.file_path) {
-              const fs20 = 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 fs20.stat(resolvedPath);
+                fileStats = await fs21.stat(resolvedPath);
               } catch {
                 return errorResult(`File not found: ${resolvedPath}`);
               }
@@ -25026,7 +25438,7 @@ Example workflow:
                   mime_type: mimeType,
                   tags: input.tags
                 });
-                const fileBuffer = await fs20.readFile(resolvedPath);
+                const fileBuffer = await fs21.readFile(resolvedPath);
                 const uploadResponse = await fetch(uploadInit.upload_url, {
                   method: "PUT",
                   headers: uploadInit.headers,
@@ -26433,8 +26845,8 @@ var SessionManager = class _SessionManager {
   /**
    * Set the folder path hint (can be passed from tools that know the workspace path)
    */
-  setFolderPath(path21) {
-    this.folderPath = path21;
+  setFolderPath(path22) {
+    this.folderPath = path22;
   }
   /**
    * Mark that context_smart has been called in this session.
@@ -26624,7 +27036,7 @@ var SessionManager = class _SessionManager {
     }
     if (this.ideRoots.length === 0) {
       const cwd = process.cwd();
-      const fs20 = await import("fs");
+      const fs21 = await import("fs");
       const projectIndicators = [
         ".git",
         "package.json",
@@ -26634,7 +27046,7 @@ var SessionManager = class _SessionManager {
       ];
       const hasProjectIndicator = projectIndicators.some((f) => {
         try {
-          return fs20.existsSync(`${cwd}/${f}`);
+          return fs21.existsSync(`${cwd}/${f}`);
         } catch {
           return false;
         }
@@ -27211,9 +27623,9 @@ async function runHttpGateway() {
 }
 
 // src/index.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir18 } from "os";
-import { join as join22 } 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";
@@ -28043,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((resolve15) => setTimeout(resolve15, waitMs));
+            await new Promise((resolve16) => setTimeout(resolve16, waitMs));
             continue;
           }
-          await new Promise((resolve15) => setTimeout(resolve15, 1e3));
+          await new Promise((resolve16) => setTimeout(resolve16, 1e3));
         }
         if (!accessToken) {
           throw new Error(
@@ -28611,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 = join22(homedir18(), ".contextstream");
-  const starShownFile = join22(configDir, ".star-shown");
-  if (existsSync16(starShownFile)) {
+  const configDir = join23(homedir19(), ".contextstream");
+  const starShownFile = join23(configDir, ".star-shown");
+  if (existsSync17(starShownFile)) {
     return;
   }
-  if (!existsSync16(configDir)) {
+  if (!existsSync17(configDir)) {
     try {
       mkdirSync5(configDir, { recursive: true });
     } catch {