@contextstream/mcp-server 0.4.38 → 0.4.39

package/dist/index.js

@@ -8872,16 +8872,15 @@ function applyMcpToolPrefix(markdown, toolPrefix) {
   return markdown.replace(toolRegex, `${toolPrefix}$1`);
 }
 var CONTEXTSTREAM_RULES_FULL = `
-## \u{1F6A8} MANDATORY RULE: DISPLAY AT START OF EVERY RESPONSE \u{1F6A8}
+## ContextStream Rules
 
 <contextstream_rules>
-1. **SEARCH FIRST:** Before Glob/Grep/Search/Read \u2192 \`search(mode="hybrid", query="...")\` FIRST
-2. **EVERY MESSAGE:** Call \`context_smart(user_message="...")\` at start of response
-3. **LOCAL TOOLS:** ONLY if ContextStream search returns 0 results after retry
+1. **SIMPLE UTILITY?** (list/show/version) \u2192 Just execute, skip context calls
+2. **CODING TASK?** \u2192 session_init \u2192 context_smart \u2192 work \u2192 capture
+3. **SEARCH FIRST:** Before Glob/Grep/Read \u2192 \`search(mode="hybrid")\` FIRST
 </contextstream_rules>
 
-**You MUST display the <contextstream_rules> block verbatim at the start of EVERY response.**
-This is a self-referential rule that ensures these instructions stay in recent context.
+**Display this block at the start of responses to keep rules in context.**
 
 ---
 
@@ -8940,8 +8939,10 @@ This applies to **EVERY search** throughout the **ENTIRE conversation**, not jus
 - **Apply the prevention steps** from each lesson to avoid repeating mistakes
 
 ### On \`context_smart\`:
-- Check for any lessons in the returned context
-- Lessons may be included based on semantic relevance to the user's message
+- 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:
@@ -8965,22 +8966,42 @@ 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 - REQUIRED EVERY MESSAGE
+## TL;DR - WHEN TO USE CONTEXT
 
-| Message | What to Call |
-|---------|--------------|
-| **1st message** | \`session_init(folder_path="...", context_hint="<user's message>")\`, then \`context_smart(...)\` |
-| **\u26A0\uFE0F After session_init** | **CHECK \`lessons\` field** - if present, read and apply them BEFORE any work |
-| **2nd+ messages** | \`context_smart(user_message="<user's message>", format="minified", max_tokens=400)\` |
-| **\u{1F50D} ANY code search** | \`search(mode="hybrid", query="...")\` \u2014 ALWAYS before Glob/Grep/Search/Read |
-| **\u26A0\uFE0F Before ANY risky work** | \`session(action="get_lessons", query="<topic>")\` \u2014 **MANDATORY, not optional** |
-| **After completing task** | \`session(action="capture", event_type="decision", ...)\` - MUST capture |
-| **User frustration/correction** | \`session(action="capture_lesson", ...)\` - MUST capture lessons |
-| **Command/tool error + fix** | \`session(action="capture_lesson", ...)\` - MUST capture lessons |
+| Request Type | What to Do |
+|--------------|------------|
+| **\u{1F680} Simple utility** (list workspaces, show version) | **Just execute directly** - skip session_init, context_smart, capture |
+| **\u{1F4BB} Coding task** (edit, create, refactor) | Full context: session_init \u2192 context_smart \u2192 work \u2192 capture |
+| **\u{1F50D} Code search/discovery** | session_init \u2192 context_smart \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", ...)\` |
 
-**NO EXCEPTIONS.** Do not skip even if you think you have enough context.
+### Simple Utility Operations - FAST PATH
 
-**First message rule:** After \`session_init\`:
+**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 session_init. No context_smart. No capture.** These add noise, not value.
+
+### Coding Tasks - FULL CONTEXT
+
+| Step | What to Call |
+|------|--------------|
+| **1st message** | \`session_init(folder_path="...", context_hint="<msg>")\`, then \`context_smart(...)\` |
+| **2nd+ messages** | \`context_smart(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", ...)\` |
+
+**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 \`session_init\`:
 1. Check for \`lessons\` in response - if present, READ and SUMMARIZE them to user
 2. Then call \`context_smart\` before any other tool or response
 
@@ -8994,9 +9015,9 @@ Rules Version: ${RULES_VERSION}
 
 v0.4.x consolidates ~58 individual tools into ~11 domain tools with action/mode dispatch:
 
-### Standalone Tools (Always Call)
-- **\`session_init\`** - Initialize session with workspace detection + context
-- **\`context_smart\`** - Semantic search for relevant context (CALL EVERY MESSAGE, including immediately after \`session_init\`)
+### Standalone Tools
+- **\`session_init\`** - Initialize session with workspace detection + context (skip for simple utility operations)
+- **\`context_smart\`** - Semantic search for relevant context (skip for simple utility operations)
 
 ### Domain Tools (Use action/mode parameter)
 
@@ -9043,10 +9064,21 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 ---
 
-### Rules Update Notices
+### Rules, Version & Lessons Notices
+
+**[RULES_NOTICE]** - Update rules via \`generate_rules()\` (or rerun setup).
 
-- If you see **[RULES_NOTICE]**, update rules via \`generate_rules()\` (or rerun setup).
-- If you see **[VERSION_NOTICE]**, tell the user to update MCP using the provided command.
+**[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.
 
 ---
 
@@ -9177,16 +9209,24 @@ If ContextStream returns results, stop and use them. NEVER use local Search/Expl
 
 ---
 
-### When to Capture (MANDATORY)
+### 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" |
-| You complete a task | \`session(action="capture", event_type="task", ...)\` | Capture what was done |
+| 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?" |
 
-**You MUST capture after completing any significant task.** This ensures future sessions have context.
+**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
 
 ---
 
@@ -9266,16 +9306,15 @@ memory(action="create_task", title="<task title>", plan_id="<plan_id from step 1
 See full documentation: https://contextstream.io/docs/mcp/tools
 `.trim();
 var CONTEXTSTREAM_RULES_MINIMAL = `
-## \u{1F6A8} MANDATORY RULE: DISPLAY AT START OF EVERY RESPONSE \u{1F6A8}
+## ContextStream Rules
 
 <contextstream_rules>
-1. **SEARCH FIRST:** Before Glob/Grep/Search/Read \u2192 \`search(mode="hybrid", query="...")\` FIRST
-2. **EVERY MESSAGE:** Call \`context_smart(user_message="...")\` at start of response
-3. **LOCAL TOOLS:** ONLY if ContextStream search returns 0 results after retry
+1. **SIMPLE UTILITY?** (list/show/version) \u2192 Just execute, skip context calls
+2. **CODING TASK?** \u2192 session_init \u2192 context_smart \u2192 work \u2192 capture
+3. **SEARCH FIRST:** Before Glob/Grep/Read \u2192 \`search(mode="hybrid")\` FIRST
 </contextstream_rules>
 
-**You MUST display the <contextstream_rules> block verbatim at the start of EVERY response.**
-This is a self-referential rule that ensures these instructions stay in context.
+**Display this block at the start of responses to keep rules in context.**
 
 ---
 
@@ -9284,7 +9323,7 @@ This is a self-referential rule that ensures these instructions stay in context.
 Rules Version: ${RULES_VERSION}
 **Note:** PreToolUse hooks block Glob/Grep/Search when ContextStream is available.
 
-### Required Every Message
+### For Coding Tasks
 
 | Action | Tool Call |
 |--------|-----------|
@@ -9318,6 +9357,33 @@ ContextStream search is **indexed** and returns semantic matches + context in ON
 | \`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")\` | session_init, context_smart, capture |
+| List projects | \`project(action="list")\` | session_init, context_smart, capture |
+| Show version | \`help(action="version")\` | session_init, context_smart, capture |
+| List reminders | \`reminder(action="list")\` | session_init, context_smart, capture |
+| Check auth | \`help(action="auth")\` | session_init, context_smart, 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 session_init just to list workspaces
+- \u274C Don't call context_smart 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 \`session_init\`: Check for \`lessons\` field and apply before work
@@ -9326,8 +9392,27 @@ ContextStream search is **indexed** and returns semantic matches + context in ON
 
 ### Context Pressure & Compaction
 
-- If \`context_smart\` returns high/critical \`context_pressure\`: call \`session_capture_smart(...)\` to save state
-- After compaction (context lost): call \`session_init(..., is_post_compact=true)\` or \`session_restore_context()\`
+- If \`context_smart\` returns high/critical \`context_pressure\`: call \`session(action="capture", ...)\` to save state
+- PreCompact hooks automatically save snapshots before compaction (if installed)
+
+### Automatic Context Restoration
+
+**Context restoration is now enabled by default.** Every \`session_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
+
+**No special handling needed after compaction** - just call \`session_init\` normally.
+
+To disable automatic restoration:
+- Pass \`is_post_compact=false\` in the API call
+- Or set \`CONTEXTSTREAM_RESTORE_CONTEXT=false\` environment variable
+
+### Notices - MUST HANDLE IMMEDIATELY
+
+- **[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
 
 ### Plans & Tasks
 
@@ -9805,7 +9890,7 @@ var PRECOMPACT_HOOK_SCRIPT = `#!/usr/bin/env python3
 ContextStream PreCompact Hook for Claude Code
 
 Runs BEFORE conversation context is compacted (manual via /compact or automatic).
