@contextstream/mcp-server 0.4.51 → 0.4.53

package/dist/hooks/runner.js

@@ -97,8 +97,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}`
+    }
+  };
+  fs.appendFileSync(DEBUG_FILE, `[PreToolUse] REDIRECT (additionalContext): ${JSON.stringify(response)}
+`);
+  console.log(JSON.stringify(response));
+  process.exit(0);
 }
 function outputClineBlock(errorMessage, contextMod) {
   const result = {
@@ -127,13 +136,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() {
+  fs.appendFileSync(DEBUG_FILE, `[PreToolUse] Hook invoked at ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+  console.error("[PreToolUse] Hook invoked at", (/* @__PURE__ */ new Date()).toISOString());
   if (!ENABLED) {
+    fs.appendFileSync(DEBUG_FILE, "[PreToolUse] Hook disabled, exiting\n");
+    console.error("[PreToolUse] Hook disabled, exiting");
     process.exit(0);
   }
   let inputData = "";
@@ -153,8 +167,14 @@ async function runPreToolUseHook() {
   const cwd = extractCwd(input);
   const tool = extractToolName(input);
   const toolInput = extractToolInput(input);
+  fs.appendFileSync(DEBUG_FILE, `[PreToolUse] tool=${tool}, cwd=${cwd}, editorFormat=${editorFormat}
+`);
   const { isIndexed } = isProjectIndexed(cwd);
+  fs.appendFileSync(DEBUG_FILE, `[PreToolUse] isIndexed=${isIndexed}
+`);
   if (!isIndexed) {
+    fs.appendFileSync(DEBUG_FILE, `[PreToolUse] Project not indexed, allowing
+`);
     if (editorFormat === "cline") {
       outputClineAllow();
     } else if (editorFormat === "cursor") {
@@ -164,8 +184,12 @@ async function runPreToolUseHook() {
   }
   if (tool === "Glob") {
     const pattern = toolInput?.pattern || "";
+    fs.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.`;
+      fs.appendFileSync(DEBUG_FILE, `[PreToolUse] Intercepting discovery glob: ${msg}
+`);
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
       } else if (editorFormat === "cursor") {
@@ -242,12 +266,13 @@ async function runPreToolUseHook() {
   }
   process.exit(0);
 }
-var ENABLED, INDEX_STATUS_FILE, STALE_THRESHOLD_DAYS, DISCOVERY_PATTERNS, isDirectRun;
+var ENABLED, INDEX_STATUS_FILE, DEBUG_FILE, STALE_THRESHOLD_DAYS, DISCOVERY_PATTERNS, isDirectRun;
 var init_pre_tool_use = __esm({
   "src/hooks/pre-tool-use.ts"() {
     "use strict";
     ENABLED = process.env.CONTEXTSTREAM_HOOK_ENABLED !== "false";
     INDEX_STATUS_FILE = path.join(homedir(), ".contextstream", "indexed-projects.json");
+    DEBUG_FILE = "/tmp/pretooluse-hook-debug.log";
     STALE_THRESHOLD_DAYS = 7;
     DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"];
     isDirectRun = process.argv[1]?.includes("pre-tool-use") || process.argv[2] === "pre-tool-use";
@@ -262,6 +287,184 @@ var user_prompt_submit_exports = {};
 __export(user_prompt_submit_exports, {
   runUserPromptSubmitHook: () => runUserPromptSubmitHook
 });
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path2.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path2.join(searchDir, ".mcp.json");
+      if (fs2.existsSync(mcpPath)) {
+        try {
+          const content = fs2.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          }
+          if (csEnv?.CONTEXTSTREAM_WORKSPACE_ID) {
+            WORKSPACE_ID = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID || !PROJECT_ID) {
+      const csConfigPath = path2.join(searchDir, ".contextstream", "config.json");
+      if (fs2.existsSync(csConfigPath)) {
+        try {
+          const content = fs2.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 = path2.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path2.join(homedir2(), ".mcp.json");
+    if (fs2.existsSync(homeMcpPath)) {
+      try {
+        const content = fs2.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function fetchSessionContext() {
+  if (!API_KEY) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    const url = new URL(`${API_URL}/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_KEY
+      },
+      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";
@@ -269,8 +472,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 (!ENABLED2) {
     process.exit(0);
@@ -289,6 +507,7 @@ async function runUserPromptSubmitHook() {
     process.exit(0);
   }
   const editorFormat = detectEditorFormat2(input);
+  const cwd = input.cwd || process.cwd();
   if (editorFormat === "claude") {
     console.log(
       JSON.stringify({
@@ -299,37 +518,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 ENABLED2, REMINDER, isDirectRun2;
+var ENABLED2, API_URL, API_KEY, WORKSPACE_ID, PROJECT_ID, REMINDER, ENHANCED_REMINDER_HEADER, isDirectRun2;
 var init_user_prompt_submit = __esm({
   "src/hooks/user-prompt-submit.ts"() {
     "use strict";
     ENABLED2 = 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_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY = 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]
+
+`;
     isDirectRun2 = process.argv[1]?.includes("user-prompt-submit") || process.argv[2] === "user-prompt-submit";
     if (isDirectRun2) {
       runUserPromptSubmitHook().catch(() => process.exit(0));
@@ -451,58 +717,58 @@ var pre_compact_exports = {};
 __export(pre_compact_exports, {
   runPreCompactHook: () => runPreCompactHook
 });
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import { homedir as homedir2 } from "node:os";
-function loadConfigFromMcpJson(cwd) {
-  let searchDir = path2.resolve(cwd);
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import { homedir as homedir3 } from "node:os";
+function loadConfigFromMcpJson2(cwd) {
+  let searchDir = path3.resolve(cwd);
   for (let i = 0; i < 5; i++) {
-    if (!API_KEY) {
-      const mcpPath = path2.join(searchDir, ".mcp.json");
-      if (fs2.existsSync(mcpPath)) {
+    if (!API_KEY2) {
+      const mcpPath = path3.join(searchDir, ".mcp.json");
+      if (fs3.existsSync(mcpPath)) {
         try {
-          const content = fs2.readFileSync(mcpPath, "utf-8");
+          const content = fs3.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
-            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+            API_KEY2 = csEnv.CONTEXTSTREAM_API_KEY;
           }
           if (csEnv?.CONTEXTSTREAM_API_URL) {
-            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+            API_URL2 = csEnv.CONTEXTSTREAM_API_URL;
           }
         } catch {
         }
       }
     }
-    if (!WORKSPACE_ID) {
-      const csConfigPath = path2.join(searchDir, ".contextstream", "config.json");
-      if (fs2.existsSync(csConfigPath)) {
+    if (!WORKSPACE_ID2) {
+      const csConfigPath = path3.join(searchDir, ".contextstream", "config.json");
+      if (fs3.existsSync(csConfigPath)) {
         try {
-          const content = fs2.readFileSync(csConfigPath, "utf-8");
+          const content = fs3.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 = path2.dirname(searchDir);
+    const parentDir = path3.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
-  if (!API_KEY) {
-    const homeMcpPath = path2.join(homedir2(), ".mcp.json");
-    if (fs2.existsSync(homeMcpPath)) {
+  if (!API_KEY2) {
+    const homeMcpPath = path3.join(homedir3(), ".mcp.json");
+    if (fs3.existsSync(homeMcpPath)) {
       try {
-        const content = fs2.readFileSync(homeMcpPath, "utf-8");
+        const content = fs3.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
-          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          API_KEY2 = csEnv.CONTEXTSTREAM_API_KEY;
         }
         if (csEnv?.CONTEXTSTREAM_API_URL) {
-          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          API_URL2 = csEnv.CONTEXTSTREAM_API_URL;
         }
       } catch {
       }
@@ -517,7 +783,7 @@ function parseTranscript(transcriptPath) {
   let startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let firstTimestamp = true;
   try {
-    const content = fs2.readFileSync(transcriptPath, "utf-8");
+    const content = fs3.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       if (!line.trim()) continue;
@@ -598,7 +864,7 @@ function parseTranscript(transcriptPath) {
   };
 }
 async function saveFullTranscript(sessionId, transcriptData, trigger) {
-  if (!API_KEY) {
+  if (!API_KEY2) {
     return { success: false, message: "No API key configured" };
   }
   if (transcriptData.messages.length === 0) {
@@ -617,17 +883,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_URL}/api/v1/transcripts`, {
+    const response = await fetch(`${API_URL2}/api/v1/transcripts`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY
+        "X-API-Key": API_KEY2
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -642,7 +908,7 @@ async function saveFullTranscript(sessionId, transcriptData, trigger) {
   }
 }
 async function saveSnapshot(sessionId, transcriptData, trigger) {
-  if (!API_KEY) {
+  if (!API_KEY2) {
     return { success: false, message: "No API key configured" };
   }
   const snapshotContent = {
@@ -663,17 +929,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_URL}/api/v1/memory/events`, {
+    const response = await fetch(`${API_URL2}/api/v1/memory/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": API_KEY
+        "X-API-Key": API_KEY2
       },
       body: JSON.stringify(payload),
       signal: controller.signal
@@ -705,7 +971,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";
@@ -714,13 +980,15 @@ async function runPreCompactHook() {
     activeFiles: [],
     toolCallCount: 0,
     messageCount: 0,
-    lastTools: []
+    lastTools: [],
+    messages: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (transcriptPath && fs2.existsSync(transcriptPath)) {
+  if (transcriptPath && fs3.existsSync(transcriptPath)) {
     transcriptData = parseTranscript(transcriptPath);
   }
   let autoSaveStatus = "";
-  if (AUTO_SAVE && API_KEY) {
+  if (AUTO_SAVE && API_KEY2) {
     const transcriptResult = await saveFullTranscript(sessionId, transcriptData, trigger);
     if (transcriptResult.success) {
       autoSaveStatus = `
@@ -754,15 +1022,15 @@ User instructions: ${customInstructions}` : ""}`;
   );
   process.exit(0);
 }
-var ENABLED4, AUTO_SAVE, API_URL, API_KEY, WORKSPACE_ID, isDirectRun4;
+var ENABLED4, AUTO_SAVE, API_URL2, API_KEY2, WORKSPACE_ID2, isDirectRun4;
 var init_pre_compact = __esm({
   "src/hooks/pre-compact.ts"() {
     "use strict";
     ENABLED4 = process.env.CONTEXTSTREAM_PRECOMPACT_ENABLED !== "false";
     AUTO_SAVE = process.env.CONTEXTSTREAM_PRECOMPACT_AUTO_SAVE !== "false";
-    API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
-    WORKSPACE_ID = null;
+    API_URL2 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY2 = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID2 = null;
     isDirectRun4 = process.argv[1]?.includes("pre-compact") || process.argv[2] === "pre-compact";
     if (isDirectRun4) {
       runPreCompactHook().catch(() => process.exit(0));
@@ -775,9 +1043,9 @@ var post_write_exports = {};
 __export(post_write_exports, {
   runPostWriteHook: () => runPostWriteHook
 });
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-import { homedir as homedir3 } from "node:os";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+import { homedir as homedir4 } from "node:os";
 function extractFilePath(input) {
   if (input.tool_input) {
     const filePath = input.tool_input.file_path || input.tool_input.notebook_path || input.tool_input.path;
@@ -802,34 +1070,34 @@ function extractCwd2(input) {
   return process.cwd();
 }
 function findLocalConfig(startDir) {
-  let currentDir = path3.resolve(startDir);
+  let currentDir = path4.resolve(startDir);
   for (let i = 0; i < 10; i++) {
-    const configPath = path3.join(currentDir, ".contextstream", "config.json");
-    if (fs3.existsSync(configPath)) {
+    const configPath = path4.join(currentDir, ".contextstream", "config.json");
+    if (fs4.existsSync(configPath)) {
       try {
-        const content = fs3.readFileSync(configPath, "utf-8");
+        const content = fs4.readFileSync(configPath, "utf-8");
         return JSON.parse(content);
       } catch {
       }
     }
-    const parentDir = path3.dirname(currentDir);
+    const parentDir = path4.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
   return null;
 }
 function loadApiConfig(startDir) {
-  let apiUrl = API_URL2;
-  let apiKey = API_KEY2;
+  let apiUrl = API_URL3;
+  let apiKey = API_KEY3;
   if (apiKey) {
     return { apiUrl, apiKey };
   }
-  let currentDir = path3.resolve(startDir);
+  let currentDir = path4.resolve(startDir);
   for (let i = 0; i < 10; i++) {
-    const mcpPath = path3.join(currentDir, ".mcp.json");
-    if (fs3.existsSync(mcpPath)) {
+    const mcpPath = path4.join(currentDir, ".mcp.json");
+    if (fs4.existsSync(mcpPath)) {
       try {
-        const content = fs3.readFileSync(mcpPath, "utf-8");
+        const content = fs4.readFileSync(mcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -842,15 +1110,15 @@ function loadApiConfig(startDir) {
       } catch {
       }
     }
-    const parentDir = path3.dirname(currentDir);
+    const parentDir = path4.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
   if (!apiKey) {
-    const homeMcpPath = path3.join(homedir3(), ".mcp.json");
-    if (fs3.existsSync(homeMcpPath)) {
+    const homeMcpPath = path4.join(homedir4(), ".mcp.json");
+    if (fs4.existsSync(homeMcpPath)) {
       try {
-        const content = fs3.readFileSync(homeMcpPath, "utf-8");
+        const content = fs4.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -866,15 +1134,15 @@ function loadApiConfig(startDir) {
   return { apiUrl, apiKey };
 }
 function shouldIndexFile(filePath) {
-  const ext = path3.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   if (!INDEXABLE_EXTENSIONS.has(ext)) {
-    const basename2 = path3.basename(filePath).toLowerCase();
+    const basename2 = path4.basename(filePath).toLowerCase();
     if (!["dockerfile", "makefile", "rakefile", "gemfile", "procfile"].includes(basename2)) {
       return false;
     }
   }
   try {
-    const stats = fs3.statSync(filePath);
+    const stats = fs4.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE) {
       return false;
     }
@@ -884,7 +1152,7 @@ function shouldIndexFile(filePath) {
   return true;
 }
 function detectLanguage(filePath) {
-  const ext = path3.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   const langMap = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -953,8 +1221,8 @@ function detectLanguage(filePath) {
   return langMap[ext] || "text";
 }
 async function indexFile(filePath, projectId, apiUrl, apiKey, projectRoot) {
-  const content = fs3.readFileSync(filePath, "utf-8");
-  const relativePath = path3.relative(projectRoot, filePath);
+  const content = fs4.readFileSync(filePath, "utf-8");
+  const relativePath = path4.relative(projectRoot, filePath);
   const payload = {
     files: [
       {
@@ -979,13 +1247,13 @@ async function indexFile(filePath, projectId, apiUrl, apiKey, projectRoot) {
   }
 }
 function findProjectRoot(filePath) {
-  let currentDir = path3.dirname(path3.resolve(filePath));
+  let currentDir = path4.dirname(path4.resolve(filePath));
   for (let i = 0; i < 10; i++) {
-    const configPath = path3.join(currentDir, ".contextstream", "config.json");
-    if (fs3.existsSync(configPath)) {
+    const configPath = path4.join(currentDir, ".contextstream", "config.json");
+    if (fs4.existsSync(configPath)) {
       return currentDir;
     }
-    const parentDir = path3.dirname(currentDir);
+    const parentDir = path4.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -1013,8 +1281,8 @@ async function runPostWriteHook() {
     process.exit(0);
   }
   const cwd = extractCwd2(input);
-  const absolutePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(cwd, filePath);
-  if (!fs3.existsSync(absolutePath) || !shouldIndexFile(absolutePath)) {
+  const absolutePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(cwd, filePath);
+  if (!fs4.existsSync(absolutePath) || !shouldIndexFile(absolutePath)) {
     process.exit(0);
   }
   const projectRoot = findProjectRoot(absolutePath);
@@ -1035,12 +1303,12 @@ async function runPostWriteHook() {
   }
   process.exit(0);
 }
-var API_URL2, API_KEY2, ENABLED5, INDEXABLE_EXTENSIONS, MAX_FILE_SIZE, isDirectRun5;
+var API_URL3, API_KEY3, ENABLED5, INDEXABLE_EXTENSIONS, MAX_FILE_SIZE, isDirectRun5;
 var init_post_write = __esm({
   "src/hooks/post-write.ts"() {
     "use strict";
-    API_URL2 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-    API_KEY2 = process.env.CONTEXTSTREAM_API_KEY || "";
+    API_URL3 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY3 = process.env.CONTEXTSTREAM_API_KEY || "";
     ENABLED5 = process.env.CONTEXTSTREAM_POSTWRITE_ENABLED !== "false";
     INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([
       ".ts",
@@ -1159,16 +1427,20 @@ __export(hooks_config_exports, {
   writeCursorHooksConfig: () => writeCursorHooksConfig,
   writeIndexStatus: () => writeIndexStatus
 });
-import * as fs4 from "node:fs/promises";
-import * as path4 from "node:path";
-import { homedir as homedir4 } from "node:os";
+import * as fs5 from "node:fs/promises";
+import * as path5 from "node:path";
+import { homedir as homedir5 } from "node:os";
 import { fileURLToPath } from "node:url";
 function getHookCommand(hookName2) {
+  const fs7 = __require("node:fs");
+  const binaryPath = "/usr/local/bin/contextstream-mcp";
+  if (fs7.existsSync(binaryPath)) {
+    return `${binaryPath} hook ${hookName2}`;
+  }
   try {
-    const __dirname = path4.dirname(fileURLToPath(import.meta.url));
-    const indexPath = path4.join(__dirname, "index.js");
-    const fs6 = __require("node:fs");
-    if (fs6.existsSync(indexPath)) {
+    const __dirname = path5.dirname(fileURLToPath(import.meta.url));
+    const indexPath = path5.join(__dirname, "index.js");
+    if (fs7.existsSync(indexPath)) {
       return `node ${indexPath} hook ${hookName2}`;
     }
   } catch {
@@ -1177,15 +1449,15 @@ function getHookCommand(hookName2) {
 }
 function getClaudeSettingsPath(scope, projectPath) {
   if (scope === "user") {
-    return path4.join(homedir4(), ".claude", "settings.json");
+    return path5.join(homedir5(), ".claude", "settings.json");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path4.join(projectPath, ".claude", "settings.json");
+  return path5.join(projectPath, ".claude", "settings.json");
 }
 function getHooksDir() {
-  return path4.join(homedir4(), ".claude", "hooks");
+  return path5.join(homedir5(), ".claude", "hooks");
 }
 function buildHooksConfig(options) {
   const userPromptHooks = [
@@ -1361,7 +1633,7 @@ function buildHooksConfig(options) {
 }
 async function installHookScripts(options) {
   const hooksDir = getHooksDir();
-  await fs4.mkdir(hooksDir, { recursive: true });
+  await fs5.mkdir(hooksDir, { recursive: true });
   const result = {
     preToolUse: getHookCommand("pre-tool-use"),
     userPrompt: getHookCommand("user-prompt-submit")
@@ -1380,7 +1652,7 @@ async function installHookScripts(options) {
 async function readClaudeSettings(scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
   try {
-    const content = await fs4.readFile(settingsPath, "utf-8");
+    const content = await fs5.readFile(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -1388,9 +1660,9 @@ async function readClaudeSettings(scope, projectPath) {
 }
 async function writeClaudeSettings(settings, scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
-  const dir = path4.dirname(settingsPath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  const dir = path5.dirname(settingsPath);
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 function mergeHooksIntoSettings(existingSettings, newHooks) {
   const settings = { ...existingSettings };
@@ -1540,12 +1812,12 @@ If you prefer to configure manually, add to \`~/.claude/settings.json\`:
 `.trim();
 }
 function getIndexStatusPath() {
-  return path4.join(homedir4(), ".contextstream", "indexed-projects.json");
+  return path5.join(homedir5(), ".contextstream", "indexed-projects.json");
 }
 async function readIndexStatus() {
   const statusPath = getIndexStatusPath();
   try {
-    const content = await fs4.readFile(statusPath, "utf-8");
+    const content = await fs5.readFile(statusPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, projects: {} };
@@ -1553,13 +1825,13 @@ async function readIndexStatus() {
 }
 async function writeIndexStatus(status) {
   const statusPath = getIndexStatusPath();
-  const dir = path4.dirname(statusPath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.writeFile(statusPath, JSON.stringify(status, null, 2));
+  const dir = path5.dirname(statusPath);
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.writeFile(statusPath, JSON.stringify(status, null, 2));
 }
 async function markProjectIndexed(projectPath, options) {
   const status = await readIndexStatus();
-  const resolvedPath = path4.resolve(projectPath);
+  const resolvedPath = path5.resolve(projectPath);
   status.projects[resolvedPath] = {
     indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_id: options?.project_id,
@@ -1569,113 +1841,113 @@ async function markProjectIndexed(projectPath, options) {
 }
 async function unmarkProjectIndexed(projectPath) {
   const status = await readIndexStatus();
-  const resolvedPath = path4.resolve(projectPath);
+  const resolvedPath = path5.resolve(projectPath);
   delete status.projects[resolvedPath];
   await writeIndexStatus(status);
 }
 function getClineHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path4.join(homedir4(), "Documents", "Cline", "Rules", "Hooks");
+    return path5.join(homedir5(), "Documents", "Cline", "Rules", "Hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path4.join(projectPath, ".clinerules", "hooks");
+  return path5.join(projectPath, ".clinerules", "hooks");
 }
 async function installClineHookScripts(options) {
   const hooksDir = getClineHooksDir(options.scope, options.projectPath);
-  await fs4.mkdir(hooksDir, { recursive: true });
-  const preToolUsePath = path4.join(hooksDir, "PreToolUse");
-  const userPromptPath = path4.join(hooksDir, "UserPromptSubmit");
-  const postToolUsePath = path4.join(hooksDir, "PostToolUse");
-  await fs4.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
-  await fs4.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  await fs5.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path5.join(hooksDir, "PostToolUse");
+  await fs5.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs5.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
   const result = {
     preToolUse: preToolUsePath,
     userPromptSubmit: userPromptPath
   };
   if (options.includePostWrite !== false) {
-    await fs4.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    await fs5.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getRooCodeHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path4.join(homedir4(), ".roo", "hooks");
+    return path5.join(homedir5(), ".roo", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path4.join(projectPath, ".roo", "hooks");
+  return path5.join(projectPath, ".roo", "hooks");
 }
 async function installRooCodeHookScripts(options) {
   const hooksDir = getRooCodeHooksDir(options.scope, options.projectPath);
-  await fs4.mkdir(hooksDir, { recursive: true });
-  const preToolUsePath = path4.join(hooksDir, "PreToolUse");
-  const userPromptPath = path4.join(hooksDir, "UserPromptSubmit");
-  const postToolUsePath = path4.join(hooksDir, "PostToolUse");
-  await fs4.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
-  await fs4.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  await fs5.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path5.join(hooksDir, "PostToolUse");
+  await fs5.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs5.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
   const result = {
     preToolUse: preToolUsePath,
     userPromptSubmit: userPromptPath
   };
   if (options.includePostWrite !== false) {
-    await fs4.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    await fs5.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getKiloCodeHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path4.join(homedir4(), ".kilocode", "hooks");
+    return path5.join(homedir5(), ".kilocode", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path4.join(projectPath, ".kilocode", "hooks");
+  return path5.join(projectPath, ".kilocode", "hooks");
 }
 async function installKiloCodeHookScripts(options) {
   const hooksDir = getKiloCodeHooksDir(options.scope, options.projectPath);
-  await fs4.mkdir(hooksDir, { recursive: true });
-  const preToolUsePath = path4.join(hooksDir, "PreToolUse");
-  const userPromptPath = path4.join(hooksDir, "UserPromptSubmit");
-  const postToolUsePath = path4.join(hooksDir, "PostToolUse");
-  await fs4.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
-  await fs4.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  await fs5.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path5.join(hooksDir, "PostToolUse");
+  await fs5.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs5.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
   const result = {
     preToolUse: preToolUsePath,
     userPromptSubmit: userPromptPath
   };
   if (options.includePostWrite !== false) {
-    await fs4.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    await fs5.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getCursorHooksConfigPath(scope, projectPath) {
   if (scope === "global") {
-    return path4.join(homedir4(), ".cursor", "hooks.json");
+    return path5.join(homedir5(), ".cursor", "hooks.json");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path4.join(projectPath, ".cursor", "hooks.json");
+  return path5.join(projectPath, ".cursor", "hooks.json");
 }
 function getCursorHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path4.join(homedir4(), ".cursor", "hooks");
+    return path5.join(homedir5(), ".cursor", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path4.join(projectPath, ".cursor", "hooks");
+  return path5.join(projectPath, ".cursor", "hooks");
 }
 async function readCursorHooksConfig(scope, projectPath) {
   const configPath = getCursorHooksConfigPath(scope, projectPath);
   try {
-    const content = await fs4.readFile(configPath, "utf-8");
+    const content = await fs5.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, hooks: {} };
@@ -1683,13 +1955,13 @@ async function readCursorHooksConfig(scope, projectPath) {
 }
 async function writeCursorHooksConfig(config, scope, projectPath) {
   const configPath = getCursorHooksConfigPath(scope, projectPath);
-  const dir = path4.dirname(configPath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.writeFile(configPath, JSON.stringify(config, null, 2));
+  const dir = path5.dirname(configPath);
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.writeFile(configPath, JSON.stringify(config, null, 2));
 }
 async function installCursorHookScripts(options) {
   const hooksDir = getCursorHooksDir(options.scope, options.projectPath);
-  await fs4.mkdir(hooksDir, { recursive: true });
+  await fs5.mkdir(hooksDir, { recursive: true });
   const existingConfig = await readCursorHooksConfig(options.scope, options.projectPath);
   const filterContextStreamHooks = (hooks2) => {
     if (!hooks2) return [];
@@ -2712,13 +2984,13 @@ var auto_rules_exports = {};
 __export(auto_rules_exports, {
   runAutoRulesHook: () => runAutoRulesHook
 });
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
-import { homedir as homedir5 } from "node:os";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import { homedir as homedir6 } from "node:os";
 function hasRunRecently() {
   try {
-    if (!fs5.existsSync(MARKER_FILE)) return false;
-    const stat = fs5.statSync(MARKER_FILE);
+    if (!fs6.existsSync(MARKER_FILE)) return false;
+    const stat = fs6.statSync(MARKER_FILE);
     const age = Date.now() - stat.mtimeMs;
     return age < COOLDOWN_MS;
   } catch {
@@ -2727,11 +2999,11 @@ function hasRunRecently() {
 }
 function markAsRan() {
   try {
-    const dir = path5.dirname(MARKER_FILE);
-    if (!fs5.existsSync(dir)) {
-      fs5.mkdirSync(dir, { recursive: true });
+    const dir = path6.dirname(MARKER_FILE);
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
     }
-    fs5.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
+    fs6.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
 }
@@ -2760,8 +3032,8 @@ function extractCwd3(input) {
 }
 function hasPythonHooks(settingsPath) {
   try {
-    if (!fs5.existsSync(settingsPath)) return false;
-    const content = fs5.readFileSync(settingsPath, "utf-8");
+    if (!fs6.existsSync(settingsPath)) return false;
+    const content = fs6.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(content);
     const hooks2 = settings.hooks;
     if (!hooks2) return false;
@@ -2785,8 +3057,8 @@ function hasPythonHooks(settingsPath) {
   }
 }
 function detectPythonHooks(cwd) {
-  const globalSettingsPath = path5.join(homedir5(), ".claude", "settings.json");
-  const projectSettingsPath = path5.join(cwd, ".claude", "settings.json");
+  const globalSettingsPath = path6.join(homedir6(), ".claude", "settings.json");
+  const projectSettingsPath = path6.join(cwd, ".claude", "settings.json");
   return {
     global: hasPythonHooks(globalSettingsPath),
     project: hasPythonHooks(projectSettingsPath)
@@ -2844,14 +3116,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 = path5.join(homedir5(), ".contextstream", ".auto-rules-ran");
+    MARKER_FILE = path6.join(homedir6(), ".contextstream", ".auto-rules-ran");
     COOLDOWN_MS = 4 * 60 * 60 * 1e3;
     isDirectRun6 = process.argv[1]?.includes("auto-rules") || process.argv[2] === "auto-rules";
     if (isDirectRun6) {