@contextstream/mcp-server 0.4.50 → 0.4.53

package/dist/hooks/on-save-intent.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+// src/hooks/on-save-intent.ts
+var ENABLED = process.env.CONTEXTSTREAM_SAVE_INTENT_ENABLED !== "false";
+var SAVE_PATTERNS = [
+  // Direct save requests
+  /\b(save|store|record|capture|log|document|write down|note down|keep track)\b.*\b(this|that|it|the)\b/i,
+  /\b(save|store|record|capture|log)\b.*\b(to|in|for)\b.*\b(contextstream|memory|later|reference|future)\b/i,
+  // Document creation
+  /\b(create|make|write|draft)\b.*\b(a|the)\b.*\b(document|doc|note|summary|report|spec|design)\b/i,
+  /\b(document|summarize|write up)\b.*\b(this|that|the|our)\b.*\b(decision|discussion|conversation|meeting|finding)\b/i,
+  // Memory/reference requests
+  /\b(remember|don't forget|keep in mind|note that|important to remember)\b/i,
+  /\bfor\s+(future|later)\s+reference\b/i,
+  /\b(add|put)\s+(this|it|that)\s+(to|in)\s+(memory|notes|docs)\b/i,
+  // Decision tracking
+  /\b(we\s+)?(decided|agreed|concluded|determined)\b.*\b(to|that)\b/i,
+  /\blet('s|s)\s+document\b/i,
+  /\bsave\s+(this|the)\s+(decision|choice|approach)\b/i,
+  // Implementation/design docs
+  /\b(implementation|design|architecture|spec)\s+(doc|document|plan)\b/i,
+  /\bwrite\s+(the|a|an)\s+.*(md|markdown|readme)\b/i
+];
+var LOCAL_FILE_PATTERNS = [
+  /\b(save|write|create)\s+(it|this|the\s+\w+)\s+(to|in|as)\s+[./~]/i,
+  /\b(save|write)\s+to\s+.*(\.md|\.txt|\.json|docs\/|notes\/)/i,
+  /\bcreate\s+(a|the)\s+file\b/i
+];
+function detectsSaveIntent(text) {
+  const hasSaveIntent = SAVE_PATTERNS.some((p) => p.test(text));
+  const isLocalFile = LOCAL_FILE_PATTERNS.some((p) => p.test(text));
+  return { hasSaveIntent, isLocalFile };
+}
+var SAVE_GUIDANCE = `[CONTEXTSTREAM DOCUMENT STORAGE]
+The user wants to save/store content. Use ContextStream instead of local files:
+
+**For decisions/notes:**
+\`\`\`
+mcp__contextstream__session(
+  action="capture",
+  event_type="decision|note|insight",
+  title="...",
+  content="...",
+  importance="high|medium|low"
+)
+\`\`\`
+
+**For documents/specs:**
+\`\`\`
+mcp__contextstream__docs(
+  action="create",
+  title="...",
+  content="...",
+  doc_type="implementation|design|spec|guide"
+)
+\`\`\`
+
+**For plans:**
+\`\`\`
+mcp__contextstream__session(
+  action="capture_plan",
+  title="...",
+  steps=[...]
+)
+\`\`\`
+
+**Why ContextStream?**
+- Persists across sessions (local files don't)
+- Searchable and retrievable
+- Shows up in context automatically
+- Can be shared with team
+
+Only save to local files if user explicitly requests a specific file path.
+[END GUIDANCE]`;
+async function runOnSaveIntentHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  let prompt = input.prompt || "";
+  if (!prompt && input.session?.messages) {
+    for (const msg of [...input.session.messages].reverse()) {
+      if (msg.role === "user") {
+        if (typeof msg.content === "string") {
+          prompt = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text" && block.text) {
+              prompt = block.text;
+              break;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  if (!prompt) {
+    process.exit(0);
+  }
+  const { hasSaveIntent, isLocalFile } = detectsSaveIntent(prompt);
+  if (hasSaveIntent || isLocalFile) {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: SAVE_GUIDANCE
+        }
+      })
+    );
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("on-save-intent") || process.argv[2] === "on-save-intent";
+if (isDirectRun) {
+  runOnSaveIntentHook().catch(() => process.exit(0));
+}
+export {
+  runOnSaveIntentHook
+};

package/dist/hooks/on-task.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+// src/hooks/on-task.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_TASK_HOOK_ENABLED !== "false";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.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;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.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 captureTaskInvocation(description, prompt, agentType, result, sessionId) {
+  if (!API_KEY) return;
+  const payload = {
+    event_type: "task_agent",
+    title: `Agent: ${agentType} - ${description}`,
+    content: JSON.stringify({
+      description,
+      prompt: prompt.slice(0, 1e3),
+      agent_type: agentType,
+      result: result.slice(0, 2e3),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "medium",
+    tags: ["task", "agent", agentType.toLowerCase()],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runOnTaskHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  if (input.tool_name !== "Task") {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const description = input.tool_input?.description || "Unknown task";
+  const prompt = input.tool_input?.prompt || "";
+  const agentType = input.tool_input?.subagent_type || "general-purpose";
+  const result = input.tool_result?.output || "";
+  const sessionId = input.session_id || "unknown";
+  captureTaskInvocation(description, prompt, agentType, result, sessionId).catch(() => {
+  });
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("on-task") || process.argv[2] === "on-task";
+if (isDirectRun) {
+  runOnTaskHook().catch(() => process.exit(0));
+}
+export {
+  runOnTaskHook
+};

package/dist/hooks/on-web.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+// src/hooks/on-web.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_WEB_HOOK_ENABLED !== "false";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.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;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.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 captureWebResearch(toolName, target, summary, sessionId) {
+  if (!API_KEY) return;
+  const payload = {
+    event_type: "web_research",
+    title: `${toolName}: ${target.slice(0, 60)}`,
+    content: JSON.stringify({
+      tool: toolName,
+      target,
+      summary: summary.slice(0, 1e3),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "medium",
+    tags: ["research", "web", toolName.toLowerCase()],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runOnWebHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const toolName = input.tool_name || "";
+  if (!["WebFetch", "WebSearch"].includes(toolName)) {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const sessionId = input.session_id || "unknown";
+  let target = "";
+  let summary = "";
+  switch (toolName) {
+    case "WebFetch":
+      target = input.tool_input?.url || "";
+      const prompt = input.tool_input?.prompt || "fetched content";
+      const content = input.tool_result?.output || input.tool_result?.content || "";
+      summary = `Fetched ${target} (${prompt}): ${content.slice(0, 300)}`;
+      break;
+    case "WebSearch":
+      target = input.tool_input?.query || "";
+      const results = input.tool_result?.results || [];
+      const topResults = results.slice(0, 3).map((r) => `- ${r.title}: ${r.url}`).join("\n");
+      summary = `Search: "${target}"
+Top results:
+${topResults}`;
+      break;
+  }
+  if (target) {
+    captureWebResearch(toolName, target, summary, sessionId).catch(() => {
+    });
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("on-web") || process.argv[2] === "on-web";
+if (isDirectRun) {
+  runOnWebHook().catch(() => process.exit(0));
+}
+export {
+  runOnWebHook
+};

package/dist/hooks/post-compact.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+// src/hooks/post-compact.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_POSTCOMPACT_ENABLED !== "false";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.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;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.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 fetchLastTranscript(sessionId) {
+  if (!API_KEY) {
+    return null;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const url = new URL(`${API_URL}/api/v1/transcripts`);
+    url.searchParams.set("session_id", sessionId);
+    url.searchParams.set("limit", "1");
+    url.searchParams.set("sort", "created_at:desc");
+    if (WORKSPACE_ID) {
+      url.searchParams.set("workspace_id", WORKSPACE_ID);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      const data = await response.json();
+      if (data.transcripts && data.transcripts.length > 0) {
+        return data.transcripts[0];
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatTranscriptSummary(transcript) {
+  const messages = transcript.messages || [];
+  const activeFiles = transcript.metadata?.active_files || [];
+  const toolCallCount = transcript.metadata?.tool_call_count || 0;
+  const userMessages = messages.filter((m) => m.role === "user").slice(-3).map((m) => `- "${m.content.slice(0, 100)}${m.content.length > 100 ? "..." : ""}"`).join("\n");
+  const lastAssistant = messages.filter((m) => m.role === "assistant" && !m.content.startsWith("[Tool:")).slice(-1)[0];
+  const lastWork = lastAssistant ? lastAssistant.content.slice(0, 300) + (lastAssistant.content.length > 300 ? "..." : "") : "None recorded";
+  return `## Pre-Compaction State Restored
+
+### Active Files (${activeFiles.length})
+${activeFiles.slice(0, 10).map((f) => `- ${f}`).join("\n") || "None tracked"}
+
+### Recent User Requests
+${userMessages || "None recorded"}
+
+### Last Work in Progress
+${lastWork}
+
+### Session Stats
+- Tool calls: ${toolCallCount}
+- Messages: ${messages.length}
+- Saved at: ${transcript.created_at}`;
+}
+async function runPostCompactHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const sessionId = input.session_id || "";
+  let restoredContext = "";
+  if (sessionId && API_KEY) {
+    const transcript = await fetchLastTranscript(sessionId);
+    if (transcript) {
+      restoredContext = formatTranscriptSummary(transcript);
+    }
+  }
+  const context = `[POST-COMPACTION - Context Restored]
+
+${restoredContext || "No saved state found. Starting fresh."}
+
+**IMPORTANT:** Call \`mcp__contextstream__context(user_message="resuming after compaction")\` to get full context and any pending tasks.
+
+The conversation was compacted to save memory. The above summary was automatically restored from ContextStream.`;
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PostCompact",
+        additionalContext: context
+      }
+    })
+  );
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("post-compact") || process.argv[2] === "post-compact";
+if (isDirectRun) {
+  runPostCompactHook().catch(() => process.exit(0));
+}
+export {
+  runPostCompactHook
+};

package/dist/hooks/pre-compact.js

@@ -269,7 +269,9 @@ async function runPreCompactHook() {
     activeFiles: [],
     toolCallCount: 0,
     messageCount: 0,
-    lastTools: []
+    lastTools: [],
+    messages: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   if (transcriptPath && fs.existsSync(transcriptPath)) {
     transcriptData = parseTranscript(transcriptPath);

package/dist/hooks/pre-tool-use.js

@@ -6,6 +6,7 @@ import * as path from "node:path";
 import { homedir } from "node:os";
 var ENABLED = process.env.CONTEXTSTREAM_HOOK_ENABLED !== "false";
 var INDEX_STATUS_FILE = path.join(homedir(), ".contextstream", "indexed-projects.json");
+var DEBUG_FILE = "/tmp/pretooluse-hook-debug.log";
 var STALE_THRESHOLD_DAYS = 7;
 var DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"];
 function isDiscoveryGlob(pattern) {
@@ -82,8 +83,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 = {
@@ -112,13 +122,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 = "";
@@ -138,8 +153,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") {
@@ -149,8 +170,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") {