@contextstream/mcp-server 0.4.45 → 0.4.47

package/dist/hooks/auto-rules.js

@@ -9,813 +9,1505 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/version.ts
-import { createRequire } from "module";
-function getVersion() {
+// src/hooks-config.ts
+var hooks_config_exports = {};
+__export(hooks_config_exports, {
+  CLINE_POSTTOOLUSE_HOOK_SCRIPT: () => CLINE_POSTTOOLUSE_HOOK_SCRIPT,
+  CLINE_PRETOOLUSE_HOOK_SCRIPT: () => CLINE_PRETOOLUSE_HOOK_SCRIPT,
+  CLINE_USER_PROMPT_HOOK_SCRIPT: () => CLINE_USER_PROMPT_HOOK_SCRIPT,
+  CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT: () => CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT,
+  CURSOR_PRETOOLUSE_HOOK_SCRIPT: () => CURSOR_PRETOOLUSE_HOOK_SCRIPT,
+  MEDIA_AWARE_HOOK_SCRIPT: () => MEDIA_AWARE_HOOK_SCRIPT,
+  PRECOMPACT_HOOK_SCRIPT: () => PRECOMPACT_HOOK_SCRIPT,
+  PRETOOLUSE_HOOK_SCRIPT: () => PRETOOLUSE_HOOK_SCRIPT,
+  USER_PROMPT_HOOK_SCRIPT: () => USER_PROMPT_HOOK_SCRIPT,
+  buildHooksConfig: () => buildHooksConfig,
+  generateAllHooksDocumentation: () => generateAllHooksDocumentation,
+  generateHooksDocumentation: () => generateHooksDocumentation,
+  getClaudeSettingsPath: () => getClaudeSettingsPath,
+  getClineHooksDir: () => getClineHooksDir,
+  getCursorHooksConfigPath: () => getCursorHooksConfigPath,
+  getCursorHooksDir: () => getCursorHooksDir,
+  getHooksDir: () => getHooksDir,
+  getIndexStatusPath: () => getIndexStatusPath,
+  getKiloCodeHooksDir: () => getKiloCodeHooksDir,
+  getRooCodeHooksDir: () => getRooCodeHooksDir,
+  installAllEditorHooks: () => installAllEditorHooks,
+  installClaudeCodeHooks: () => installClaudeCodeHooks,
+  installClineHookScripts: () => installClineHookScripts,
+  installCursorHookScripts: () => installCursorHookScripts,
+  installEditorHooks: () => installEditorHooks,
+  installHookScripts: () => installHookScripts,
+  installKiloCodeHookScripts: () => installKiloCodeHookScripts,
+  installRooCodeHookScripts: () => installRooCodeHookScripts,
+  markProjectIndexed: () => markProjectIndexed,
+  mergeHooksIntoSettings: () => mergeHooksIntoSettings,
+  readClaudeSettings: () => readClaudeSettings,
+  readCursorHooksConfig: () => readCursorHooksConfig,
+  readIndexStatus: () => readIndexStatus,
+  unmarkProjectIndexed: () => unmarkProjectIndexed,
+  writeClaudeSettings: () => writeClaudeSettings,
+  writeCursorHooksConfig: () => writeCursorHooksConfig,
+  writeIndexStatus: () => writeIndexStatus
+});
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { homedir } from "node:os";
+function getClaudeSettingsPath(scope, projectPath) {
+  if (scope === "user") {
+    return path.join(homedir(), ".claude", "settings.json");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path.join(projectPath, ".claude", "settings.json");
+}
+function getHooksDir() {
+  return path.join(homedir(), ".claude", "hooks");
+}
+function buildHooksConfig(options) {
+  const userPromptHooks = [
+    {
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: "npx @contextstream/mcp-server hook user-prompt-submit",
+          timeout: 5
+        }
+      ]
+    }
+  ];
+  if (options?.includeMediaAware !== false) {
+    userPromptHooks.push({
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: "npx @contextstream/mcp-server hook media-aware",
+          timeout: 5
+        }
+      ]
+    });
+  }
+  const config = {
+    PreToolUse: [
+      {
+        matcher: "Glob|Grep|Search|Task|EnterPlanMode",
+        hooks: [
+          {
+            type: "command",
+            command: "npx @contextstream/mcp-server hook pre-tool-use",
+            timeout: 5
+          }
+        ]
+      }
+    ],
+    UserPromptSubmit: userPromptHooks
+  };
+  if (options?.includePreCompact) {
+    config.PreCompact = [
+      {
+        // Match both manual (/compact) and automatic compaction
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: "npx @contextstream/mcp-server hook pre-compact",
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  const postToolUseHooks = [];
+  if (options?.includePostWrite !== false) {
+    postToolUseHooks.push({
+      matcher: "Edit|Write|NotebookEdit",
+      hooks: [
+        {
+          type: "command",
+          command: "npx @contextstream/mcp-server hook post-write",
+          timeout: 10
+        }
+      ]
+    });
+  }
+  if (options?.includeAutoRules !== false) {
+    postToolUseHooks.push({
+      matcher: "mcp__contextstream__init|mcp__contextstream__context",
+      hooks: [
+        {
+          type: "command",
+          command: "npx @contextstream/mcp-server hook auto-rules",
+          timeout: 15
+        }
+      ]
+    });
+  }
+  if (postToolUseHooks.length > 0) {
+    config.PostToolUse = postToolUseHooks;
+  }
+  return config;
+}
+async function installHookScripts(options) {
+  const hooksDir = getHooksDir();
+  await fs.mkdir(hooksDir, { recursive: true });
+  const result = {
+    preToolUse: "npx @contextstream/mcp-server hook pre-tool-use",
+    userPrompt: "npx @contextstream/mcp-server hook user-prompt-submit"
+  };
+  if (options?.includePreCompact) {
+    result.preCompact = "npx @contextstream/mcp-server hook pre-compact";
+  }
+  if (options?.includeMediaAware !== false) {
+    result.mediaAware = "npx @contextstream/mcp-server hook media-aware";
+  }
+  if (options?.includeAutoRules !== false) {
+    result.autoRules = "npx @contextstream/mcp-server hook auto-rules";
+  }
+  return result;
+}
+async function readClaudeSettings(scope, projectPath) {
+  const settingsPath = getClaudeSettingsPath(scope, projectPath);
   try {
-    const require2 = createRequire(import.meta.url);
-    const pkg = require2("../package.json");
-    const version = pkg?.version;
-    if (typeof version === "string" && version.trim()) return version.trim();
+    const content = await fs.readFile(settingsPath, "utf-8");
+    return JSON.parse(content);
   } catch {
+    return {};
   }
-  return "unknown";
 }
-var VERSION, CACHE_TTL_MS;
-var init_version = __esm({
-  "src/version.ts"() {
-    "use strict";
-    VERSION = getVersion();
-    CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+async function writeClaudeSettings(settings, scope, projectPath) {
+  const settingsPath = getClaudeSettingsPath(scope, projectPath);
+  const dir = path.dirname(settingsPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+}
+function mergeHooksIntoSettings(existingSettings, newHooks) {
+  const settings = { ...existingSettings };
+  const existingHooks = settings.hooks || {};
+  for (const [hookType, matchers] of Object.entries(newHooks || {})) {
+    if (!matchers) continue;
+    const existing = existingHooks?.[hookType] || [];
+    const filtered = existing.filter((m) => {
+      return !m.hooks?.some((h) => h.command?.includes("contextstream"));
+    });
+    existingHooks[hookType] = [...filtered, ...matchers];
   }
-});
-
-// src/rules-templates.ts
-var rules_templates_exports = {};
-__export(rules_templates_exports, {
-  RULES_VERSION: () => RULES_VERSION,
-  TEMPLATES: () => TEMPLATES,
-  generateAllRuleFiles: () => generateAllRuleFiles,
-  generateRuleContent: () => generateRuleContent,
-  getAvailableEditors: () => getAvailableEditors,
-  getTemplate: () => getTemplate
-});
-function applyMcpToolPrefix(markdown, toolPrefix) {
-  const toolPattern = CONTEXTSTREAM_TOOL_NAMES.join("|");
-  const toolRegex = new RegExp(`(?<!__)\\b(${toolPattern})\\b(?=\\s*\\()`, "g");
-  return markdown.replace(toolRegex, `${toolPrefix}$1`);
-}
-function getAvailableEditors() {
-  return Object.keys(TEMPLATES);
-}
-function getTemplate(editor) {
-  return TEMPLATES[editor.toLowerCase()] || null;
-}
-function generateRuleContent(editor, options) {
-  const template = getTemplate(editor);
-  if (!template) return null;
-  const mode = options?.mode || "dynamic";
-  const rules = mode === "full" ? CONTEXTSTREAM_RULES_FULL : mode === "minimal" ? CONTEXTSTREAM_RULES_MINIMAL : CONTEXTSTREAM_RULES_DYNAMIC;
-  let content = template.build(rules);
-  if (options?.workspaceName || options?.projectName) {
-    const header = `
-# Workspace: ${options.workspaceName || "Unknown"}
-${options.projectName ? `# Project: ${options.projectName}` : ""}
-${options.workspaceId ? `# Workspace ID: ${options.workspaceId}` : ""}
-
-`;
-    content = header + content;
+  settings.hooks = existingHooks;
+  return settings;
+}
+async function installClaudeCodeHooks(options) {
+  const result = { scripts: [], settings: [] };
+  result.scripts.push(
+    "npx @contextstream/mcp-server hook pre-tool-use",
+    "npx @contextstream/mcp-server hook user-prompt-submit"
+  );
+  if (options.includePreCompact) {
+    result.scripts.push("npx @contextstream/mcp-server hook pre-compact");
+  }
+  if (options.includeMediaAware !== false) {
+    result.scripts.push("npx @contextstream/mcp-server hook media-aware");
+  }
+  if (options.includePostWrite !== false) {
+    result.scripts.push("npx @contextstream/mcp-server hook post-write");
+  }
+  if (options.includeAutoRules !== false) {
+    result.scripts.push("npx @contextstream/mcp-server hook auto-rules");
+  }
+  const hooksConfig = buildHooksConfig({
+    includePreCompact: options.includePreCompact,
+    includeMediaAware: options.includeMediaAware,
+    includePostWrite: options.includePostWrite,
+    includeAutoRules: options.includeAutoRules
+  });
+  if (options.scope === "user" || options.scope === "both") {
+    const settingsPath = getClaudeSettingsPath("user");
+    if (!options.dryRun) {
+      const existing = await readClaudeSettings("user");
+      const merged = mergeHooksIntoSettings(existing, hooksConfig);
+      await writeClaudeSettings(merged, "user");
+    }
+    result.settings.push(settingsPath);
+  }
+  if ((options.scope === "project" || options.scope === "both") && options.projectPath) {
+    const settingsPath = getClaudeSettingsPath("project", options.projectPath);
+    if (!options.dryRun) {
+      const existing = await readClaudeSettings("project", options.projectPath);
+      const merged = mergeHooksIntoSettings(existing, hooksConfig);
+      await writeClaudeSettings(merged, "project", options.projectPath);
+    }
+    result.settings.push(settingsPath);
+  }
+  return result;
+}
+function generateHooksDocumentation() {
+  return `
+## Claude Code Hooks (ContextStream)
+
+ContextStream installs hooks to enforce ContextStream-first behavior.
+All hooks run via Node.js - no Python dependency required.
+
+### PreToolUse Hook
+- **Command:** \`npx @contextstream/mcp-server hook pre-tool-use\`
+- **Purpose:** Blocks Glob/Grep/Search/EnterPlanMode and redirects to ContextStream
+- **Blocked tools:** Glob, Grep, Search, Task(Explore), Task(Plan), EnterPlanMode
+- **Disable:** Set \`CONTEXTSTREAM_HOOK_ENABLED=false\` environment variable
+
+### UserPromptSubmit Hook
+- **Command:** \`npx @contextstream/mcp-server hook user-prompt-submit\`
+- **Purpose:** Injects a reminder about ContextStream rules on every message
+- **Disable:** Set \`CONTEXTSTREAM_REMINDER_ENABLED=false\` environment variable
+
+### Media-Aware Hook
+- **Command:** \`npx @contextstream/mcp-server hook media-aware\`
+- **Purpose:** Detects media-related prompts and injects media tool guidance
+- **Triggers:** Patterns like video, clips, Remotion, image, audio, creative assets
+- **Disable:** Set \`CONTEXTSTREAM_MEDIA_HOOK_ENABLED=false\` environment variable
+
+When Media-Aware hook detects media patterns, it injects context about:
+- How to search indexed media assets
+- How to get clips for Remotion (with frame-based props)
+- How to index new media files
+
+### PreCompact Hook (Optional)
+- **Command:** \`npx @contextstream/mcp-server hook pre-compact\`
+- **Purpose:** Saves conversation state before context compaction
+- **Triggers:** Both manual (/compact) and automatic compaction
+- **Disable:** Set \`CONTEXTSTREAM_PRECOMPACT_ENABLED=false\` environment variable
+- **Note:** Enable with \`generate_rules(include_pre_compact=true)\` to activate
+
+When PreCompact runs, it:
+1. Parses the transcript for active files and tool calls
+2. Saves a session_snapshot to ContextStream API
+3. Injects context about using \`session_init(is_post_compact=true)\` after compaction
+
+### PostToolUse Hook (Real-time Indexing)
+- **Command:** \`npx @contextstream/mcp-server hook post-write\`
+- **Purpose:** Indexes files immediately after Edit/Write/NotebookEdit operations
+- **Matcher:** Edit|Write|NotebookEdit
+- **Disable:** Set \`CONTEXTSTREAM_POSTWRITE_ENABLED=false\` environment variable
+
+### Why Hooks?
+Claude Code has strong built-in behaviors to use its default tools (Grep, Glob, Read)
+and its built-in plan mode. CLAUDE.md instructions decay over long conversations.
+Hooks provide:
+1. **Physical enforcement** - Blocked tools can't be used
+2. **Continuous reminders** - Rules stay in recent context
+3. **Better UX** - Faster searches via indexed ContextStream
+4. **Persistent plans** - ContextStream plans survive across sessions
+5. **Compaction awareness** - Save state before context is compacted
+6. **Real-time indexing** - Files indexed immediately after writes
+
+### Manual Configuration
+If you prefer to configure manually, add to \`~/.claude/settings.json\`:
+\`\`\`json
+{
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "Glob|Grep|Search|Task|EnterPlanMode",
+      "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook pre-tool-use"}]
+    }],
+    "UserPromptSubmit": [
+      {
+        "matcher": "*",
+        "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook user-prompt-submit"}]
+      },
+      {
+        "matcher": "*",
+        "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook media-aware"}]
+      }
+    ],
+    "PreCompact": [{
+      "matcher": "*",
+      "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook pre-compact", "timeout": 10}]
+    }],
+    "PostToolUse": [{
+      "matcher": "Edit|Write|NotebookEdit",
+      "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook post-write", "timeout": 10}]
+    }]
+  }
+}
+\`\`\`
+`.trim();
+}
+function getIndexStatusPath() {
+  return path.join(homedir(), ".contextstream", "indexed-projects.json");
+}
+async function readIndexStatus() {
+  const statusPath = getIndexStatusPath();
+  try {
+    const content = await fs.readFile(statusPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, projects: {} };
+  }
+}
+async function writeIndexStatus(status) {
+  const statusPath = getIndexStatusPath();
+  const dir = path.dirname(statusPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(statusPath, JSON.stringify(status, null, 2));
+}
+async function markProjectIndexed(projectPath, options) {
+  const status = await readIndexStatus();
+  const resolvedPath = path.resolve(projectPath);
+  status.projects[resolvedPath] = {
+    indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    project_id: options?.project_id,
+    project_name: options?.project_name
+  };
+  await writeIndexStatus(status);
+}
+async function unmarkProjectIndexed(projectPath) {
+  const status = await readIndexStatus();
+  const resolvedPath = path.resolve(projectPath);
+  delete status.projects[resolvedPath];
+  await writeIndexStatus(status);
+}
+function getClineHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path.join(homedir(), "Documents", "Cline", "Rules", "Hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path.join(projectPath, ".clinerules", "hooks");
+}
+async function installClineHookScripts(options) {
+  const hooksDir = getClineHooksDir(options.scope, options.projectPath);
+  await fs.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path.join(hooksDir, "PreToolUse");
+  const userPromptPath = path.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path.join(hooksDir, "PostToolUse");
+  await fs.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  const result = {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+  if (options.includePostWrite !== false) {
+    await fs.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    result.postToolUse = postToolUsePath;
+  }
+  return result;
+}
+function getRooCodeHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path.join(homedir(), ".roo", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path.join(projectPath, ".roo", "hooks");
+}
+async function installRooCodeHookScripts(options) {
+  const hooksDir = getRooCodeHooksDir(options.scope, options.projectPath);
+  await fs.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path.join(hooksDir, "PreToolUse");
+  const userPromptPath = path.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path.join(hooksDir, "PostToolUse");
+  await fs.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  const result = {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+  if (options.includePostWrite !== false) {
+    await fs.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    result.postToolUse = postToolUsePath;
+  }
+  return result;
+}
+function getKiloCodeHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path.join(homedir(), ".kilocode", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path.join(projectPath, ".kilocode", "hooks");
+}
+async function installKiloCodeHookScripts(options) {
+  const hooksDir = getKiloCodeHooksDir(options.scope, options.projectPath);
+  await fs.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path.join(hooksDir, "PreToolUse");
+  const userPromptPath = path.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path.join(hooksDir, "PostToolUse");
+  await fs.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  const result = {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+  if (options.includePostWrite !== false) {
+    await fs.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    result.postToolUse = postToolUsePath;
+  }
+  return result;
+}
+function getCursorHooksConfigPath(scope, projectPath) {
+  if (scope === "global") {
+    return path.join(homedir(), ".cursor", "hooks.json");
   }
-  if (options?.additionalRules) {
-    content += "\n\n## Project-Specific Rules\n\n" + options.additionalRules;
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path.join(projectPath, ".cursor", "hooks.json");
+}
+function getCursorHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path.join(homedir(), ".cursor", "hooks");
   }
-  if (editor.toLowerCase() === "claude") {
-    content = applyMcpToolPrefix(content, `mcp__${DEFAULT_CLAUDE_MCP_SERVER_NAME}__`);
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path.join(projectPath, ".cursor", "hooks");
+}
+async function readCursorHooksConfig(scope, projectPath) {
+  const configPath = getCursorHooksConfigPath(scope, projectPath);
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, hooks: {} };
   }
+}
+async function writeCursorHooksConfig(config, scope, projectPath) {
+  const configPath = getCursorHooksConfigPath(scope, projectPath);
+  const dir = path.dirname(configPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function installCursorHookScripts(options) {
+  const hooksDir = getCursorHooksDir(options.scope, options.projectPath);
+  await fs.mkdir(hooksDir, { recursive: true });
+  const existingConfig = await readCursorHooksConfig(options.scope, options.projectPath);
+  const filterContextStreamHooks = (hooks) => {
+    if (!hooks) return [];
+    return hooks.filter((h) => {
+      const hook = h;
+      return !hook.command?.includes("contextstream");
+    });
+  };
+  const filteredPreToolUse = filterContextStreamHooks(existingConfig.hooks.preToolUse);
+  const filteredBeforeSubmit = filterContextStreamHooks(existingConfig.hooks.beforeSubmitPrompt);
+  const config = {
+    version: 1,
+    hooks: {
+      ...existingConfig.hooks,
+      preToolUse: [
+        ...filteredPreToolUse,
+        {
+          command: "npx @contextstream/mcp-server hook pre-tool-use",
+          type: "command",
+          timeout: 5,
+          matcher: { tool_name: "Glob|Grep|search_files|list_files|ripgrep" }
+        }
+      ],
+      beforeSubmitPrompt: [
+        ...filteredBeforeSubmit,
+        {
+          command: "npx @contextstream/mcp-server hook user-prompt-submit",
+          type: "command",
+          timeout: 5
+        }
+      ]
+    }
+  };
+  await writeCursorHooksConfig(config, options.scope, options.projectPath);
+  const configPath = getCursorHooksConfigPath(options.scope, options.projectPath);
   return {
-    filename: template.filename,
-    content: content.trim() + "\n"
+    preToolUse: "npx @contextstream/mcp-server hook pre-tool-use",
+    beforeSubmitPrompt: "npx @contextstream/mcp-server hook user-prompt-submit",
+    config: configPath
   };
 }
-function generateAllRuleFiles(options) {
-  return getAvailableEditors().map((editor) => {
-    const result = generateRuleContent(editor, options);
-    if (!result) return null;
-    return { editor, ...result };
-  }).filter((r) => r !== null);
+async function installEditorHooks(options) {
+  const { editor, scope, projectPath, includePreCompact, includePostWrite } = options;
+  switch (editor) {
+    case "claude": {
+      if (scope === "project" && !projectPath) {
+        throw new Error("projectPath required for project scope");
+      }
+      const scripts = await installHookScripts({ includePreCompact });
+      const hooksConfig = buildHooksConfig({ includePreCompact, includePostWrite });
+      const settingsScope = scope === "global" ? "user" : "project";
+      const existing = await readClaudeSettings(settingsScope, projectPath);
+      const merged = mergeHooksIntoSettings(existing, hooksConfig);
+      await writeClaudeSettings(merged, settingsScope, projectPath);
+      const installed = [scripts.preToolUse, scripts.userPrompt];
+      if (scripts.preCompact) installed.push(scripts.preCompact);
+      return {
+        editor: "claude",
+        installed,
+        hooksDir: getHooksDir()
+      };
+    }
+    case "cline": {
+      const scripts = await installClineHookScripts({ scope, projectPath, includePostWrite });
+      const installed = [scripts.preToolUse, scripts.userPromptSubmit];
+      if (scripts.postToolUse) installed.push(scripts.postToolUse);
+      return {
+        editor: "cline",
+        installed,
+        hooksDir: getClineHooksDir(scope, projectPath)
+      };
+    }
+    case "roo": {
+      const scripts = await installRooCodeHookScripts({ scope, projectPath, includePostWrite });
+      const installed = [scripts.preToolUse, scripts.userPromptSubmit];
+      if (scripts.postToolUse) installed.push(scripts.postToolUse);
+      return {
+        editor: "roo",
+        installed,
+        hooksDir: getRooCodeHooksDir(scope, projectPath)
+      };
+    }
+    case "kilo": {
+      const scripts = await installKiloCodeHookScripts({ scope, projectPath, includePostWrite });
+      const installed = [scripts.preToolUse, scripts.userPromptSubmit];
+      if (scripts.postToolUse) installed.push(scripts.postToolUse);
+      return {
+        editor: "kilo",
+        installed,
+        hooksDir: getKiloCodeHooksDir(scope, projectPath)
+      };
+    }
+    case "cursor": {
+      const scripts = await installCursorHookScripts({ scope, projectPath });
+      return {
+        editor: "cursor",
+        installed: [scripts.preToolUse, scripts.beforeSubmitPrompt],
+        hooksDir: getCursorHooksDir(scope, projectPath)
+      };
+    }
+    default:
+      throw new Error(`Unsupported editor: ${editor}`);
+  }
 }
-var DEFAULT_CLAUDE_MCP_SERVER_NAME, RULES_VERSION, CONTEXTSTREAM_TOOL_NAMES, CONTEXTSTREAM_RULES_DYNAMIC, CONTEXTSTREAM_RULES_FULL, CONTEXTSTREAM_RULES_MINIMAL, TEMPLATES;
-var init_rules_templates = __esm({
-  "src/rules-templates.ts"() {
-    "use strict";
-    init_version();
-    DEFAULT_CLAUDE_MCP_SERVER_NAME = "contextstream";
-    RULES_VERSION = VERSION === "unknown" ? "0.0.0" : VERSION;
-    CONTEXTSTREAM_TOOL_NAMES = [
-      // Standalone tools (always present)
-      "init",
-      // Renamed from session_init - initialize conversation session
-      "context",
-      // Renamed from context_smart - get relevant context every message
-      "context_feedback",
-      "generate_rules",
-      // Consolidated domain tools (v0.4.x default)
-      "search",
-      // Modes: semantic, hybrid, keyword, pattern
-      "session",
-      // Actions: capture, capture_lesson, get_lessons, recall, remember, user_context, summary, compress, delta, smart_search, decision_trace
-      "memory",
-      // Actions: create_event, get_event, update_event, delete_event, list_events, distill_event, create_node, get_node, update_node, delete_node, list_nodes, supersede_node, search, decisions, timeline, summary
-      "graph",
-      // Actions: dependencies, impact, call_path, related, path, decisions, ingest, circular_dependencies, unused_code, contradictions
-      "project",
-      // Actions: list, get, create, update, index, overview, statistics, files, index_status, ingest_local
-      "workspace",
-      // Actions: list, get, associate, bootstrap
-      "reminder",
-      // Actions: list, active, create, snooze, complete, dismiss
-      "integration",
-      // Provider: slack, github, all; Actions: status, search, stats, activity, contributors, knowledge, summary, channels, discussions, sync_users, repos, issues
-      "help"
-      // Actions: tools, auth, version, editor_rules, enable_bundle
-    ];
-    CONTEXTSTREAM_RULES_DYNAMIC = `
-## ContextStream Dynamic Rules (Powered by our SmartRouter)
-
-All rules are served dynamically via \`context\`. This file is minimal by design.
-
-### Every Message Protocol
-
-| Message | What to Call |
-|---------|--------------|
-| **1st message** | \`init()\` then \`context(user_message="<msg>")\` |
-| **2nd+ messages** | \`context(user_message="<msg>")\` |
-
-Note: \`init()\` auto-detects folder from IDE. Only pass \`folder_path\` if auto-detection fails.
-
-### Follow the Instructions Field
-
-The \`context\` response includes an \`instructions\` field with context-aware guidance.
-**Follow these instructions.** They are dynamically matched to your query and include:
-- Search guidance (when/how to search)
-- Git workflow rules (commit, PR, safety)
-- Planning rules (use ContextStream plans, not file-based)
-- Media/code analysis guidance
-- Lessons from past mistakes
-- And more...
-
-### Notices
-
-Handle notices from \`context\` response:
-- **[VERSION_NOTICE]**: Tell user to update MCP
-- **[RULES_NOTICE]**: Run \`generate_rules()\`
-- **[LESSONS_WARNING]**: Apply lessons immediately
-
-Rules Version: ${RULES_VERSION}
-`.trim();
-    CONTEXTSTREAM_RULES_FULL = `
-## ContextStream Rules
-
-<contextstream_rules>
-1. **SIMPLE UTILITY?** (list/show/version) \u2192 Just execute, skip context calls
-2. **CODING TASK?** \u2192 init \u2192 context \u2192 work \u2192 capture
-3. **SEARCH FIRST:** Before Glob/Grep/Read \u2192 \`search(mode="hybrid")\` FIRST
-</contextstream_rules>
-
-**Display this block at the start of responses to keep rules in context.**
-
----
-
-## \u{1F6A8} CRITICAL RULE #1 - CONTEXTSTREAM SEARCH FIRST \u{1F6A8}
-
-**BEFORE using Glob, Grep, Search, Read (for discovery), Explore, or ANY local file scanning:**
-\`\`\`
-STOP \u2192 Call search(mode="hybrid", query="...") FIRST
-\`\`\`
-
-**Note:** PreToolUse hooks block these tools when ContextStream is available.
-**Claude Code users:** Your tool names are \`mcp__contextstream__search\`, \`mcp__contextstream__init\`, etc.
-
-\u274C **NEVER DO THIS:**
-- \`Glob("**/*.ts")\` \u2192 Use \`search(mode="pattern", query="*.ts")\` instead
-- \`Grep("functionName")\` \u2192 Use \`search(mode="keyword", query="functionName")\` instead
-- \`Read(file)\` for discovery \u2192 Use \`search(mode="hybrid", query="...")\` instead
-- \`Task(subagent_type="Explore")\` \u2192 Use \`search(mode="hybrid")\` instead
-
-\u2705 **ALWAYS DO THIS:**
-1. \`search(mode="hybrid", query="what you're looking for")\`
-2. Only use local tools (Glob/Grep/Read) if ContextStream returns **0 results**
-3. Use Read ONLY for exact file edits after you know the file path
-
-This applies to **EVERY search** throughout the **ENTIRE conversation**, not just the first message.
-
----
-
-## \u{1F6A8} CRITICAL RULE #2 - AUTO-INDEXING \u{1F6A8}
-
-**ContextStream auto-indexes your project on \`init\`.** You do NOT need to:
-- Ask the user to index
-- Manually trigger ingestion
-- Check index_status before every search
-
-**When \`init\` returns \`indexing_status: "started"\` or \`"refreshing"\`:**
-- Background indexing is running automatically
-- Search results will be available within seconds to minutes
-- **DO NOT fall back to local tools** - wait for ContextStream search to work
-- If search returns 0 results initially, try again after a moment
-
-**Only manually trigger indexing if:**
-- \`init\` returned \`ingest_recommendation.recommended: true\` (rare edge case)
-- User explicitly asks to re-index
-
----
-
-## \u{1F6A8} CRITICAL RULE #3 - LESSONS (PAST MISTAKES) \u{1F6A8}
-
-**Lessons are past mistakes that MUST inform your work.** Ignoring lessons leads to repeated failures.
-
-### On \`init\`:
-- Check for \`lessons\` and \`lessons_warning\` in the response
-- If present, **READ THEM IMMEDIATELY** before doing any work
-- These are high-priority lessons (critical/high severity) relevant to your context
-- **Apply the prevention steps** from each lesson to avoid repeating mistakes
-
-### On \`context\`:
-- Check for \`[LESSONS_WARNING]\` tag in the response
-- If present, you **MUST** tell the user about the lessons before proceeding
-- Lessons are proactively fetched when risky actions are detected (refactor, migrate, deploy, etc.)
-- **Do not skip or bury this warning** - lessons represent real past mistakes
-
-### Before ANY Non-Trivial Work:
-**ALWAYS call \`session(action="get_lessons", query="<topic>")\`** where \`<topic>\` matches what you're about to do:
-- Before refactoring \u2192 \`session(action="get_lessons", query="refactoring")\`
-- Before API changes \u2192 \`session(action="get_lessons", query="API changes")\`
-- Before database work \u2192 \`session(action="get_lessons", query="database migrations")\`
-- Before deployments \u2192 \`session(action="get_lessons", query="deployment")\`
-
-### When Lessons Are Found:
-1. **Summarize the lessons** to the user before proceeding
-2. **Explicitly state how you will avoid the past mistakes**
-3. If a lesson conflicts with the current approach, **warn the user**
-
-**Failing to check lessons before risky work is a critical error.**
-
----
-
-## ContextStream v0.4.x Integration (Enhanced)
-
-You have access to ContextStream MCP tools for persistent memory and context.
-v0.4.x uses **~11 consolidated domain tools** for ~75% token reduction vs previous versions.
-Rules Version: ${RULES_VERSION}
-
-## TL;DR - WHEN TO USE CONTEXT
-
-| Request Type | What to Do |
-|--------------|------------|
-| **\u{1F680} Simple utility** (list workspaces, show version) | **Just execute directly** - skip init, context, capture |
-| **\u{1F4BB} Coding task** (edit, create, refactor) | Full context: init \u2192 context \u2192 work \u2192 capture |
-| **\u{1F50D} Code search/discovery** | init \u2192 context \u2192 search() |
-| **\u26A0\uFE0F Risky work** (deploy, migrate, refactor) | Check lessons first: \`session(action="get_lessons")\` |
-| **User frustration/correction** | Capture lesson: \`session(action="capture_lesson", ...)\` |
-
-### Simple Utility Operations - FAST PATH
-
-**For simple queries, just execute and respond:**
-- "list workspaces" \u2192 \`workspace(action="list")\` \u2192 done
-- "list projects" \u2192 \`project(action="list")\` \u2192 done
-- "show version" \u2192 \`help(action="version")\` \u2192 done
-- "what reminders do I have" \u2192 \`reminder(action="list")\` \u2192 done
-
-**No init. No context. No capture.** These add noise, not value.
-
-### Coding Tasks - FULL CONTEXT
-
-| Step | What to Call |
-|------|--------------|
-| **1st message** | \`init(folder_path="...", context_hint="<msg>")\`, then \`context(...)\` |
-| **2nd+ messages** | \`context(user_message="<msg>", format="minified", max_tokens=400)\` |
-| **Code search** | \`search(mode="hybrid", query="...")\` \u2014 BEFORE Glob/Grep/Read |
-| **After significant work** | \`session(action="capture", event_type="decision", ...)\` |
-| **User correction** | \`session(action="capture_lesson", ...)\` |
-| **\u26A0\uFE0F When warnings received** | **STOP**, acknowledge, explain mitigation, then proceed |
-
-**How to detect simple utility operations:**
-- Single-word commands: "list", "show", "version", "help"
-- Data retrieval with no context dependency: "list my workspaces", "what projects do I have"
-- Status checks: "am I authenticated?", "what's the server version?"
-
-**First message rule (for coding tasks):** After \`init\`:
-1. Check for \`lessons\` in response - if present, READ and SUMMARIZE them to user
-2. Then call \`context\` before any other tool or response
-
-**Context Pack (Pro+):** If enabled, use \`context(..., mode="pack", distill=true)\` for code/file queries. If unavailable or disabled, omit \`mode\` and proceed with standard \`context\` (the API will fall back).
-
-**Tool naming:** Use the exact tool names exposed by your MCP client. Claude Code typically uses \`mcp__<server>__<tool>\` where \`<server>\` matches your MCP config (often \`contextstream\`). If a tool call fails with "No such tool available", refresh rules and match the tool list.
-
----
-
-## Consolidated Domain Tools Architecture
-
-v0.4.x consolidates ~58 individual tools into ~11 domain tools with action/mode dispatch:
-
-### Standalone Tools
-- **\`init\`** - Initialize session with workspace detection + context (skip for simple utility operations)
-- **\`context\`** - Semantic search for relevant context (skip for simple utility operations)
-
-### Domain Tools (Use action/mode parameter)
-
-| Domain | Actions/Modes | Example |
-|--------|---------------|---------|
-| **\`search\`** | mode: semantic, hybrid, keyword, pattern | \`search(mode="hybrid", query="auth implementation", limit=3)\` |
-| **\`session\`** | action: capture, capture_lesson, get_lessons, recall, remember, user_context, summary, compress, delta, smart_search, decision_trace | \`session(action="capture", event_type="decision", title="Use JWT", content="...")\` |
-| **\`memory\`** | action: create_event, get_event, update_event, delete_event, list_events, distill_event, create_node, get_node, update_node, delete_node, list_nodes, supersede_node, search, decisions, timeline, summary | \`memory(action="list_events", limit=10)\` |
-| **\`graph\`** | action: dependencies, impact, call_path, related, path, decisions, ingest, circular_dependencies, unused_code, contradictions | \`graph(action="impact", symbol_name="AuthService")\` |
-| **\`project\`** | action: list, get, create, update, index, overview, statistics, files, index_status, ingest_local | \`project(action="statistics")\` |
-| **\`workspace\`** | action: list, get, associate, bootstrap | \`workspace(action="list")\` |
-| **\`reminder\`** | action: list, active, create, snooze, complete, dismiss | \`reminder(action="active")\` |
-| **\`integration\`** | provider: slack/github/all; action: status, search, stats, activity, contributors, knowledge, summary, channels, discussions, sync_users, repos, issues | \`integration(provider="github", action="search", query="...")\` |
-| **\`help\`** | action: tools, auth, version, editor_rules, enable_bundle | \`help(action="tools")\` |
-
----
-
-### Why context is Required (Even After init)
-
-**Common mistake:** "init already gave me context, I don't need context"
-
-**This is WRONG. Here's why:**
-- \`init\` returns the last ~10 items **BY TIME** (chronological)
-- \`context\` **SEARCHES** for items **RELEVANT to THIS message** (semantic)
-
-**Example failure:**
-- User asks: "how should I implement authentication?"
-- Auth decisions were made 20 conversations ago
-- \`init\` won't have it (too old, not in recent 10)
-- \`context\` FINDS it via semantic search
-
-**Without context, you WILL miss relevant older context.**
-
----
-
-### Recommended Token Budgets
-
-- For trivial/local edits: \`context(..., max_tokens=200)\`
-- Default: \`context(..., max_tokens=400)\`
-- Deep debugging/architecture: \`context(..., max_tokens=800)\`
-- Keep \`format="minified"\` (default) unless debugging
-
-If context still feels missing, use \`session(action="recall", query="...")\` for focused deep lookup.
-
----
-
-### Rules, Version & Lessons Notices
-
-**[RULES_NOTICE]** - Update rules via \`generate_rules()\` (or rerun setup).
-
-**[VERSION_NOTICE]** - You **MUST IMMEDIATELY** tell the user:
-  1. A new MCP server version is available
-  2. The exact update command to run
-  3. That they need to restart their AI tool after updating
-  **Do not skip this** - users often miss stderr warnings.
-
-**[LESSONS_WARNING]** - You **MUST** before proceeding:
-  1. Read all lessons listed
-  2. Tell the user about relevant lessons
-  3. Explain how you will avoid each past mistake
-  **This is critical** - ignoring lessons leads to repeated failures.
-
----
-
-### Preferences & Lessons (Use Early)
+async function installAllEditorHooks(options) {
+  const editors = options.editors || ["claude", "cline", "roo", "kilo", "cursor"];
+  const results = [];
+  for (const editor of editors) {
+    try {
+      const result = await installEditorHooks({
+        editor,
+        scope: options.scope,
+        projectPath: options.projectPath,
+        includePreCompact: options.includePreCompact,
+        includePostWrite: options.includePostWrite
+      });
+      results.push(result);
+    } catch (error) {
+      console.error(`Failed to install hooks for ${editor}:`, error);
+    }
+  }
+  return results;
+}
+function generateAllHooksDocumentation() {
+  return `
+## Editor Hooks Support (ContextStream)
 
-- If preferences/style matter: \`session(action="user_context")\`
-- Before risky changes: \`session(action="get_lessons", query="<topic>")\`
-- On frustration/corrections: \`session(action="capture_lesson", title="...", trigger="...", impact="...", prevention="...")\`
+ContextStream can install hooks for multiple AI code editors to enforce ContextStream-first behavior.
 
----
+### Supported Editors
 
-### Context Pressure & Compaction Awareness
+| Editor | Hooks Location | Hook Types |
+|--------|---------------|------------|
+| **Claude Code** | \`~/.claude/hooks/\` | PreToolUse, UserPromptSubmit, PreCompact |
+| **Cursor** | \`~/.cursor/hooks/\` | preToolUse, beforeSubmit |
+| **Cline** | \`~/Documents/Cline/Rules/Hooks/\` | PreToolUse, UserPromptSubmit |
+| **Roo Code** | \`~/.roo/hooks/\` | PreToolUse, UserPromptSubmit |
+| **Kilo Code** | \`~/.kilocode/hooks/\` | PreToolUse, UserPromptSubmit |
 
-ContextStream tracks context pressure to help you stay ahead of conversation compaction:
+### Claude Code Hooks
 
-**Automatic tracking:** Token usage is tracked automatically. \`context\` returns \`context_pressure\` when usage is high.
+${generateHooksDocumentation()}
 
-**When \`context\` returns \`context_pressure\` with high/critical level:**
-1. Review the \`suggested_action\` field:
-   - \`prepare_save\`: Start thinking about saving important state
-   - \`save_now\`: Immediately call \`session(action="capture", event_type="session_snapshot")\` to preserve state
+### Cursor Hooks
 
-**PreCompact Hook (Optional):** If enabled, Claude Code will inject a reminder to save state before compaction.
-Enable with: \`generate_rules(install_hooks=true, include_pre_compact=true)\`
+Cursor uses a \`hooks.json\` configuration file:
+- **preToolUse**: Blocks discovery tools before execution
+- **beforeSubmitPrompt**: Injects ContextStream rules reminder
 
-**Before compaction happens (when warned):**
+#### Output Format
+\`\`\`json
+{ "decision": "allow" }
 \`\`\`
-session(action="capture", event_type="session_snapshot", title="Pre-compaction snapshot", content="{
-  \\"conversation_summary\\": \\"<summarize what we've been doing>\\",
-  \\"current_goal\\": \\"<the main task>\\",
-  \\"active_files\\": [\\"file1.ts\\", \\"file2.ts\\"],
-  \\"recent_decisions\\": [{title: \\"...\\", rationale: \\"...\\"}],
-  \\"unfinished_work\\": [{task: \\"...\\", status: \\"...\\", next_steps: \\"...\\"}]
-}")
+or
+\`\`\`json
+{ "decision": "deny", "reason": "Use ContextStream search instead" }
 \`\`\`
 
-**After compaction (when context seems lost):**
-1. Call \`init(folder_path="...", is_post_compact=true)\` - this auto-restores the most recent snapshot
-2. Or call \`session_restore_context()\` directly to get the saved state
-3. Review the \`restored_context\` to understand prior work
-4. Acknowledge to the user what was restored and continue
-
----
-
-### Index Status (Auto-Managed)
-
-**Indexing is automatic.** After \`init\`, the project is auto-indexed in the background.
-
-**You do NOT need to manually check index_status before every search.** Just use \`search()\`.
-
-**If search returns 0 results and you expected matches:**
-1. Check if \`init\` returned \`indexing_status: "started"\` - indexing may still be in progress
-2. Wait a moment and retry \`search()\`
-3. Only as a last resort: \`project(action="index_status")\` to check
-
-**Graph data:** If graph queries (\`dependencies\`, \`impact\`) return empty, run \`graph(action="ingest")\` once.
-
-**NEVER fall back to local tools (Glob/Grep/Read) just because search returned 0 results on first try.** Retry first.
-
-### Enhanced Context (Server-Side Warnings)
-
-\`context\` now includes **intelligent server-side filtering** that proactively surfaces relevant warnings:
-
-**Response fields:**
-- \`warnings\`: Array of warning strings (displayed with \u26A0\uFE0F prefix)
+### Cline/Roo/Kilo Code Hooks
 
-**What triggers warnings:**
-- **Lessons**: Past mistakes relevant to the current query (via semantic matching)
-- **Risky actions**: Detected high-risk operations (deployments, migrations, destructive commands)
-- **Breaking changes**: When modifications may impact other parts of the codebase
+These editors use the same hook format (JSON output):
+- **PreToolUse**: Blocks discovery tools, redirects to ContextStream search
+- **UserPromptSubmit**: Injects ContextStream rules reminder
 
-**When you receive warnings:**
-1. **STOP** and read each warning carefully
-2. **Acknowledge** the warning to the user
-3. **Explain** how you will avoid the issue
-4. Only proceed after addressing the warnings
+Hooks are executable scripts named after the hook type (no extension).
 
-### Search & Code Intelligence (ContextStream-first)
-
-\u26A0\uFE0F **STOP: Before using Search/Glob/Grep/Read/Explore** \u2192 Call \`search(mode="hybrid")\` FIRST. Use local tools ONLY if ContextStream returns 0 results.
-
-**\u274C WRONG workflow (wastes tokens, slow):**
-\`\`\`
-Grep "function" \u2192 Read file1.ts \u2192 Read file2.ts \u2192 Read file3.ts \u2192 finally understand
-\`\`\`
-
-**\u2705 CORRECT workflow (fast, complete):**
-\`\`\`
-search(mode="hybrid", query="function implementation") \u2192 done (results include context)
+#### Output Format
+\`\`\`json
+{
+  "cancel": true,
+  "errorMessage": "Use ContextStream search instead",
+  "contextModification": "[CONTEXTSTREAM] Use search tool first"
+}
 \`\`\`
 
-**Why?** ContextStream search returns semantic matches + context + file locations in ONE call. Local tools require multiple round-trips.
-
-**Search order:**
-1. \`session(action="smart_search", query="...")\` - context-enriched
-2. \`search(mode="hybrid", query="...", limit=3)\` or \`search(mode="keyword", query="<filename>", limit=3)\`
-3. \`project(action="files")\` - file tree/list (only when needed)
-4. \`graph(action="dependencies", ...)\` - code structure
-5. Local repo scans (rg/ls/find) - ONLY if ContextStream returns no results, errors, or the user explicitly asks
-
-**Search Mode Selection:**
-
-| Need | Mode | Example |
-|------|------|---------|
-| Find code by meaning | \`hybrid\` | "authentication logic", "error handling" |
-| Exact string/symbol | \`keyword\` | "UserAuthService", "API_KEY" |
-| File patterns | \`pattern\` | "*.sql", "test_*.py" |
-| ALL matches (grep-like) | \`exhaustive\` | "TODO", "FIXME" (find all occurrences) |
-| Symbol renaming | \`refactor\` | "oldFunctionName" (word-boundary matching) |
-| Conceptual search | \`semantic\` | "how does caching work" |
-
-**Token Efficiency:** Use \`output_format\` to reduce response size:
-- \`full\` (default): Full content for understanding code
-- \`paths\`: File paths only (80% token savings) - use for file listings
-- \`minimal\`: Compact format (60% savings) - use for refactoring
-- \`count\`: Match counts only (90% savings) - use for quick checks
-
-**When to use \`output_format=count\`:**
-- User asks "how many X" or "count of X" \u2192 \`search(..., output_format="count")\`
-- Checking if something exists \u2192 count > 0 is sufficient
-- Large exhaustive searches \u2192 get count first, then fetch if needed
-
-**Auto-suggested formats:** Search responses include \`query_interpretation.suggested_output_format\` when the API detects an optimal format:
-- Symbol queries (e.g., "authOptions") \u2192 suggests \`minimal\` (path + line + snippet)
-- Count queries (e.g., "how many") \u2192 suggests \`count\`
-**USE the suggested format** on subsequent searches for best token efficiency.
-
-**Search defaults:** \`search\` returns the top 3 results with compact snippets. Use \`limit\` + \`offset\` for pagination, and \`content_max_chars\` to expand snippets when needed.
-
-If ContextStream returns results, stop and use them. NEVER use local Search/Explore/Read unless you need exact code edits or ContextStream returned 0 results.
-
-**Code Analysis:**
-- Dependencies: \`graph(action="dependencies", file_path="...")\`
-- Change impact: \`graph(action="impact", symbol_name="...")\`
-- Call path: \`graph(action="call_path", from_symbol="...", to_symbol="...")\`
-- Build graph: \`graph(action="ingest")\` - async, can take a few minutes
-
----
-
-### Distillation & Memory Hygiene
+### Installation
 
-- Quick context: \`session(action="summary")\`
-- Long chat: \`session(action="compress", content="...")\`
-- Memory summary: \`memory(action="summary")\`
-- Condense noisy entries: \`memory(action="distill_event", event_id="...")\`
+Use \`generate_rules(install_hooks=true, editors=["claude", "cursor", "cline", "roo", "kilo"])\` to install hooks for specific editors, or omit \`editors\` to install for all.
 
----
+### Disabling Hooks
 
-### When to Capture
-
-| When | Call | Example |
-|------|------|---------|
-| User makes decision | \`session(action="capture", event_type="decision", ...)\` | "Let's use PostgreSQL" |
-| User states preference | \`session(action="capture", event_type="preference", ...)\` | "I prefer TypeScript" |
-| Complete significant task | \`session(action="capture", event_type="task", ...)\` | Capture what was done |
-| Need past context | \`session(action="recall", query="...")\` | "What did we decide about X?" |
-
-**DO NOT capture utility operations:**
-- \u274C "Listed workspaces" - not meaningful context
-- \u274C "Showed version" - not a decision
-- \u274C "Listed projects" - just data retrieval
-
-**DO capture meaningful work:**
-- \u2705 Decisions, preferences, completed features
-- \u2705 Lessons from mistakes
-- \u2705 Insights about architecture or patterns
-
----
-
-### \u{1F6A8} Plans & Tasks - USE CONTEXTSTREAM, NOT FILE-BASED PLANS \u{1F6A8}
-
-**CRITICAL: When the user requests planning, implementation plans, roadmaps, task breakdowns, or step-by-step approaches:**
-
-\u274C **DO NOT** use built-in plan mode (EnterPlanMode tool)
-\u274C **DO NOT** write plans to markdown files or plan documents
-\u274C **DO NOT** ask "should I create a plan file?"
-
-\u2705 **ALWAYS** use ContextStream's plan/task system instead
-
-**Trigger phrases to detect (use ContextStream immediately):**
-- "create a plan", "make a plan", "plan this", "plan for"
-- "implementation plan", "roadmap", "milestones"
-- "break down", "breakdown", "break this into steps"
-- "what are the steps", "step by step", "outline the approach"
-- "task list", "todo list", "action items"
-- "how should we approach", "implementation strategy"
-
-**When detected, immediately:**
-
-1. **Create the plan in ContextStream:**
-\`\`\`
-session(action="capture_plan", title="<descriptive title>", description="<what this plan accomplishes>", goals=["goal1", "goal2"], steps=[{id: "1", title: "Step 1", order: 1, description: "..."}, ...])
-\`\`\`
-
-2. **Create tasks for each step:**
-\`\`\`
-memory(action="create_task", title="<task title>", plan_id="<plan_id from step 1>", priority="high|medium|low", description="<detailed task description>")
-\`\`\`
-
-**Why ContextStream plans are better:**
-- Plans persist across sessions and are searchable
-- Tasks track status (pending/in_progress/completed/blocked)
-- Context is preserved with workspace/project association
-- Can be retrieved with \`session(action="get_plan", plan_id="...", include_tasks=true)\`
-- Future sessions can continue from where you left off
-
-**Managing plans/tasks:**
-- List plans: \`session(action="list_plans")\`
-- Get plan with tasks: \`session(action="get_plan", plan_id="<uuid>", include_tasks=true)\`
-- List tasks: \`memory(action="list_tasks", plan_id="<uuid>")\` or \`memory(action="list_tasks")\` for all
-- Update task status: \`memory(action="update_task", task_id="<uuid>", task_status="pending|in_progress|completed|blocked")\`
-- Link task to plan: \`memory(action="update_task", task_id="<uuid>", plan_id="<plan_uuid>")\`
-- Unlink task from plan: \`memory(action="update_task", task_id="<uuid>", plan_id=null)\`
-- Delete: \`memory(action="delete_task", task_id="<uuid>")\` or \`memory(action="delete_event", event_id="<plan_uuid>")\`
-
----
-
-### Complete Action Reference
-
-**session actions:**
-- \`capture\` - Save decision/insight/task (requires: event_type, title, content)
-- \`capture_lesson\` - Save lesson from mistake (requires: title, category, trigger, impact, prevention)
-- \`get_lessons\` - Retrieve relevant lessons (optional: query, category, severity)
-- \`recall\` - Natural language memory recall (requires: query)
-- \`remember\` - Quick save to memory (requires: content)
-- \`user_context\` - Get user preferences/style
-- \`summary\` - Workspace summary
-- \`compress\` - Compress long conversation
-- \`delta\` - Changes since timestamp
-- \`smart_search\` - Context-enriched search
-- \`decision_trace\` - Trace decision provenance
-
-**memory actions:**
-- Event CRUD: \`create_event\`, \`get_event\`, \`update_event\`, \`delete_event\`, \`list_events\`, \`distill_event\`
-- Node CRUD: \`create_node\`, \`get_node\`, \`update_node\`, \`delete_node\`, \`list_nodes\`, \`supersede_node\`
-- Query: \`search\`, \`decisions\`, \`timeline\`, \`summary\`
-
-**graph actions:**
-- Analysis: \`dependencies\`, \`impact\`, \`call_path\`, \`related\`, \`path\`
-- Quality: \`circular_dependencies\`, \`unused_code\`, \`contradictions\`
-- Management: \`ingest\`, \`decisions\`
-
-See full documentation: https://contextstream.io/docs/mcp/tools
+Set environment variables:
+- \`CONTEXTSTREAM_HOOK_ENABLED=false\` - Disable PreToolUse blocking
+- \`CONTEXTSTREAM_REMINDER_ENABLED=false\` - Disable UserPromptSubmit reminders
 `.trim();
-    CONTEXTSTREAM_RULES_MINIMAL = `
-## ContextStream Rules
-
-<contextstream_rules>
-1. **SIMPLE UTILITY?** (list/show/version) \u2192 Just execute, skip context calls
-2. **CODING TASK?** \u2192 init \u2192 context \u2192 work \u2192 capture
-3. **SEARCH FIRST:** Before Glob/Grep/Read \u2192 \`search(mode="hybrid")\` FIRST
-</contextstream_rules>
-
-**Display this block at the start of responses to keep rules in context.**
-
----
-
-## ContextStream v0.4.x (Hooks Enforced)
-
-Rules Version: ${RULES_VERSION}
-**Note:** PreToolUse hooks block Glob/Grep/Search when ContextStream is available.
-
-### For Coding Tasks
-
-| Action | Tool Call |
-|--------|-----------|
-| **1st message** | \`init(folder_path="<cwd>", context_hint="<msg>")\` then \`context(...)\` |
-| **2nd+ messages** | \`context(user_message="<msg>", format="minified", max_tokens=400)\` |
-| **Code search** | \`search(mode="hybrid", query="...")\` \u2014 BEFORE any local tools |
-| **Save decisions** | \`session(action="capture", event_type="decision", ...)\` |
-
-### Search Modes
-
-| Mode | Use Case |
-|------|----------|
-| \`hybrid\` | General code search (default) |
-| \`keyword\` | Exact symbol/string match |
-| \`exhaustive\` | Find ALL matches (grep-like) |
-| \`semantic\` | Conceptual questions |
-
-### Why ContextStream First?
-
-\u274C **WRONG:** \`Grep \u2192 Read \u2192 Read \u2192 Read\` (4+ tool calls, slow)
-\u2705 **CORRECT:** \`search(mode="hybrid")\` (1 call, returns context)
-
-ContextStream search is **indexed** and returns semantic matches + context in ONE call.
-
-### Quick Reference
-
-| Tool | Example |
-|------|---------|
-| \`search\` | \`search(mode="hybrid", query="auth", limit=3)\` |
-| \`session\` | \`session(action="capture", event_type="decision", title="...", content="...")\` |
-| \`memory\` | \`memory(action="list_events", limit=10)\` |
-| \`graph\` | \`graph(action="dependencies", file_path="...")\` |
-
-### \u{1F680} FAST PATH: Simple Utility Operations
-
-**For simple utility commands, SKIP the ceremony and just execute directly:**
-
-| Command Type | Just Call | Skip |
-|--------------|-----------|------|
-| List workspaces | \`workspace(action="list")\` | init, context, capture |
-| List projects | \`project(action="list")\` | init, context, capture |
-| Show version | \`help(action="version")\` | init, context, capture |
-| List reminders | \`reminder(action="list")\` | init, context, capture |
-| Check auth | \`help(action="auth")\` | init, context, capture |
-
-**Detect simple operations by these patterns:**
-- "list ...", "show ...", "what are my ...", "get ..."
-- Single-action queries with no context dependency
-- User just wants data, not analysis or coding help
-
-**DO NOT add overhead for utility operations:**
-- \u274C Don't call init just to list workspaces
-- \u274C Don't call context for simple queries
-- \u274C Don't capture "listed workspaces" as an event (that's noise)
-
-**Use full context ceremony ONLY for:**
-- Coding tasks (edit, create, refactor, debug)
-- Search/discovery (finding code, understanding architecture)
-- Tasks where past decisions or lessons matter
-
-### Lessons (Past Mistakes)
-
-- After \`init\`: Check for \`lessons\` field and apply before work
-- Before risky work: \`session(action="get_lessons", query="<topic>")\`
-- On mistakes: \`session(action="capture_lesson", title="...", trigger="...", impact="...", prevention="...")\`
-
-### Context Pressure & Compaction
-
-- If \`context\` returns high/critical \`context_pressure\`: call \`session(action="capture", ...)\` to save state
-- PreCompact hooks automatically save snapshots before compaction (if installed)
-
-### Enhanced Context (Warnings)
+}
+var PRETOOLUSE_HOOK_SCRIPT, USER_PROMPT_HOOK_SCRIPT, MEDIA_AWARE_HOOK_SCRIPT, PRECOMPACT_HOOK_SCRIPT, CLINE_PRETOOLUSE_HOOK_SCRIPT, CLINE_USER_PROMPT_HOOK_SCRIPT, CLINE_POSTTOOLUSE_HOOK_SCRIPT, CLINE_HOOK_WRAPPER, CURSOR_PRETOOLUSE_HOOK_SCRIPT, CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT;
+var init_hooks_config = __esm({
+  "src/hooks-config.ts"() {
+    "use strict";
+    PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreToolUse Hook for Claude Code
+Blocks Grep/Glob/Search/Task(Explore)/EnterPlanMode and redirects to ContextStream.
+
+Only blocks if the current project is indexed in ContextStream.
+If not indexed, allows local tools through with a suggestion to index.
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+# Consider index stale after 7 days
+STALE_THRESHOLD_DAYS = 7
+
+DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
+
+def is_discovery_glob(pattern):
+    pattern_lower = pattern.lower()
+    for p in DISCOVERY_PATTERNS:
+        if p in pattern_lower:
+            return True
+    if pattern_lower.startswith("**/*.") or pattern_lower.startswith("**/"):
+        return True
+    if "**" in pattern or "*/" in pattern:
+        return True
+    return False
+
+def is_discovery_grep(file_path):
+    if not file_path or file_path in [".", "./", "*", "**"]:
+        return True
+    if "*" in file_path or "**" in file_path:
+        return True
+    return False
+
+def is_project_indexed(cwd: str) -> tuple[bool, bool]:
+    """
+    Check if the current directory is in an indexed project.
+    Returns (is_indexed, is_stale).
+    """
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+    cwd_path = Path(cwd).resolve()
+
+    # Check if cwd is within any indexed project
+    for project_path, info in projects.items():
+        try:
+            indexed_path = Path(project_path).resolve()
+            # Check if cwd is the project or a subdirectory
+            if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                # Check if stale
+                indexed_at = info.get("indexed_at")
+                if indexed_at:
+                    try:
+                        indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                        if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                            return True, True  # Indexed but stale
+                    except:
+                        pass
+                return True, False  # Indexed and fresh
+        except:
+            continue
+
+    return False, False
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    tool = data.get("tool_name", "")
+    inp = data.get("tool_input", {})
+    cwd = data.get("cwd", os.getcwd())
+
+    # Check if project is indexed
+    is_indexed, is_stale = is_project_indexed(cwd)
+
+    if not is_indexed:
+        # Project not indexed - allow local tools but suggest indexing
+        # Don't block, just exit successfully
+        sys.exit(0)
+
+    if is_stale:
+        # Index is stale - allow with warning (printed but not blocking)
+        # Still allow the tool but remind about re-indexing
+        pass  # Continue to blocking logic but could add warning
+
+    if tool == "Glob":
+        pattern = inp.get("pattern", "")
+        if is_discovery_glob(pattern):
+            print(f"STOP: Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of Glob.", file=sys.stderr)
+            sys.exit(2)
+
+    elif tool == "Grep" or tool == "Search":
+        # Block ALL Grep/Search operations - use ContextStream search or Read for specific files
+        pattern = inp.get("pattern", "")
+        path = inp.get("path", "")
+        if pattern:
+            if path and not is_discovery_grep(path):
+                # Specific file - suggest Read instead
+                print(f"STOP: Use Read(\\"{path}\\") to view file content, or mcp__contextstream__search(mode=\\"keyword\\", query=\\"{pattern}\\") for codebase search.", file=sys.stderr)
+            else:
+                print(f"STOP: Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}.", file=sys.stderr)
+            sys.exit(2)
+
+    elif tool == "Task":
+        if inp.get("subagent_type", "").lower() == "explore":
+            print("STOP: Use mcp__contextstream__search(mode=\\"hybrid\\") instead of Task(Explore).", file=sys.stderr)
+            sys.exit(2)
+        if inp.get("subagent_type", "").lower() == "plan":
+            print("STOP: Use mcp__contextstream__session(action=\\"capture_plan\\") for planning. ContextStream plans persist across sessions.", file=sys.stderr)
+            sys.exit(2)
+
+    elif tool == "EnterPlanMode":
+        print("STOP: Use mcp__contextstream__session(action=\\"capture_plan\\", title=\\"...\\", steps=[...]) instead of EnterPlanMode. ContextStream plans persist across sessions and are searchable.", file=sys.stderr)
+        sys.exit(2)
+
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+    USER_PROMPT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream UserPromptSubmit Hook - Injects reminder on every message.
+"""
 
-\`context\` returns server-side \`warnings\` for lessons, risky actions, and breaking changes.
-When warnings are present: **STOP**, acknowledge them, explain mitigation, then proceed.
+import json
+import sys
+import os
 
-### Automatic Context Restoration
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
 
-**Context restoration is now enabled by default.** Every \`init\` call automatically:
-- Restores context from recent snapshots (if available)
-- Returns \`restored_context\` field with snapshot data
-- Sets \`is_post_compact=true\` in response when restoration occurs
+REMINDER = """[CONTEXTSTREAM RULES]
+1. BEFORE Glob/Grep/Read/Search: mcp__contextstream__search(mode="hybrid") FIRST
+2. Call context_smart at start of EVERY response
+3. Local tools ONLY if ContextStream returns 0 results
+[END RULES]"""
 
-**No special handling needed after compaction** - just call \`init\` normally.
+def main():
+    if not ENABLED:
+        sys.exit(0)
 
-To disable automatic restoration:
-- Pass \`is_post_compact=false\` in the API call
-- Or set \`CONTEXTSTREAM_RESTORE_CONTEXT=false\` environment variable
+    try:
+        json.load(sys.stdin)
+    except:
+        sys.exit(0)
 
-### Notices - MUST HANDLE IMMEDIATELY
+    print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": REMINDER}}))
+    sys.exit(0)
 
-- **[VERSION_NOTICE]**: Tell the user about the update and command to run
-- **[RULES_NOTICE]**: Run \`generate_rules(overwrite_existing=true)\` to update
-- **[LESSONS_WARNING]**: Read lessons, tell user about them, explain how you'll avoid past mistakes
+if __name__ == "__main__":
+    main()
+`;
+    MEDIA_AWARE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream Media-Aware Hook for Claude Code
+
+Detects media-related prompts and injects context about the media tool.
+"""
+
+import json
+import sys
+import os
+import re
+
+ENABLED = os.environ.get("CONTEXTSTREAM_MEDIA_HOOK_ENABLED", "true").lower() == "true"
+
+# Media patterns (case-insensitive)
+PATTERNS = [
+    r"\\b(video|videos|clip|clips|footage|keyframe)s?\\b",
+    r"\\b(remotion|timeline|video\\s*edit)\\b",
+    r"\\b(image|images|photo|photos|picture|thumbnail)s?\\b",
+    r"\\b(audio|podcast|transcript|transcription|voice)\\b",
+    r"\\b(media|asset|assets|creative|b-roll)\\b",
+    r"\\b(find|search|show).*(clip|video|image|audio|footage|media)\\b",
+]
+
+COMPILED = [re.compile(p, re.IGNORECASE) for p in PATTERNS]
+
+MEDIA_CONTEXT = """[MEDIA TOOLS AVAILABLE]
+Your workspace may have indexed media. Use ContextStream media tools:
+
+- **Search**: \`mcp__contextstream__media(action="search", query="description")\`
+- **Get clip**: \`mcp__contextstream__media(action="get_clip", content_id="...", start="1:34", end="2:15", output_format="remotion|ffmpeg|raw")\`
+- **List assets**: \`mcp__contextstream__media(action="list")\`
+- **Index**: \`mcp__contextstream__media(action="index", file_path="...", content_type="video|audio|image|document")\`
+
+For Remotion: use \`output_format="remotion"\` to get frame-based props.
+[END MEDIA TOOLS]"""
+
+def matches(text):
+    return any(p.search(text) for p in COMPILED)
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    prompt = data.get("prompt", "")
+    if not prompt:
+        session = data.get("session", {})
+        for msg in reversed(session.get("messages", [])):
+            if msg.get("role") == "user":
+                content = msg.get("content", "")
+                prompt = content if isinstance(content, str) else ""
+                if isinstance(content, list):
+                    for b in content:
+                        if isinstance(b, dict) and b.get("type") == "text":
+                            prompt = b.get("text", "")
+                            break
+                break
+
+    if not prompt or not matches(prompt):
+        sys.exit(0)
+
+    print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": MEDIA_CONTEXT}}))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+    PRECOMPACT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreCompact Hook for Claude Code
+
+Runs BEFORE conversation context is compacted (manual via /compact or automatic).
+Automatically saves conversation state to ContextStream by parsing the transcript.
+
+Input (via stdin):
+{
+  "session_id": "...",
+  "transcript_path": "/path/to/transcript.jsonl",
+  "permission_mode": "default",
+  "hook_event_name": "PreCompact",
+  "trigger": "manual" | "auto",
+  "custom_instructions": "..."
+}
 
-### Plans & Tasks
+Output (to stdout):
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreCompact",
+    "additionalContext": "... status message ..."
+  }
+}
+"""
+
+import json
+import sys
+import os
+import re
+import urllib.request
+import urllib.error
+
+ENABLED = os.environ.get("CONTEXTSTREAM_PRECOMPACT_ENABLED", "true").lower() == "true"
+AUTO_SAVE = os.environ.get("CONTEXTSTREAM_PRECOMPACT_AUTO_SAVE", "true").lower() == "true"
+API_URL = os.environ.get("CONTEXTSTREAM_API_URL", "https://api.contextstream.io")
+API_KEY = os.environ.get("CONTEXTSTREAM_API_KEY", "")
+
+WORKSPACE_ID = None
+
+def load_config_from_mcp_json(cwd):
+    """Load API config from .mcp.json if env vars not set."""
+    global API_URL, API_KEY, WORKSPACE_ID
+
+    # Try to find .mcp.json and .contextstream/config.json in cwd or parent directories
+    search_dir = cwd
+    for _ in range(5):  # Search up to 5 levels
+        # Load API config from .mcp.json
+        if not API_KEY:
+            mcp_path = os.path.join(search_dir, ".mcp.json")
+            if os.path.exists(mcp_path):
+                try:
+                    with open(mcp_path, 'r') as f:
+                        config = json.load(f)
+                    servers = config.get("mcpServers", {})
+                    cs_config = servers.get("contextstream", {})
+                    env = cs_config.get("env", {})
+                    if env.get("CONTEXTSTREAM_API_KEY"):
+                        API_KEY = env["CONTEXTSTREAM_API_KEY"]
+                    if env.get("CONTEXTSTREAM_API_URL"):
+                        API_URL = env["CONTEXTSTREAM_API_URL"]
+                except:
+                    pass
+
+        # Load workspace_id from .contextstream/config.json
+        if not WORKSPACE_ID:
+            cs_config_path = os.path.join(search_dir, ".contextstream", "config.json")
+            if os.path.exists(cs_config_path):
+                try:
+                    with open(cs_config_path, 'r') as f:
+                        cs_config = json.load(f)
+                    if cs_config.get("workspace_id"):
+                        WORKSPACE_ID = cs_config["workspace_id"]
+                except:
+                    pass
+
+        parent = os.path.dirname(search_dir)
+        if parent == search_dir:
+            break
+        search_dir = parent
+
+def parse_transcript(transcript_path):
+    """Parse transcript to extract active files, decisions, and context."""
+    active_files = set()
+    recent_messages = []
+    tool_calls = []
+
+    try:
+        with open(transcript_path, 'r') as f:
+            for line in f:
+                try:
+                    entry = json.loads(line.strip())
+                    msg_type = entry.get("type", "")
+
+                    # Extract files from tool calls
+                    if msg_type == "tool_use":
+                        tool_name = entry.get("name", "")
+                        tool_input = entry.get("input", {})
+                        tool_calls.append({"name": tool_name, "input": tool_input})
+
+                        # Extract file paths from common tools
+                        if tool_name in ["Read", "Write", "Edit", "NotebookEdit"]:
+                            file_path = tool_input.get("file_path") or tool_input.get("notebook_path")
+                            if file_path:
+                                active_files.add(file_path)
+                        elif tool_name == "Glob":
+                            pattern = tool_input.get("pattern", "")
+                            if pattern:
+                                active_files.add(f"[glob:{pattern}]")
+
+                    # Collect recent assistant messages for summary
+                    if msg_type == "assistant" and entry.get("content"):
+                        content = entry.get("content", "")
+                        if isinstance(content, str) and len(content) > 50:
+                            recent_messages.append(content[:500])
+
+                except json.JSONDecodeError:
+                    continue
+    except Exception as e:
+        pass
+
+    return {
+        "active_files": list(active_files)[-20:],  # Last 20 files
+        "tool_call_count": len(tool_calls),
+        "message_count": len(recent_messages),
+        "last_tools": [t["name"] for t in tool_calls[-10:]],  # Last 10 tool names
+    }
 
-When user asks for a plan, use ContextStream (not EnterPlanMode):
-1. \`session(action="capture_plan", title="...", steps=[...])\`
-2. \`memory(action="create_task", title="...", plan_id="<id>")\`
+def save_snapshot(session_id, transcript_data, trigger):
+    """Save snapshot to ContextStream API."""
+    if not API_KEY:
+        return False, "No API key configured"
+
+    snapshot_content = {
+        "session_id": session_id,
+        "trigger": trigger,
+        "captured_at": None,  # API will set timestamp
+        "active_files": transcript_data.get("active_files", []),
+        "tool_call_count": transcript_data.get("tool_call_count", 0),
+        "last_tools": transcript_data.get("last_tools", []),
+        "auto_captured": True,
+    }
 
-### Workspace-Only Mode (Multi-Project Folders)
+    payload = {
+        "event_type": "session_snapshot",
+        "title": f"Auto Pre-compaction Snapshot ({trigger})",
+        "content": json.dumps(snapshot_content),
+        "importance": "high",
+        "tags": ["session_snapshot", "pre_compaction", "auto_captured"],
+        "source_type": "hook",
+    }
 
-If working in a parent folder containing multiple projects:
-\`\`\`
-init(folder_path="...", skip_project_creation=true)
-\`\`\`
+    # Add workspace_id if available
+    if WORKSPACE_ID:
+        payload["workspace_id"] = WORKSPACE_ID
+
+    try:
+        req = urllib.request.Request(
+            f"{API_URL}/api/v1/memory/events",
+            data=json.dumps(payload).encode('utf-8'),
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": API_KEY,
+            },
+            method="POST"
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            return True, "Snapshot saved"
+    except urllib.error.URLError as e:
+        return False, str(e)
+    except Exception as e:
+        return False, str(e)
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    # Load config from .mcp.json if env vars not set
+    cwd = data.get("cwd", os.getcwd())
+    load_config_from_mcp_json(cwd)
+
+    session_id = data.get("session_id", "unknown")
+    transcript_path = data.get("transcript_path", "")
+    trigger = data.get("trigger", "unknown")
+    custom_instructions = data.get("custom_instructions", "")
+
+    # Parse transcript for context
+    transcript_data = {}
+    if transcript_path and os.path.exists(transcript_path):
+        transcript_data = parse_transcript(transcript_path)
+
+    # Auto-save snapshot if enabled
+    auto_save_status = ""
+    if AUTO_SAVE and API_KEY:
+        success, msg = save_snapshot(session_id, transcript_data, trigger)
+        if success:
+            auto_save_status = f"\\n[ContextStream: Auto-saved snapshot with {len(transcript_data.get('active_files', []))} active files]"
+        else:
+            auto_save_status = f"\\n[ContextStream: Auto-save failed - {msg}]"
+
+    # Build context injection for the AI (backup in case auto-save fails)
+    files_list = ", ".join(transcript_data.get("active_files", [])[:5]) or "none detected"
+    context = f"""[CONTEXT COMPACTION - {trigger.upper()}]{auto_save_status}
+
+Active files detected: {files_list}
+Tool calls in session: {transcript_data.get('tool_call_count', 0)}
+
+After compaction, call session_init(is_post_compact=true) to restore context.
+{f"User instructions: {custom_instructions}" if custom_instructions else ""}"""
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreCompact",
+            "additionalContext": context
+        }
+    }
 
-This enables workspace-level memory and context without project-specific indexing.
-Use for monorepos or folders with multiple independent projects.
+    print(json.dumps(output))
+    sys.exit(0)
 
-Full docs: https://contextstream.io/docs/mcp/tools
-`.trim();
-    TEMPLATES = {
-      codex: {
-        filename: "AGENTS.md",
-        description: "Codex CLI agent instructions",
-        build: (rules) => `# Codex CLI Instructions
-${rules}
-`
-      },
-      cursor: {
-        filename: ".cursorrules",
-        description: "Cursor AI rules",
-        build: (rules) => `# Cursor Rules
-${rules}
-`
-      },
-      cline: {
-        filename: ".clinerules",
-        description: "Cline AI rules",
-        build: (rules) => `# Cline Rules
-${rules}
-`
-      },
-      kilo: {
-        filename: ".kilocode/rules/contextstream.md",
-        description: "Kilo Code AI rules",
-        build: (rules) => `# Kilo Code Rules
-${rules}
-`
-      },
-      roo: {
-        filename: ".roo/rules/contextstream.md",
-        description: "Roo Code AI rules",
-        build: (rules) => `# Roo Code Rules
-${rules}
-`
-      },
-      claude: {
-        filename: "CLAUDE.md",
-        description: "Claude Code instructions",
-        build: (rules) => `# Claude Code Instructions
-${rules}
-`
-      },
-      aider: {
-        filename: ".aider.conf.yml",
-        description: "Aider configuration with system prompt",
-        build: (rules) => `# Aider Configuration
-# Note: Aider uses different config format - this adds to the system prompt
-
-# Add ContextStream guidance to conventions
-conventions: |
-${rules.split("\n").map((line) => "  " + line).join("\n")}
-`
-      },
-      antigravity: {
-        filename: "GEMINI.md",
-        description: "Google Antigravity AI rules",
-        build: (rules) => `# Antigravity Agent Rules
-${rules}
-`
-      }
-    };
+if __name__ == "__main__":
+    main()
+`;
+    CLINE_PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreToolUse Hook for Cline
+Blocks discovery tools and redirects to ContextStream search.
+
+Cline hooks use JSON output format:
+{
+  "cancel": true/false,
+  "errorMessage": "optional error description",
+  "contextModification": "optional text to inject"
+}
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+STALE_THRESHOLD_DAYS = 7
+
+DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
+
+def is_discovery_glob(pattern):
+    pattern_lower = pattern.lower()
+    for p in DISCOVERY_PATTERNS:
+        if p in pattern_lower:
+            return True
+    if pattern_lower.startswith("**/*.") or pattern_lower.startswith("**/"):
+        return True
+    if "**" in pattern or "*/" in pattern:
+        return True
+    return False
+
+def is_discovery_grep(file_path):
+    if not file_path or file_path in [".", "./", "*", "**"]:
+        return True
+    if "*" in file_path or "**" in file_path:
+        return True
+    return False
+
+def is_project_indexed(workspace_roots):
+    """Check if any workspace root is in an indexed project."""
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+
+    for workspace in workspace_roots:
+        cwd_path = Path(workspace).resolve()
+        for project_path, info in projects.items():
+            try:
+                indexed_path = Path(project_path).resolve()
+                if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                    indexed_at = info.get("indexed_at")
+                    if indexed_at:
+                        try:
+                            indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                            if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                                return True, True
+                        except:
+                            pass
+                    return True, False
+            except:
+                continue
+    return False, False
+
+def output_allow(context_mod=None):
+    result = {"cancel": False}
+    if context_mod:
+        result["contextModification"] = context_mod
+    print(json.dumps(result))
+    sys.exit(0)
+
+def output_block(error_msg, context_mod=None):
+    result = {"cancel": True, "errorMessage": error_msg}
+    if context_mod:
+        result["contextModification"] = context_mod
+    print(json.dumps(result))
+    sys.exit(0)
+
+def main():
+    if not ENABLED:
+        output_allow()
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        output_allow()
+
+    hook_name = data.get("hookName", "")
+    if hook_name != "PreToolUse":
+        output_allow()
+
+    tool = data.get("toolName", "")
+    params = data.get("toolParameters", {})
+    workspace_roots = data.get("workspaceRoots", [])
+
+    # Check if project is indexed
+    is_indexed, is_stale = is_project_indexed(workspace_roots)
+    if not is_indexed:
+        output_allow()
+
+    # Check for discovery patterns
+    if tool == "list_files" or tool == "search_files":
+        pattern = params.get("path", "") or params.get("regex", "")
+        if is_discovery_glob(pattern) or is_discovery_grep(pattern):
+            output_block(
+                f"Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster. Only use local tools if ContextStream returns 0 results.",
+                "[CONTEXTSTREAM] Use ContextStream search for code discovery."
+            )
+
+    elif tool == "read_file":
+        # Allow read_file by default - blocking discovery at search level is enough
+        pass
+
+    output_allow()
+
+if __name__ == "__main__":
+    main()
+`;
+    CLINE_USER_PROMPT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream UserPromptSubmit Hook for Cline
+Injects reminder about ContextStream rules on every message.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+REMINDER = """[CONTEXTSTREAM RULES]
+1. BEFORE list_files/search_files/read_file: mcp__contextstream__search(mode="hybrid") FIRST
+2. Call context_smart at start of EVERY response
+3. Local tools ONLY if ContextStream returns 0 results
+[END RULES]"""
+
+def main():
+    if not ENABLED:
+        print(json.dumps({"cancel": False}))
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        print(json.dumps({"cancel": False}))
+        sys.exit(0)
+
+    print(json.dumps({
+        "cancel": False,
+        "contextModification": REMINDER
+    }))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+    CLINE_POSTTOOLUSE_HOOK_SCRIPT = `#!/bin/bash
+# ContextStream PostToolUse Hook for Cline/Roo/Kilo Code
+# Indexes files after Edit/Write/NotebookEdit operations for real-time search updates.
+#
+# The hook receives JSON on stdin with tool_name and toolParameters.
+# Only runs for write operations (write_to_file, edit_file).
+
+TOOL_NAME=$(cat | python3 -c "import sys, json; d=json.load(sys.stdin); print(d.get('toolName', d.get('tool_name', '')))" 2>/dev/null)
+
+case "$TOOL_NAME" in
+  write_to_file|edit_file|Write|Edit|NotebookEdit)
+    npx @contextstream/mcp-server hook post-write
+    ;;
+esac
+
+exit 0
+`;
+    CLINE_HOOK_WRAPPER = (hookName) => `#!/bin/bash
+# ContextStream ${hookName} Hook Wrapper for Cline/Roo/Kilo Code
+# Calls the Node.js hook via npx
+exec npx @contextstream/mcp-server hook ${hookName}
+`;
+    CURSOR_PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreToolUse Hook for Cursor
+Blocks discovery tools and redirects to ContextStream search.
+
+Cursor hooks use JSON output format:
+{
+  "decision": "allow" | "deny",
+  "reason": "optional error description"
+}
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+STALE_THRESHOLD_DAYS = 7
+
+DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
+
+def is_discovery_glob(pattern):
+    pattern_lower = pattern.lower()
+    for p in DISCOVERY_PATTERNS:
+        if p in pattern_lower:
+            return True
+    if pattern_lower.startswith("**/*.") or pattern_lower.startswith("**/"):
+        return True
+    if "**" in pattern or "*/" in pattern:
+        return True
+    return False
+
+def is_discovery_grep(file_path):
+    if not file_path or file_path in [".", "./", "*", "**"]:
+        return True
+    if "*" in file_path or "**" in file_path:
+        return True
+    return False
+
+def is_project_indexed(workspace_roots):
+    """Check if any workspace root is in an indexed project."""
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+
+    for workspace in workspace_roots:
+        cwd_path = Path(workspace).resolve()
+        for project_path, info in projects.items():
+            try:
+                indexed_path = Path(project_path).resolve()
+                if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                    indexed_at = info.get("indexed_at")
+                    if indexed_at:
+                        try:
+                            indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                            if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                                return True, True
+                        except:
+                            pass
+                    return True, False
+            except:
+                continue
+    return False, False
+
+def output_allow():
+    print(json.dumps({"decision": "allow"}))
+    sys.exit(0)
+
+def output_deny(reason):
+    print(json.dumps({"decision": "deny", "reason": reason}))
+    sys.exit(0)
+
+def main():
+    if not ENABLED:
+        output_allow()
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        output_allow()
+
+    hook_name = data.get("hook_event_name", "")
+    if hook_name != "preToolUse":
+        output_allow()
+
+    tool = data.get("tool_name", "")
+    params = data.get("tool_input", {}) or data.get("parameters", {})
+    workspace_roots = data.get("workspace_roots", [])
+
+    # Check if project is indexed
+    is_indexed, _ = is_project_indexed(workspace_roots)
+    if not is_indexed:
+        output_allow()
+
+    # Check for Cursor tools
+    if tool in ["Glob", "glob", "list_files"]:
+        pattern = params.get("pattern", "") or params.get("path", "")
+        if is_discovery_glob(pattern):
+            output_deny(
+                f"Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster."
+            )
+
+    elif tool in ["Grep", "grep", "search_files", "ripgrep"]:
+        pattern = params.get("pattern", "") or params.get("regex", "")
+        file_path = params.get("path", "")
+        if is_discovery_grep(file_path):
+            output_deny(
+                f"Use mcp__contextstream__search(mode=\\"keyword\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster."
+            )
+
+    output_allow()
+
+if __name__ == "__main__":
+    main()
+`;
+    CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream BeforeSubmitPrompt Hook for Cursor
+Injects reminder about ContextStream rules.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+def main():
+    if not ENABLED:
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+    print(json.dumps({
+        "continue": True,
+        "user_message": "[CONTEXTSTREAM] Search with mcp__contextstream__search before using Glob/Grep/Read"
+    }))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
   }
 });
 
 // src/hooks/auto-rules.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { homedir } from "node:os";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
 var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
 var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
 var ENABLED = process.env.CONTEXTSTREAM_AUTO_RULES !== "false";
-var MARKER_FILE = path.join(homedir(), ".contextstream", ".auto-rules-ran");
+var MARKER_FILE = path2.join(homedir2(), ".contextstream", ".auto-rules-ran");
 var COOLDOWN_MS = 4 * 60 * 60 * 1e3;
 function hasRunRecently() {
   try {
-    if (!fs.existsSync(MARKER_FILE)) return false;
-    const stat = fs.statSync(MARKER_FILE);
+    if (!fs2.existsSync(MARKER_FILE)) return false;
+    const stat = fs2.statSync(MARKER_FILE);
     const age = Date.now() - stat.mtimeMs;
     return age < COOLDOWN_MS;
   } catch {
@@ -824,11 +1516,11 @@ function hasRunRecently() {
 }
 function markAsRan() {
   try {
-    const dir = path.dirname(MARKER_FILE);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    const dir = path2.dirname(MARKER_FILE);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
     }
-    fs.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
+    fs2.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
 }
@@ -855,14 +1547,49 @@ function extractCwd(input) {
   if (input.cwd) return input.cwd;
   return process.cwd();
 }
-async function generateRulesForFolder(folderPath) {
-  const { generateAllRuleFiles: generateAllRuleFiles2 } = await Promise.resolve().then(() => (init_rules_templates(), rules_templates_exports));
-  await generateAllRuleFiles2({
-    folderPath,
-    editors: ["cursor", "cline", "kilo", "roo", "claude", "aider", "codex"],
-    overwriteExisting: true,
-    mode: "minimal"
-    // Use minimal mode for auto-updates
+function hasPythonHooks(settingsPath) {
+  try {
+    if (!fs2.existsSync(settingsPath)) return false;
+    const content = fs2.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    const hooks = settings.hooks;
+    if (!hooks) return false;
+    for (const hookType of Object.keys(hooks)) {
+      const matchers = hooks[hookType];
+      if (!Array.isArray(matchers)) continue;
+      for (const matcher of matchers) {
+        const hookList = matcher.hooks;
+        if (!Array.isArray(hookList)) continue;
+        for (const hook of hookList) {
+          const cmd = hook.command || "";
+          if (cmd.includes("python3") && cmd.includes("contextstream")) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function detectPythonHooks(cwd) {
+  const globalSettingsPath = path2.join(homedir2(), ".claude", "settings.json");
+  const projectSettingsPath = path2.join(cwd, ".claude", "settings.json");
+  return {
+    global: hasPythonHooks(globalSettingsPath),
+    project: hasPythonHooks(projectSettingsPath)
+  };
+}
+async function upgradeHooksForFolder(folderPath) {
+  const { installClaudeCodeHooks: installClaudeCodeHooks2 } = await Promise.resolve().then(() => (init_hooks_config(), hooks_config_exports));
+  await installClaudeCodeHooks2({
+    scope: "both",
+    projectPath: folderPath,
+    includePreCompact: true,
+    includeMediaAware: true,
+    includePostWrite: true,
+    includeAutoRules: true
   });
 }
 async function runAutoRulesHook() {
@@ -890,14 +1617,17 @@ async function runAutoRulesHook() {
   if (!isContextTool) {
     process.exit(0);
   }
+  const cwd = extractCwd(input);
+  const pythonHooks = detectPythonHooks(cwd);
+  const hasPythonHooksToUpgrade = pythonHooks.global || pythonHooks.project;
   const rulesNotice = extractRulesNotice(input);
-  if (!rulesNotice || rulesNotice.status === "current") {
+  const rulesNeedUpdate = rulesNotice && rulesNotice.status !== "current";
+  if (!hasPythonHooksToUpgrade && !rulesNeedUpdate) {
     process.exit(0);
   }
-  const cwd = extractCwd(input);
-  const folderPath = rulesNotice.update_args?.folder_path || cwd;
+  const folderPath = rulesNotice?.update_args?.folder_path || cwd;
   try {
-    await generateRulesForFolder(folderPath);
+    await upgradeHooksForFolder(folderPath);
     markAsRan();
   } catch {
   }