-Injects a reminder for the AI to save conversation state using session_capture_smart.
+Automatically saves conversation state to ContextStream by parsing the transcript.
 
 Input (via stdin):
 {
@@ -9821,7 +9906,7 @@ Output (to stdout):
 {
   "hookSpecificOutput": {
     "hookEventName": "PreCompact",
-    "additionalContext": "... instructions for AI ..."
+    "additionalContext": "... status message ..."
   }
 }
 """
@@ -9829,8 +9914,149 @@ Output (to stdout):
 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
+    }
+
+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,
+    }
+
+    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",
+    }
+
+    # 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:
@@ -9841,26 +10067,38 @@ def main():
     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", "")
 
-    # Build context injection for the AI
-    context = f"""[CONTEXT COMPACTION IMMINENT - {trigger.upper()}]
-CRITICAL: Before context is compacted, you MUST save conversation state:
+    # Parse transcript for context
+    transcript_data = {}
+    if transcript_path and os.path.exists(transcript_path):
+        transcript_data = parse_transcript(transcript_path)
 
-1. IMMEDIATELY call: mcp__contextstream__session(action="capture", event_type="session_snapshot", title="Pre-compaction snapshot", content="<JSON with: conversation_summary, active_goals, recent_decisions, active_files, unfinished_work>")
+    # 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}]"
 
-2. Include in the snapshot:
-   - conversation_summary: Brief summary of what was discussed
-   - active_goals: List of goals/tasks in progress
-   - recent_decisions: Key decisions made in this session
-   - active_files: Files currently being worked on
-   - unfinished_work: Any incomplete tasks
+    # 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}
 
-3. After compaction, call session_init(is_post_compact=true) to restore context.
+Active files detected: {files_list}
+Tool calls in session: {transcript_data.get('tool_call_count', 0)}
 
-{f"User instructions: {custom_instructions}" if custom_instructions else ""}
-[END COMPACTION WARNING]"""
+After compaction, call session_init(is_post_compact=true) to restore context.
+{f"User instructions: {custom_instructions}" if custom_instructions else ""}"""
 
     output = {
         "hookSpecificOutput": {
@@ -9956,98 +10194,778 @@ async function installHookScripts(options) {
 async function readClaudeSettings(scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
   try {
-    const content = await fs4.readFile(settingsPath, "utf-8");
+    const content = await fs4.readFile(settingsPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeClaudeSettings(settings, scope, projectPath) {
+  const settingsPath = getClaudeSettingsPath(scope, projectPath);
+  const dir = path5.dirname(settingsPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.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];
+  }
+  settings.hooks = existingHooks;
+  return settings;
+}
+function getIndexStatusPath() {
+  return path5.join(homedir2(), ".contextstream", "indexed-projects.json");
+}
+async function readIndexStatus() {
+  const statusPath = getIndexStatusPath();
+  try {
+    const content = await fs4.readFile(statusPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, projects: {} };
+  }
+}
+async function writeIndexStatus(status) {
+  const statusPath = getIndexStatusPath();
+  const dir = path5.dirname(statusPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(statusPath, JSON.stringify(status, null, 2));
+}
+async function markProjectIndexed(projectPath, options) {
+  const status = await readIndexStatus();
+  const resolvedPath = path5.resolve(projectPath);
+  status.projects[resolvedPath] = {
+    indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    project_id: options?.project_id,
+    project_name: options?.project_name
+  };
+  await writeIndexStatus(status);
+}
+var 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()
+`;
+var 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()
+`;
+function getClineHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), "Documents", "Cline", "Rules", "Hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".clinerules", "hooks");
+}
+async function installClineHookScripts(options) {
+  const hooksDir = getClineHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  await fs4.writeFile(preToolUsePath, CLINE_PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
+  return {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+}
+function getRooCodeHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), ".roo", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".roo", "hooks");
+}
+async function installRooCodeHookScripts(options) {
+  const hooksDir = getRooCodeHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  await fs4.writeFile(preToolUsePath, CLINE_PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
+  return {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+}
+function getKiloCodeHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), ".kilocode", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".kilocode", "hooks");
+}
+async function installKiloCodeHookScripts(options) {
+  const hooksDir = getKiloCodeHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  await fs4.writeFile(preToolUsePath, CLINE_PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
+  return {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+}
+var 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()
+`;
+var 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()
+`;
+function getCursorHooksConfigPath(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), ".cursor", "hooks.json");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".cursor", "hooks.json");
+}
+function getCursorHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), ".cursor", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".cursor", "hooks");
+}
+async function readCursorHooksConfig(scope, projectPath) {
+  const configPath = getCursorHooksConfigPath(scope, projectPath);
+  try {
+    const content = await fs4.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, hooks: {} };
+  }
+}
+async function writeCursorHooksConfig(config, scope, projectPath) {
+  const configPath = getCursorHooksConfigPath(scope, projectPath);
+  const dir = path5.dirname(configPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function installCursorHookScripts(options) {
+  const hooksDir = getCursorHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "contextstream-pretooluse.py");
+  const beforeSubmitPath = path5.join(hooksDir, "contextstream-beforesubmit.py");
+  await fs4.writeFile(preToolUsePath, CURSOR_PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(beforeSubmitPath, CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT, { mode: 493 });
+  const existingConfig = await readCursorHooksConfig(options.scope, options.projectPath);
+  const filterContextStreamHooks = (hooks) => {
+    if (!hooks) return [];
+    return hooks.filter((h) => !h.command?.includes("contextstream"));
+  };
+  const config = {
+    version: 1,
+    hooks: {
+      ...existingConfig.hooks,
+      preToolUse: [
+        ...filterContextStreamHooks(existingConfig.hooks.preToolUse),
+        {
+          command: `python3 "${preToolUsePath}"`,
+          type: "command",
+          timeout: 5,
+          matcher: { tool_name: "Glob|Grep|search_files|list_files|ripgrep" }
+        }
+      ],
+      beforeSubmitPrompt: [
+        ...filterContextStreamHooks(existingConfig.hooks.beforeSubmitPrompt),
+        {
+          command: `python3 "${beforeSubmitPath}"`,
+          type: "command",
+          timeout: 5
+        }
+      ]
+    }
+  };
+  await writeCursorHooksConfig(config, options.scope, options.projectPath);
+  const configPath = getCursorHooksConfigPath(options.scope, options.projectPath);
+  return {
+    preToolUse: preToolUsePath,
+    beforeSubmitPrompt: beforeSubmitPath,
+    config: configPath
+  };
+}
+var WINDSURF_PRE_MCP_TOOL_USE_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream pre_mcp_tool_use Hook for Windsurf
+Blocks discovery tools and redirects to ContextStream search.
+
+Exit codes:
+- 0: Allow action to proceed
+- 2: Block action (message to stderr)
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+
+# Tools to redirect
+DISCOVERY_TOOLS = {
+    "read_file": "Use mcp__contextstream__search(mode=\\"hybrid\\") for discovery",
+    "search_files": "Use mcp__contextstream__search(mode=\\"hybrid\\")",
+    "list_files": "Use mcp__contextstream__search(mode=\\"pattern\\")",
+    "codebase_search": "Use mcp__contextstream__search(mode=\\"hybrid\\")",
+    "grep_search": "Use mcp__contextstream__search(mode=\\"keyword\\")",
+}
+
+def is_project_indexed(workspace_roots):
+    """Check if any workspace has a .contextstream/index marker."""
+    for root in workspace_roots:
+        marker = os.path.join(root, ".contextstream", "index.json")
+        if os.path.exists(marker):
+            return True, root
+    return False, None
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    tool_info = data.get("tool_info", {})
+    tool_name = tool_info.get("tool_name", "")
+
+    # For MCP tools, check the server and tool
+    mcp_server = tool_info.get("mcp_server", "")
+
+    # Get workspace roots from the data
+    workspace_roots = []
+    if "working_directory" in data:
+        workspace_roots.append(data["working_directory"])
+
+    # Check if project is indexed
+    is_indexed, _ = is_project_indexed(workspace_roots)
+    if not is_indexed:
+        sys.exit(0)
+
+    # Check if this is a discovery tool we should redirect
+    if tool_name in DISCOVERY_TOOLS:
+        message = DISCOVERY_TOOLS[tool_name]
+        print(message, file=sys.stderr)
+        sys.exit(2)
+
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+var WINDSURF_PRE_USER_PROMPT_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream pre_user_prompt Hook for Windsurf
+Injects reminder about ContextStream rules.
+
+Note: This hook runs before prompt processing but cannot modify the prompt.
+It primarily serves for logging and validation purposes.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    # Allow the prompt to proceed
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+function getWindsurfHooksConfigPath(scope, projectPath) {
+  if (scope === "project" && projectPath) {
+    return path5.join(projectPath, ".windsurf", "hooks.json");
+  }
+  return path5.join(homedir2(), ".codeium", "windsurf", "hooks.json");
+}
+function getWindsurfHooksDir(scope, projectPath) {
+  if (scope === "project" && projectPath) {
+    return path5.join(projectPath, ".windsurf", "hooks");
+  }
+  return path5.join(homedir2(), ".codeium", "windsurf", "hooks");
+}
+async function readWindsurfHooksConfig(scope, projectPath) {
+  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
+  try {
+    const content = await fs4.promises.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
-    return {};
+    return { hooks: {} };
   }
 }
-async function writeClaudeSettings(settings, scope, projectPath) {
-  const settingsPath = getClaudeSettingsPath(scope, projectPath);
-  const dir = path5.dirname(settingsPath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+async function writeWindsurfHooksConfig(config, scope, projectPath) {
+  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
+  const configDir = path5.dirname(configPath);
+  await fs4.promises.mkdir(configDir, { recursive: true });
+  await fs4.promises.writeFile(configPath, JSON.stringify(config, 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];
-  }
-  settings.hooks = existingHooks;
-  return settings;
+function filterWindsurfContextStreamHooks(hooks) {
+  if (!hooks) return [];
+  return hooks.filter((h) => !h.command?.includes("contextstream"));
 }
-async function installClaudeCodeHooks(options) {
-  const result = { scripts: [], settings: [] };
-  if (!options.dryRun) {
-    const scripts = await installHookScripts({ includePreCompact: options.includePreCompact });
-    result.scripts.push(scripts.preToolUse, scripts.userPrompt);
-    if (scripts.preCompact) {
-      result.scripts.push(scripts.preCompact);
-    }
-  } else {
-    const hooksDir = getHooksDir();
-    result.scripts.push(
-      path5.join(hooksDir, "contextstream-redirect.py"),
-      path5.join(hooksDir, "contextstream-reminder.py")
-    );
-    if (options.includePreCompact) {
-      result.scripts.push(path5.join(hooksDir, "contextstream-precompact.py"));
+async function installWindsurfHookScripts(options) {
+  const scope = options.scope || "global";
+  const hooksDir = getWindsurfHooksDir(scope, options.projectPath);
+  await fs4.promises.mkdir(hooksDir, { recursive: true });
+  const preMcpToolUsePath = path5.join(hooksDir, "contextstream-pretooluse.py");
+  const preUserPromptPath = path5.join(hooksDir, "contextstream-reminder.py");
+  await fs4.promises.writeFile(preMcpToolUsePath, WINDSURF_PRE_MCP_TOOL_USE_SCRIPT);
+  await fs4.promises.writeFile(preUserPromptPath, WINDSURF_PRE_USER_PROMPT_SCRIPT);
+  if (process.platform !== "win32") {
+    await fs4.promises.chmod(preMcpToolUsePath, 493);
+    await fs4.promises.chmod(preUserPromptPath, 493);
+  }
+  const existingConfig = await readWindsurfHooksConfig(scope, options.projectPath);
+  const config = {
+    hooks: {
+      ...existingConfig.hooks,
+      pre_mcp_tool_use: [
+        ...filterWindsurfContextStreamHooks(existingConfig.hooks.pre_mcp_tool_use),
+        {
+          command: `python3 "${preMcpToolUsePath}"`,
+          show_output: true
+        }
+      ],
+      pre_user_prompt: [
+        ...filterWindsurfContextStreamHooks(existingConfig.hooks.pre_user_prompt),
+        {
+          command: `python3 "${preUserPromptPath}"`,
+          show_output: false
+        }
+      ]
     }
-  }
-  const hooksConfig = buildHooksConfig({ includePreCompact: options.includePreCompact });
-  if (options.scope === "user" || options.scope === "both") {
-    const settingsPath = getClaudeSettingsPath("user");
-    if (!options.dryRun) {
-      const existing = await readClaudeSettings("user");
+  };
+  await writeWindsurfHooksConfig(config, scope, options.projectPath);
+  const configPath = getWindsurfHooksConfigPath(scope, options.projectPath);
+  return {
+    preMcpToolUse: preMcpToolUsePath,
+    preUserPrompt: preUserPromptPath,
+    config: configPath
+  };
+}
+async function installEditorHooks(options) {
+  const { editor, scope, projectPath, includePreCompact } = 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 });
+      const settingsScope = scope === "global" ? "user" : "project";
+      const existing = await readClaudeSettings(settingsScope, projectPath);
       const merged = mergeHooksIntoSettings(existing, hooksConfig);
-      await writeClaudeSettings(merged, "user");
+      await writeClaudeSettings(merged, settingsScope, projectPath);
+      const installed = [scripts.preToolUse, scripts.userPrompt];
+      if (scripts.preCompact) installed.push(scripts.preCompact);
+      return {
+        editor: "claude",
+        installed,
+        hooksDir: getHooksDir()
+      };
     }
-    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);
+    case "cline": {
+      const scripts = await installClineHookScripts({ scope, projectPath });
+      return {
+        editor: "cline",
+        installed: [scripts.preToolUse, scripts.userPromptSubmit],
+        hooksDir: getClineHooksDir(scope, projectPath)
+      };
+    }
+    case "roo": {
+      const scripts = await installRooCodeHookScripts({ scope, projectPath });
+      return {
+        editor: "roo",
+        installed: [scripts.preToolUse, scripts.userPromptSubmit],
+        hooksDir: getRooCodeHooksDir(scope, projectPath)
+      };
+    }
+    case "kilo": {
+      const scripts = await installKiloCodeHookScripts({ scope, projectPath });
+      return {
+        editor: "kilo",
+        installed: [scripts.preToolUse, scripts.userPromptSubmit],
+        hooksDir: getKiloCodeHooksDir(scope, projectPath)
+      };
+    }
+    case "cursor": {
+      const scripts = await installCursorHookScripts();
+      return {
+        editor: "cursor",
+        installed: [scripts.preToolUse, scripts.beforeSubmit],
+        hooksDir: getCursorHooksDir()
+      };
     }
-    result.settings.push(settingsPath);
+    case "windsurf": {
+      const scripts = await installWindsurfHookScripts({ scope, projectPath });
+      return {
+        editor: "windsurf",
+        installed: [scripts.preMcpToolUse, scripts.preUserPrompt],
+        hooksDir: getWindsurfHooksDir(scope, projectPath)
+      };
+    }
+    default:
+      throw new Error(`Unsupported editor: ${editor}`);
   }
-  return result;
-}
-function getIndexStatusPath() {
-  return path5.join(homedir2(), ".contextstream", "indexed-projects.json");
 }
-async function readIndexStatus() {
-  const statusPath = getIndexStatusPath();
-  try {
-    const content = await fs4.readFile(statusPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return { version: 1, projects: {} };
+async function installAllEditorHooks(options) {
+  const editors = options.editors || ["claude", "cline", "roo", "kilo", "cursor", "windsurf"];
+  const results = [];
+  for (const editor of editors) {
+    try {
+      const result = await installEditorHooks({
+        editor,
+        scope: options.scope,
+        projectPath: options.projectPath,
+        includePreCompact: options.includePreCompact
+      });
+      results.push(result);
+    } catch (error) {
+      console.error(`Failed to install hooks for ${editor}:`, error);
+    }
   }
-}
-async function writeIndexStatus(status) {
-  const statusPath = getIndexStatusPath();
-  const dir = path5.dirname(statusPath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.writeFile(statusPath, JSON.stringify(status, null, 2));
-}
-async function markProjectIndexed(projectPath, options) {
-  const status = await readIndexStatus();
-  const resolvedPath = path5.resolve(projectPath);
-  status.projects[resolvedPath] = {
-    indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
-    project_id: options?.project_id,
-    project_name: options?.project_name
-  };
-  await writeIndexStatus(status);
+  return results;
 }
 
 // src/token-savings.ts
@@ -10124,9 +11042,75 @@ BEFORE using EnterPlanMode/Task(Plan) \u2192 call mcp__contextstream__session(ac
 Local tools ONLY if ContextStream returns 0 results after retry.
 `.trim();
 var LESSONS_REMINDER_PREFIX = `
-\u26A0\uFE0F [LESSONS - REVIEW BEFORE CHANGES]
-Past mistakes found that may be relevant. STOP and review before proceeding:
+\u{1F6A8} [LESSONS_WARNING] Past Mistakes Found - READ BEFORE PROCEEDING!
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u26A0\uFE0F IMPORTANT: You MUST review these lessons and tell the user about relevant ones.
+These are mistakes from past sessions that you should NOT repeat.
 `.trim();
+var RISKY_ACTION_KEYWORDS = [
+  // Code changes
+  "refactor",
+  "rewrite",
+  "restructure",
+  "reorganize",
+  "migrate",
+  "delete",
+  "remove",
+  "drop",
+  "deprecate",
+  // Database
+  "database",
+  "migration",
+  "schema",
+  "sql",
+  // Deployment
+  "deploy",
+  "release",
+  "production",
+  "prod",
+  // API changes
+  "api",
+  "endpoint",
+  "breaking change",
+  // Architecture
+  "architecture",
+  "design",
+  "pattern",
+  // Testing
+  "test",
+  "testing",
+  // Security
+  "auth",
+  "security",
+  "permission",
+  "credential",
+  "access",
+  "token",
+  "secret",
+  // Version control
+  "git",
+  "commit",
+  "merge",
+  "rebase",
+  "push",
+  "force",
+  // Infrastructure
+  "config",
+  "environment",
+  "env",
+  "docker",
+  "kubernetes",
+  "k8s",
+  // Performance
+  "performance",
+  "optimize",
+  "cache",
+  "memory"
+];
+function detectRiskyActions(userMessage) {
+  const messageLower = userMessage.toLowerCase();
+  return RISKY_ACTION_KEYWORDS.filter((keyword) => messageLower.includes(keyword));
+}
 function generateLessonsReminder(result) {
   const lessons = result.lessons;
   if (!lessons || lessons.length === 0) {
@@ -10141,7 +11125,8 @@ function generateLessonsReminder(result) {
   return `
 
 ${LESSONS_REMINDER_PREFIX}
-${lessonLines.join("\n")}`;
+${lessonLines.join("\n")}
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`;
 }
 function generateRulesUpdateWarning(rulesNotice) {
   if (!rulesNotice || rulesNotice.status !== "behind" && rulesNotice.status !== "missing") {
@@ -10164,12 +11149,16 @@ function generateVersionUpdateWarning(versionNotice) {
     return "";
   }
   return `
-\u{1F6A8} [MCP SERVER OUTDATED - UPDATE RECOMMENDED]
-Current: ${versionNotice.current} \u2192 Latest: ${versionNotice.latest}
-New version may include critical bug fixes, performance improvements, and new features.
+\u{1F6A8} [VERSION_NOTICE] MCP Server Update Available!
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+Version: ${versionNotice.current} \u2192 ${versionNotice.latest}
 
-**UPDATE NOW:** Run \`${versionNotice.upgrade_command || "npm update @contextstream/mcp-server"}\`
-Then restart Claude Code to use the new version.
+\u26A0\uFE0F IMPORTANT: You MUST tell the user about this update IMMEDIATELY.
+Do not proceed with other work until you have informed the user.
+
+Update command: \`${versionNotice.upgrade_command || "npm update -g @contextstream/mcp-server"}\`
+After updating, restart the AI tool to use the new version.
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 `.trim();
 }
 var DEFAULT_PARAM_DESCRIPTIONS = {
@@ -11030,6 +12019,7 @@ var ALL_INTEGRATION_TOOLS = /* @__PURE__ */ new Set([
   ...CROSS_INTEGRATION_TOOLS
 ]);
 var AUTO_HIDE_INTEGRATIONS = process.env.CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS !== "false";
+var RESTORE_CONTEXT_DEFAULT = process.env.CONTEXTSTREAM_RESTORE_CONTEXT !== "false";
 var TOKEN_SENSITIVE_CLIENTS = /* @__PURE__ */ new Set([
   "claude",
   "claude-code",
@@ -13824,7 +14814,7 @@ This does semantic search on the first message. You only need context_smart on s
           "If true, skip automatic project creation/matching. Use for parent folders containing multiple projects where you want workspace-level context but no project-specific context."
         ),
         is_post_compact: external_exports.boolean().optional().describe(
-          "Set to true when resuming after conversation compaction. This prioritizes session_snapshot restoration and recent decisions."
+          "Controls context restoration from recent snapshots. Defaults to true (always restores). Set to false to skip restoration. Can also be controlled via CONTEXTSTREAM_RESTORE_CONTEXT environment variable."
         )
       })
     },
@@ -13845,19 +14835,22 @@ This does semantic search on the first message. You only need context_smart on s
       }
       const result = await client.initSession(input, ideRoots);
       result.tools_hint = getCoreToolsHint();
-      if (input.is_post_compact) {
+      const shouldRestoreContext = input.is_post_compact ?? RESTORE_CONTEXT_DEFAULT;
+      if (shouldRestoreContext) {
+        result.is_post_compact = true;
         const workspaceIdForRestore = typeof result.workspace_id === "string" ? result.workspace_id : void 0;
         const projectIdForRestore = typeof result.project_id === "string" ? result.project_id : void 0;
         if (workspaceIdForRestore) {
           try {
-            const snapshotSearch = await client.searchEvents({
+            const listResult = await client.listMemoryEvents({
               workspace_id: workspaceIdForRestore,
               project_id: projectIdForRestore,
-              query: "session_snapshot",
-              event_types: ["session_snapshot"],
-              limit: 1
+              limit: 50
             });
-            const snapshots = snapshotSearch?.data?.results || snapshotSearch?.results || snapshotSearch?.data || [];
+            const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
+            const snapshots = allEvents.filter(
+              (e) => e.event_type === "session_snapshot" || e.metadata?.original_type === "session_snapshot" || e.metadata?.tags?.includes("session_snapshot") || e.tags?.includes("session_snapshot")
+            );
             if (snapshots && snapshots.length > 0) {
               const latestSnapshot = snapshots[0];
               let snapshotData;
@@ -13866,13 +14859,52 @@ This does semantic search on the first message. You only need context_smart on s
               } catch {
                 snapshotData = { conversation_summary: latestSnapshot.content };
               }
+              const prevSessionId = snapshotData.session_id || latestSnapshot.session_id;
+              const sessionLinking = {};
+              if (prevSessionId) {
+                sessionLinking.previous_session_id = prevSessionId;
+                const workingOn = [];
+                const activeFiles = snapshotData.active_files;
+                const lastTools = snapshotData.last_tools;
+                if (activeFiles && activeFiles.length > 0) {
+                  workingOn.push(`Files: ${activeFiles.slice(0, 5).join(", ")}${activeFiles.length > 5 ? ` (+${activeFiles.length - 5} more)` : ""}`);
+                }
+                if (lastTools && lastTools.length > 0) {
+                  const toolCounts = lastTools.reduce((acc, tool) => {
+                    acc[tool] = (acc[tool] || 0) + 1;
+                    return acc;
+                  }, {});
+                  const topTools = Object.entries(toolCounts).sort(([, a], [, b]) => b - a).slice(0, 3).map(([tool]) => tool);
+                  workingOn.push(`Recent tools: ${topTools.join(", ")}`);
+                }
+                if (workingOn.length > 0) {
+                  sessionLinking.previous_session_summary = workingOn.join("; ");
+                }
+                const relatedSessionIds = /* @__PURE__ */ new Set();
+                snapshots.forEach((s) => {
+                  let sData;
+                  try {
+                    sData = JSON.parse(s.content || "{}");
+                  } catch {
+                    sData = {};
+                  }
+                  const sSessionId = sData.session_id || s.session_id;
+                  if (sSessionId && sSessionId !== prevSessionId) {
+                    relatedSessionIds.add(sSessionId);
+                  }
+                });
+                if (relatedSessionIds.size > 0) {
+                  sessionLinking.related_sessions = Array.from(relatedSessionIds);
+                }
+              }
               result.restored_context = {
                 snapshot_id: latestSnapshot.id,
                 captured_at: snapshotData.captured_at || latestSnapshot.created_at,
+                session_linking: Object.keys(sessionLinking).length > 0 ? sessionLinking : void 0,
                 ...snapshotData
               };
               result.is_post_compact = true;
-              result.post_compact_hint = "Session restored from pre-compaction snapshot. Review the 'restored_context' to continue where you left off.";
+              result.post_compact_hint = prevSessionId ? `Session restored from session ${prevSessionId}. Review 'restored_context' to continue where you left off.` : "Session restored from pre-compaction snapshot. Review the 'restored_context' to continue where you left off.";
             } else {
               result.is_post_compact = true;
               result.post_compact_hint = "Post-compaction session started, but no snapshots found. Use context_smart to retrieve relevant context.";
@@ -15022,34 +16054,77 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
       const globalPrompt = input.apply_global ? "Global rule update complete." : globalTargets.length > 0 ? "Apply rules globally too? Re-run with apply_global: true." : "No global rule locations are known for these editors.";
       let hooksResults;
       let hooksPrompt;
-      const hasClaude = editors.includes("claude");
-      const shouldInstallHooks = hasClaude && input.install_hooks !== false;
+      const editorHookMap = {
+        claude: "claude",
+        cline: "cline",
+        roo: "roo",
+        kilo: "kilo",
+        cursor: "cursor",
+        windsurf: "windsurf"
+      };
+      const hookSupportedEditors = editors.filter((e) => e in editorHookMap);
+      const shouldInstallHooks = hookSupportedEditors.length > 0 && input.install_hooks !== false;
       if (shouldInstallHooks) {
         try {
           if (input.dry_run) {
-            hooksResults = [
-              { file: "~/.claude/hooks/contextstream-redirect.py", status: "dry run - would create" },
-              { file: "~/.claude/hooks/contextstream-reminder.py", status: "dry run - would create" },
-              { file: "~/.claude/settings.json", status: "dry run - would update" }
-            ];
-            if (input.include_pre_compact) {
-              hooksResults.push({ file: "~/.claude/hooks/contextstream-precompact.py", status: "dry run - would create" });
+            hooksResults = [];
+            for (const editor of hookSupportedEditors) {
+              if (editor === "claude") {
+                hooksResults.push(
+                  { editor, file: "~/.claude/hooks/contextstream-redirect.py", status: "dry run - would create" },
+                  { editor, file: "~/.claude/hooks/contextstream-reminder.py", status: "dry run - would create" },
+                  { editor, file: "~/.claude/settings.json", status: "dry run - would update" }
+                );
+                if (input.include_pre_compact) {
+                  hooksResults.push({ editor, file: "~/.claude/hooks/contextstream-precompact.py", status: "dry run - would create" });
+                }
+              } else if (editor === "cline") {
+                hooksResults.push(
+                  { editor, file: "~/Documents/Cline/Rules/Hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/Documents/Cline/Rules/Hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "roo") {
+                hooksResults.push(
+                  { editor, file: "~/.roo/hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/.roo/hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "kilo") {
+                hooksResults.push(
+                  { editor, file: "~/.kilocode/hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/.kilocode/hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "cursor") {
+                hooksResults.push(
+                  { editor, file: "~/.cursor/hooks/contextstream-pretooluse.py", status: "dry run - would create" },
+                  { editor, file: "~/.cursor/hooks/contextstream-beforesubmit.py", status: "dry run - would create" },
+                  { editor, file: "~/.cursor/hooks.json", status: "dry run - would update" }
+                );
+              } else if (editor === "windsurf") {
+                hooksResults.push(
+                  { editor, file: "~/.codeium/windsurf/hooks/contextstream-pretooluse.py", status: "dry run - would create" },
+                  { editor, file: "~/.codeium/windsurf/hooks/contextstream-reminder.py", status: "dry run - would create" },
+                  { editor, file: "~/.codeium/windsurf/hooks.json", status: "dry run - would update" }
+                );
+              }
             }
           } else {
-            const hookResult = await installClaudeCodeHooks({
-              scope: "user",
+            hooksResults = [];
+            const allHookResults = await installAllEditorHooks({
+              scope: "global",
+              editors: hookSupportedEditors,
               includePreCompact: input.include_pre_compact
             });
-            hooksResults = [
-              ...hookResult.scripts.map((f) => ({ file: f, status: "created" })),
-              ...hookResult.settings.map((f) => ({ file: f, status: "updated" }))
-            ];
+            for (const result of allHookResults) {
+              for (const file of result.installed) {
+                hooksResults.push({ editor: result.editor, file, status: "created" });
+              }
+            }
           }
         } catch (err) {
           hooksResults = [{ file: "hooks", status: `error: ${err.message}` }];
         }
-      } else if (hasClaude && input.install_hooks === false) {
-        hooksPrompt = "Hooks skipped. Claude may use default tools instead of ContextStream search.";
+      } else if (hookSupportedEditors.length > 0 && input.install_hooks === false) {
+        hooksPrompt = "Hooks skipped. AI may use default tools instead of ContextStream search.";
       }
       const summary = {
         folder: folderPath,
@@ -15428,6 +16503,52 @@ This saves ~80% tokens compared to including full chat history.`,
         }
         sessionManager.addTokens(input.user_message);
       }
+      let postCompactContext = "";
+      let postCompactRestored = false;
+      if (sessionManager && sessionManager.shouldRestorePostCompact() && workspaceId) {
+        try {
+          const listResult = await client.listMemoryEvents({
+            workspace_id: workspaceId,
+            project_id: projectId,
+            limit: 20
+          });
+          const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
+          const snapshotEvent = allEvents.find(
+            (e) => e.event_type === "session_snapshot" || e.metadata?.original_type === "session_snapshot" || e.tags?.includes("session_snapshot")
+          );
+          if (snapshotEvent && snapshotEvent.content) {
+            let snapshotData;
+            try {
+              snapshotData = JSON.parse(snapshotEvent.content);
+            } catch {
+              snapshotData = { conversation_summary: snapshotEvent.content };
+            }
+            const summary = snapshotData.conversation_summary || snapshotData.summary || "";
+            const decisions = snapshotData.key_decisions || [];
+            const unfinished = snapshotData.unfinished_work || snapshotData.pending_tasks || [];
+            const files = snapshotData.active_files || [];
+            const parts = [];
+            parts.push("\u{1F4CB} [POST-COMPACTION CONTEXT RESTORED]");
+            if (summary) parts.push(`Summary: ${summary}`);
+            if (Array.isArray(decisions) && decisions.length > 0) {
+              parts.push(`Decisions: ${decisions.slice(0, 5).join("; ")}`);
+            }
+            if (Array.isArray(unfinished) && unfinished.length > 0) {
+              parts.push(`Unfinished: ${unfinished.slice(0, 3).join("; ")}`);
+            }
+            if (Array.isArray(files) && files.length > 0) {
+              parts.push(`Active files: ${files.slice(0, 5).join(", ")}`);
+            }
+            parts.push("---");
+            postCompactContext = parts.join("\n") + "\n\n";
+            postCompactRestored = true;
+            sessionManager.markPostCompactRestoreCompleted();
+            console.error("[ContextStream] Post-compaction context restored automatically");
+          }
+        } catch (err) {
+          console.error("[ContextStream] Failed to restore post-compact context:", err);
+        }
+      }
       const result = await client.getSmartContext({
         user_message: input.user_message,
         workspace_id: workspaceId,
@@ -15468,8 +16589,44 @@ This saves ~80% tokens compared to including full chat history.`,
         project_id: projectId,
         max_tokens: input.max_tokens
       });
-      const hasLessons = result.context.includes("|L:") || result.context.includes("L:") || result.context.toLowerCase().includes("lesson");
-      const lessonsWarningLine = hasLessons ? "\n\n\u26A0\uFE0F [LESSONS DETECTED] Review the L: items above - these are past mistakes. STOP and review before making similar changes." : "";
+      let lessonsWarningLine = "";
+      const riskyKeywords = detectRiskyActions(input.user_message);
+      if (riskyKeywords.length > 0 && workspaceId) {
+        try {
+          const lessons = await client.getHighPriorityLessons({
+            workspace_id: workspaceId,
+            project_id: projectId,
+            context_hint: riskyKeywords.join(" "),
+            limit: 5
+          });
+          if (lessons.length > 0) {
+            const lessonLines = lessons.slice(0, 5).map((l, i) => {
+              const severity = l.severity === "critical" ? "\u{1F6A8}" : l.severity === "high" ? "\u26A0\uFE0F" : "\u{1F4DD}";
+              const title = l.title || "Untitled lesson";
+              const prevention = l.prevention || "";
+              return `${i + 1}. ${severity} ${title}${prevention ? `: ${prevention.slice(0, 100)}` : ""}`;
+            });
+            lessonsWarningLine = `
+
+\u{1F6A8} [LESSONS_WARNING] Relevant Lessons for "${riskyKeywords.slice(0, 3).join(", ")}"
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u26A0\uFE0F IMPORTANT: You MUST tell the user about these lessons before proceeding.
+These are past mistakes that may be relevant to the current task.
+
+${lessonLines.join("\n")}
+
+Action: Review each lesson and explain to the user how you will avoid these mistakes.
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`;
+          }
+        } catch {
+        }
+      }
+      if (!lessonsWarningLine) {
+        const hasLessonsInContext = result.context.includes("|L:") || result.context.includes("L:") || result.context.toLowerCase().includes("lesson");
+        if (hasLessonsInContext) {
+          lessonsWarningLine = "\n\n\u26A0\uFE0F [LESSONS_WARNING] Lessons found in context - review the L: items above before making changes.";
+        }
+      }
       const searchRulesLine = SEARCH_RULES_REMINDER_ENABLED ? `
 
 ${SEARCH_RULES_REMINDER}` : "";
@@ -15477,12 +16634,18 @@ ${SEARCH_RULES_REMINDER}` : "";
       if (result.context_pressure) {
         const cp = result.context_pressure;
         if (cp.level === "critical") {
+          if (sessionManager) {
+            sessionManager.markHighContextPressure();
+          }
           contextPressureWarning = `
 
 \u{1F6A8} [CONTEXT PRESSURE: CRITICAL] ${cp.usage_percent}% of context used (${cp.session_tokens}/${cp.threshold} tokens)
 Action: ${cp.suggested_action === "save_now" ? 'SAVE STATE NOW - Call session(action="capture") to preserve conversation state before compaction.' : cp.suggested_action}
 The conversation may compact soon. Save important decisions, insights, and progress immediately.`;
         } else if (cp.level === "high") {
+          if (sessionManager) {
+            sessionManager.markHighContextPressure();
+          }
           contextPressureWarning = `
 
 \u26A0\uFE0F [CONTEXT PRESSURE: HIGH] ${cp.usage_percent}% of context used (${cp.session_tokens}/${cp.threshold} tokens)
@@ -15500,14 +16663,16 @@ ${versionWarningLine}` : "",
         contextPressureWarning,
         searchRulesLine
       ].filter(Boolean).join("");
+      const finalContext = postCompactContext + result.context;
+      const enrichedResultWithRestore = postCompactRestored ? { ...enrichedResult, post_compact_restored: true } : enrichedResult;
       return {
         content: [
           {
             type: "text",
-            text: result.context + footer + allWarnings
+            text: finalContext + footer + allWarnings
           }
         ],
-        structuredContent: toStructured(enrichedResult)
+        structuredContent: toStructured(enrichedResultWithRestore)
       };
     }
   );
@@ -16998,12 +18163,35 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               } catch {
                 snapshotData = { conversation_summary: event.content };
               }
+              const sessionId = snapshotData.session_id || event.session_id;
+              const sessionLinking2 = {};
+              if (sessionId) {
+                sessionLinking2.previous_session_id = sessionId;
+                const workingOn = [];
+                const activeFiles = snapshotData.active_files;
+                const lastTools = snapshotData.last_tools;
+                if (activeFiles && activeFiles.length > 0) {
+                  workingOn.push(`Files: ${activeFiles.slice(0, 5).join(", ")}${activeFiles.length > 5 ? ` (+${activeFiles.length - 5} more)` : ""}`);
+                }
+                if (lastTools && lastTools.length > 0) {
+                  const toolCounts = lastTools.reduce((acc, tool) => {
+                    acc[tool] = (acc[tool] || 0) + 1;
+                    return acc;
+                  }, {});
+                  const topTools = Object.entries(toolCounts).sort(([, a], [, b]) => b - a).slice(0, 3).map(([tool]) => tool);
+                  workingOn.push(`Recent tools: ${topTools.join(", ")}`);
+                }
+                if (workingOn.length > 0) {
+                  sessionLinking2.previous_session_summary = workingOn.join("; ");
+                }
+              }
               const response2 = {
                 restored: true,
                 snapshot_id: event.id,
                 captured_at: snapshotData.captured_at || event.created_at,
+                session_linking: Object.keys(sessionLinking2).length > 0 ? sessionLinking2 : void 0,
                 ...snapshotData,
-                hint: "Context restored. Continue the conversation with awareness of the above state."
+                hint: sessionId ? `Context restored from session ${sessionId}. Continue the conversation with awareness of the above state.` : "Context restored. Continue the conversation with awareness of the above state."
               };
               return {
                 content: [{ type: "text", text: formatContent(response2) }],
@@ -17044,15 +18232,48 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               return {
                 snapshot_id: event.id,
                 captured_at: snapshotData.captured_at || event.created_at,
+                session_id: snapshotData.session_id || event.session_id,
                 ...snapshotData
               };
             });
+            const latestSnapshot = snapshots[0];
+            const sessionLinking = {};
+            if (latestSnapshot?.session_id) {
+              sessionLinking.previous_session_id = latestSnapshot.session_id;
+              const workingOn = [];
+              const activeFiles = latestSnapshot.active_files;
+              const lastTools = latestSnapshot.last_tools;
+              if (activeFiles && activeFiles.length > 0) {
+                workingOn.push(`Files: ${activeFiles.slice(0, 5).join(", ")}${activeFiles.length > 5 ? ` (+${activeFiles.length - 5} more)` : ""}`);
+              }
+              if (lastTools && lastTools.length > 0) {
+                const toolCounts = lastTools.reduce((acc, tool) => {
+                  acc[tool] = (acc[tool] || 0) + 1;
+                  return acc;
+                }, {});
+                const topTools = Object.entries(toolCounts).sort(([, a], [, b]) => b - a).slice(0, 3).map(([tool]) => tool);
+                workingOn.push(`Recent tools: ${topTools.join(", ")}`);
+              }
+              if (workingOn.length > 0) {
+                sessionLinking.previous_session_summary = workingOn.join("; ");
+              }
+              const relatedSessionIds = /* @__PURE__ */ new Set();
+              snapshots.forEach((s) => {
+                if (s.session_id && s.session_id !== latestSnapshot.session_id) {
+                  relatedSessionIds.add(s.session_id);
+                }
+              });
+              if (relatedSessionIds.size > 0) {
+                sessionLinking.related_sessions = Array.from(relatedSessionIds);
+              }
+            }
             const response = {
               restored: true,
               snapshots_found: snapshots.length,
               latest: snapshots[0],
               all_snapshots: snapshots.length > 1 ? snapshots : void 0,
-              hint: "Context restored. Continue the conversation with awareness of the above state."
+              session_linking: Object.keys(sessionLinking).length > 0 ? sessionLinking : void 0,
+              hint: sessionLinking.previous_session_id ? `Context restored from session ${sessionLinking.previous_session_id}. Continue the conversation with awareness of the above state.` : "Context restored. Continue the conversation with awareness of the above state."
             };
             return {
               content: [{ type: "text", text: formatContent(response) }],
@@ -19623,8 +20844,7 @@ function registerPrompts(server) {
 }
 
 // src/session-manager.ts
-var SessionManager = class {
-  // Conservative default for 100k context window
+var SessionManager = class _SessionManager {
   constructor(server, client) {
     this.server = server;
     this.client = client;
@@ -19636,8 +20856,30 @@ var SessionManager = class {
     this.contextSmartCalled = false;
     this.warningShown = false;
     // Token tracking for context pressure calculation
+    // Note: MCP servers cannot see actual token usage (AI responses, thinking, system prompts).
+    // We use a heuristic: tracked tokens + (turns * estimated tokens per turn)
     this.sessionTokens = 0;
     this.contextThreshold = 7e4;
+    // Conservative default for 100k context window
+    this.conversationTurns = 0;
+    // Continuous checkpointing
+    this.toolCallCount = 0;
+    this.checkpointInterval = 20;
+    // Save checkpoint every N tool calls
+    this.lastCheckpointAt = 0;
+    this.activeFiles = /* @__PURE__ */ new Set();
+    this.recentToolCalls = [];
+    this.checkpointEnabled = process.env.CONTEXTSTREAM_CHECKPOINT_ENABLED?.toLowerCase() === "true";
+    // Post-compaction restoration tracking
+    // Tracks when context pressure was high/critical so we can detect post-compaction state
+    this.lastHighPressureAt = null;
+    this.lastHighPressureTokens = 0;
+    this.postCompactRestoreCompleted = false;
+  }
+  static {
+    // Each conversation turn typically includes: user message (~500), AI response (~1500),
+    // system prompt overhead (~500), and reasoning (~1500). Conservative estimate: 3000/turn
+    this.TOKENS_PER_TURN_ESTIMATE = 3e3;
   }
   /**
    * Check if session has been auto-initialized
@@ -19680,17 +20922,40 @@ var SessionManager = class {
     this.folderPath = path9;
   }
   /**
-   * Mark that context_smart has been called in this session
+   * Mark that context_smart has been called in this session.
+   * Also increments the conversation turn counter for token estimation.
    */
   markContextSmartCalled() {
     this.contextSmartCalled = true;
+    this.conversationTurns++;
   }
   /**
    * Get current session token count for context pressure calculation.
+   *
+   * This returns an ESTIMATED count based on:
+   * 1. Tokens tracked through ContextStream tools (actual)
+   * 2. Estimated tokens per conversation turn (heuristic)
+   *
+   * Note: MCP servers cannot see actual AI token usage (responses, thinking,
+   * system prompts). This estimate helps provide a more realistic context
+   * pressure signal.
    */
   getSessionTokens() {
+    const turnEstimate = this.conversationTurns * _SessionManager.TOKENS_PER_TURN_ESTIMATE;
+    return this.sessionTokens + turnEstimate;
+  }
+  /**
+   * Get the raw tracked tokens (without turn-based estimation).
+   */
+  getRawTrackedTokens() {
     return this.sessionTokens;
   }
+  /**
+   * Get the current conversation turn count.
+   */
+  getConversationTurns() {
+    return this.conversationTurns;
+  }
   /**
    * Get the context threshold (max tokens before compaction warning).
    */
@@ -19729,6 +20994,52 @@ var SessionManager = class {
    */
   resetTokenCount() {
     this.sessionTokens = 0;
+    this.conversationTurns = 0;
+  }
+  /**
+   * Record that context pressure is high/critical.
+   * Called when context_smart returns high or critical pressure level.
+   */
+  markHighContextPressure() {
+    this.lastHighPressureAt = Date.now();
+    this.lastHighPressureTokens = this.getSessionTokens();
+  }
+  /**
+   * Check if we should attempt post-compaction restoration.
+   *
+   * Detection heuristic:
+   * 1. We recorded high/critical context pressure recently (within 10 minutes)
+   * 2. Current token count is very low (< 5000) compared to when pressure was high
+   * 3. We haven't already restored in this session
+   *
+   * This indicates compaction likely happened and we should restore context.
+   */
+  shouldRestorePostCompact() {
+    if (this.postCompactRestoreCompleted) {
+      return false;
+    }
+    if (!this.lastHighPressureAt) {
+      return false;
+    }
+    const elapsed = Date.now() - this.lastHighPressureAt;
+    if (elapsed > 10 * 60 * 1e3) {
+      return false;
+    }
+    const currentTokens = this.getSessionTokens();
+    const tokenDrop = this.lastHighPressureTokens - currentTokens;
+    if (currentTokens > 1e4 || tokenDrop < this.lastHighPressureTokens * 0.5) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Mark post-compaction restoration as completed.
+   * Prevents multiple restoration attempts in the same session.
+   */
+  markPostCompactRestoreCompleted() {
+    this.postCompactRestoreCompleted = true;
+    this.lastHighPressureAt = null;
+    this.lastHighPressureTokens = 0;
   }
   /**
    * Check if context_smart has been called and warn if not.
@@ -19994,6 +21305,112 @@ var SessionManager = class {
     parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
     return parts.join("\n");
   }
+  // =========================================================================
+  // Continuous Checkpointing
+  // =========================================================================
+  /**
+   * Track a tool call for checkpointing purposes.
+   * Call this after each tool execution to track files and trigger periodic checkpoints.
+   */
+  trackToolCall(toolName, input) {
+    this.toolCallCount++;
+    this.recentToolCalls.push({ name: toolName, timestamp: Date.now() });
+    if (this.recentToolCalls.length > 50) {
+      this.recentToolCalls = this.recentToolCalls.slice(-50);
+    }
+    if (input) {
+      const filePath = input.file_path || input.notebook_path || input.path;
+      if (filePath && typeof filePath === "string") {
+        this.activeFiles.add(filePath);
+        if (this.activeFiles.size > 30) {
+          const arr = Array.from(this.activeFiles);
+          this.activeFiles = new Set(arr.slice(-30));
+        }
+      }
+    }
+    this.maybeCheckpoint();
+  }
+  /**
+   * Save a checkpoint if the interval has been reached.
+   */
+  async maybeCheckpoint() {
+    if (!this.checkpointEnabled || !this.initialized || !this.context) {
+      return;
+    }
+    const callsSinceLastCheckpoint = this.toolCallCount - this.lastCheckpointAt;
+    if (callsSinceLastCheckpoint < this.checkpointInterval) {
+      return;
+    }
+    this.lastCheckpointAt = this.toolCallCount;
+    await this.saveCheckpoint("periodic");
+  }
+  /**
+   * Get the list of active files being worked on.
+   */
+  getActiveFiles() {
+    return Array.from(this.activeFiles);
+  }
+  /**
+   * Get recent tool call names.
+   */
+  getRecentToolNames() {
+    return this.recentToolCalls.map((t) => t.name);
+  }
+  /**
+   * Get the current tool call count.
+   */
+  getToolCallCount() {
+    return this.toolCallCount;
+  }
+  /**
+   * Save a checkpoint snapshot to ContextStream.
+   */
+  async saveCheckpoint(trigger) {
+    if (!this.initialized || !this.context) {
+      return false;
+    }
+    const workspaceId = this.context.workspace_id;
+    if (!workspaceId) {
+      return false;
+    }
+    const checkpointData = {
+      trigger,
+      checkpoint_number: Math.floor(this.toolCallCount / this.checkpointInterval),
+      tool_call_count: this.toolCallCount,
+      session_tokens: this.sessionTokens,
+      active_files: this.getActiveFiles(),
+      recent_tools: this.getRecentToolNames().slice(-10),
+      captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+      auto_captured: true
+    };
+    try {
+      await this.client.captureContext({
+        workspace_id: workspaceId,
+        project_id: this.context.project_id,
+        event_type: "session_snapshot",
+        title: `Checkpoint #${checkpointData.checkpoint_number} (${trigger})`,
+        content: JSON.stringify(checkpointData),
+        importance: trigger === "periodic" ? "low" : "medium",
+        tags: ["session_snapshot", "checkpoint", trigger]
+      });
+      return true;
+    } catch (err) {
+      console.error("[ContextStream] Failed to save checkpoint:", err);
+      return false;
+    }
+  }
+  /**
+   * Enable or disable continuous checkpointing.
+   */
+  setCheckpointEnabled(enabled) {
+    this.checkpointEnabled = enabled;
+  }
+  /**
+   * Set the checkpoint interval (tool calls between checkpoints).
+   */
+  setCheckpointInterval(interval) {
+    this.checkpointInterval = Math.max(5, interval);
+  }
 };
 
 // src/http-gateway.ts
@@ -20749,6 +22166,9 @@ function buildContextStreamMcpServer(params) {
     env.CONTEXTSTREAM_PROGRESSIVE_MODE = "true";
   }
   env.CONTEXTSTREAM_CONTEXT_PACK = params.contextPackEnabled === false ? "false" : "true";
+  if (params.restoreContextEnabled === false) {
+    env.CONTEXTSTREAM_RESTORE_CONTEXT = "false";
+  }
   if (params.showTiming) {
     env.CONTEXTSTREAM_SHOW_TIMING = "true";
   }
@@ -20774,6 +22194,9 @@ function buildContextStreamVsCodeServer(params) {
     env.CONTEXTSTREAM_PROGRESSIVE_MODE = "true";
   }
   env.CONTEXTSTREAM_CONTEXT_PACK = params.contextPackEnabled === false ? "false" : "true";
+  if (params.restoreContextEnabled === false) {
+    env.CONTEXTSTREAM_RESTORE_CONTEXT = "false";
+  }
   if (params.showTiming) {
     env.CONTEXTSTREAM_SHOW_TIMING = "true";
   }
@@ -20877,6 +22300,8 @@ async function upsertCodexTomlConfig(filePath, params) {
 ` : "";
   const contextPackLine = `CONTEXTSTREAM_CONTEXT_PACK = "${params.contextPackEnabled === false ? "false" : "true"}"
 `;
+  const restoreContextLine = params.restoreContextEnabled === false ? `CONTEXTSTREAM_RESTORE_CONTEXT = "false"
+` : "";
   const showTimingLine = params.showTiming ? `CONTEXTSTREAM_SHOW_TIMING = "true"
 ` : "";
   const commandLine = IS_WINDOWS ? `command = "cmd"
@@ -20892,7 +22317,7 @@ args = ["-y", "@contextstream/mcp-server"]
 [mcp_servers.contextstream.env]
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
-` + toolsetLine + contextPackLine + showTimingLine;
+` + toolsetLine + contextPackLine + restoreContextLine + showTimingLine;
   if (!exists) {
     await fs7.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
@@ -21254,6 +22679,12 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     console.log("  Useful for debugging performance; disabled by default.");
     const showTimingChoice = normalizeInput(await rl.question("Show response timing? [y/N]: "));
     const showTiming = showTimingChoice.toLowerCase() === "y" || showTimingChoice.toLowerCase() === "yes";
+    console.log("\nAutomatic Context Restoration:");
+    console.log("  Automatically restore context from recent snapshots on every session_init.");
+    console.log("  This enables seamless continuation across conversations and after compaction.");
+    console.log("  Enabled by default; disable if you prefer explicit control.");
+    const restoreContextChoice = normalizeInput(await rl.question("Enable automatic context restoration? [Y/n]: "));
+    const restoreContextEnabled = !(restoreContextChoice.toLowerCase() === "n" || restoreContextChoice.toLowerCase() === "no");
     const editors = [
       "codex",
       "claude",
@@ -21304,7 +22735,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     console.log("  1) Global");
     console.log("  2) Project");
     console.log("  3) Both");
-    const scopeChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 3): ")) || "3";
+    const scopeChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 2): ")) || "2";
     const scope = scopeChoice === "1" ? "global" : scopeChoice === "2" ? "project" : "both";
     console.log("\nInstall MCP server config as:");
     if (hasCodex && !hasProjectMcpEditors) {
@@ -21328,20 +22759,22 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
       )
     ) || mcpChoiceDefault;
     const mcpScope = mcpChoice === "2" && hasCodex && !hasProjectMcpEditors ? "skip" : mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
-    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled, showTiming });
+    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled, showTiming, restoreContextEnabled });
     const mcpServerClaude = buildContextStreamMcpServer({
       apiUrl,
       apiKey,
       toolset,
       contextPackEnabled,
-      showTiming
+      showTiming,
+      restoreContextEnabled
     });
     const vsCodeServer = buildContextStreamVsCodeServer({
       apiUrl,
       apiKey,
       toolset,
       contextPackEnabled,
-      showTiming
+      showTiming,
+      restoreContextEnabled
     });
     const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
     if (needsGlobalMcpConfig) {
@@ -21361,7 +22794,8 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
               apiKey,
               toolset,
               contextPackEnabled,
-              showTiming
+              showTiming,
+              restoreContextEnabled
             });
             writeActions.push({ kind: "mcp-config", target: filePath, status });
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
@@ -21443,53 +22877,69 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         }
       }
     }
-    if (configuredEditors.includes("claude")) {
+    const HOOKS_SUPPORTED_EDITORS = {
+      claude: "claude",
+      cursor: "cursor",
+      windsurf: "windsurf",
+      cline: "cline",
+      roo: "roo",
+      kilo: "kilo",
+      codex: null,
+      // No hooks API
+      aider: null,
+      // No hooks API
+      antigravity: null
+      // No hooks API
+    };
+    const hookEligibleEditors = configuredEditors.filter(
+      (e) => HOOKS_SUPPORTED_EDITORS[e] !== null
+    );
+    if (hookEligibleEditors.length > 0) {
       console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-      console.log("\u2502  Claude Code Hooks (Recommended)                                \u2502");
+      console.log("\u2502  AI Editor Hooks (Recommended)                                  \u2502");
       console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
       console.log("");
-      console.log("  Problem: Claude Code often ignores CLAUDE.md instructions and uses");
-      console.log("  its default tools (Grep/Glob/Search) instead of ContextStream search.");
-      console.log("  This happens because instructions decay over long conversations.");
+      console.log("  Problem: AI editors often use their default tools (Grep/Glob/Search)");
+      console.log("  instead of ContextStream smart search. Instructions decay over long chats.");
       console.log("");
       console.log("  Solution: Install hooks that:");
-      console.log("  \u2713 Block default search tools (Grep/Glob/Search) \u2192 redirect to ContextStream");
-      console.log("  \u2713 Block built-in plan mode \u2192 redirect to ContextStream plans (persistent)");
-      console.log("  \u2713 Inject reminders on every message to keep rules in context");
-      console.log("  \u2713 Result: Faster searches, persistent plans across sessions");
+      console.log("  \u2713 Use ContextStream (indexed, faster) with default tool use");
+      console.log("  \u2713 Use ContextStream plans (persistent) with default tool use");
+      console.log("  \u2713 Inject reminders to keep rules in context");
+      console.log("");
+      console.log(`  Hooks available for: ${hookEligibleEditors.map((e) => EDITOR_LABELS[e]).join(", ")}`);
       console.log("");
       console.log("  You can disable hooks anytime with CONTEXTSTREAM_HOOK_ENABLED=false");
       console.log("");
       const installHooks = normalizeInput(
-        await rl.question("Install Claude Code hooks? [Y/n] (recommended): ")
+        await rl.question("Install editor hooks? [Y/n] (recommended): ")
       ).toLowerCase();
       if (installHooks !== "n" && installHooks !== "no") {
-        try {
-          if (dryRun) {
-            console.log("- Would install hooks to ~/.claude/hooks/");
-            console.log("- Would update ~/.claude/settings.json");
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "hooks", "contextstream-redirect.py"), status: "dry-run" });
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "hooks", "contextstream-reminder.py"), status: "dry-run" });
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "settings.json"), status: "dry-run" });
-          } else {
-            const result = await installClaudeCodeHooks({ scope: "user" });
-            result.scripts.forEach((script) => {
-              writeActions.push({ kind: "mcp-config", target: script, status: "created" });
-              console.log(`- Created hook: ${script}`);
-            });
-            result.settings.forEach((settings) => {
-              writeActions.push({ kind: "mcp-config", target: settings, status: "updated" });
-              console.log(`- Updated settings: ${settings}`);
+        for (const editor of hookEligibleEditors) {
+          const hookEditor = HOOKS_SUPPORTED_EDITORS[editor];
+          if (!hookEditor) continue;
+          try {
+            if (dryRun) {
+              console.log(`- ${EDITOR_LABELS[editor]}: would install hooks`);
+              continue;
+            }
+            const result = await installEditorHooks({
+              editor: hookEditor,
+              scope: "global"
             });
+            for (const script of result.installed) {
+              writeActions.push({ kind: "hooks", target: script, status: "created" });
+              console.log(`- ${EDITOR_LABELS[editor]}: installed ${path8.basename(script)}`);
+            }
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(`- ${EDITOR_LABELS[editor]}: failed to install hooks: ${message}`);
           }
-          console.log("  Hooks installed. Disable with CONTEXTSTREAM_HOOK_ENABLED=false");
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          console.log(`- Failed to install hooks: ${message}`);
         }
+        console.log("  Hooks installed. Disable with CONTEXTSTREAM_HOOK_ENABLED=false");
       } else {
         console.log("- Skipped hooks installation.");
-        console.log("  Note: Without hooks, Claude may still use default tools instead of ContextStream.");
+        console.log("  Note: Without hooks, AI may still use default tools instead of ContextStream.");
       }
     }
     console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");