@contextstream/mcp-server 0.4.39 → 0.4.41

package/dist/index.js

@@ -8872,15 +8872,16 @@ function applyMcpToolPrefix(markdown, toolPrefix) {
   return markdown.replace(toolRegex, `${toolPrefix}$1`);
 }
 var CONTEXTSTREAM_RULES_FULL = `
-## ContextStream Rules
+## \u{1F6A8} MANDATORY RULE: DISPLAY AT START OF EVERY RESPONSE \u{1F6A8}
 
 <contextstream_rules>
-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
+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
 </contextstream_rules>
 
-**Display this block at the start of responses to keep rules in context.**
+**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.
 
 ---
 
@@ -8939,10 +8940,8 @@ 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 \`[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
+- Check for any lessons in the returned context
+- Lessons may be included based on semantic relevance to the user's message
 
 ### Before ANY Non-Trivial Work:
 **ALWAYS call \`session(action="get_lessons", query="<topic>")\`** where \`<topic>\` matches what you're about to do:
@@ -8966,42 +8965,22 @@ You have access to ContextStream MCP tools for persistent memory and context.
 v0.4.x uses **~11 consolidated domain tools** for ~75% token reduction vs previous versions.
 Rules Version: ${RULES_VERSION}
 
-## TL;DR - WHEN TO USE CONTEXT
+## TL;DR - REQUIRED EVERY MESSAGE
 
-| 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", ...)\` |
+| 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 |
 
-### Simple Utility Operations - FAST PATH
+**NO EXCEPTIONS.** Do not skip even if you think you have enough context.
 
-**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\`:
+**First message rule:** 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
 
@@ -9015,9 +8994,9 @@ Rules Version: ${RULES_VERSION}
 
 v0.4.x consolidates ~58 individual tools into ~11 domain tools with action/mode dispatch:
 
-### 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)
+### 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\`)
 
 ### Domain Tools (Use action/mode parameter)
 
@@ -9064,21 +9043,10 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 ---
 
-### Rules, Version & Lessons Notices
-
-**[RULES_NOTICE]** - Update rules via \`generate_rules()\` (or rerun setup).
+### Rules Update Notices
 
-**[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.
+- 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.
 
 ---
 
@@ -9209,24 +9177,16 @@ If ContextStream returns results, stop and use them. NEVER use local Search/Expl
 
 ---
 
-### When to Capture
+### When to Capture (MANDATORY)
 
 | When | Call | Example |
 |------|------|---------|
 | User makes decision | \`session(action="capture", event_type="decision", ...)\` | "Let's use PostgreSQL" |
 | User states preference | \`session(action="capture", event_type="preference", ...)\` | "I prefer TypeScript" |
-| Complete significant task | \`session(action="capture", event_type="task", ...)\` | Capture what was done |
+| You complete a task | \`session(action="capture", event_type="task", ...)\` | Capture what was done |
 | Need past context | \`session(action="recall", query="...")\` | "What did we decide about X?" |
 
-**DO NOT capture utility operations:**
-- \u274C "Listed workspaces" - not meaningful context
-- \u274C "Showed version" - not a decision
-- \u274C "Listed projects" - just data retrieval
-
-**DO capture meaningful work:**
-- \u2705 Decisions, preferences, completed features
-- \u2705 Lessons from mistakes
-- \u2705 Insights about architecture or patterns
+**You MUST capture after completing any significant task.** This ensures future sessions have context.
 
 ---
 
@@ -9306,15 +9266,16 @@ 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 = `
-## ContextStream Rules
+## \u{1F6A8} MANDATORY RULE: DISPLAY AT START OF EVERY RESPONSE \u{1F6A8}
 
 <contextstream_rules>
-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
+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
 </contextstream_rules>
 
-**Display this block at the start of responses to keep rules in context.**
+**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.
 
 ---
 
@@ -9323,7 +9284,7 @@ var CONTEXTSTREAM_RULES_MINIMAL = `
 Rules Version: ${RULES_VERSION}
 **Note:** PreToolUse hooks block Glob/Grep/Search when ContextStream is available.
 
-### For Coding Tasks
+### Required Every Message
 
 | Action | Tool Call |
 |--------|-----------|
@@ -9357,33 +9318,6 @@ 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
@@ -9392,27 +9326,8 @@ ContextStream search is **indexed** and returns semantic matches + context in ON
 
 ### Context Pressure & Compaction
 
-- 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
+- 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()\`
 
 ### Plans & Tasks
 
@@ -9890,7 +9805,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).
-Automatically saves conversation state to ContextStream by parsing the transcript.
+Injects a reminder for the AI to save conversation state using session_capture_smart.
 
 Input (via stdin):
 {
@@ -9906,7 +9821,7 @@ Output (to stdout):
 {
   "hookSpecificOutput": {
     "hookEventName": "PreCompact",
-    "additionalContext": "... status message ..."
+    "additionalContext": "... instructions for AI ..."
   }
 }
 """
@@ -9914,149 +9829,8 @@ 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:
@@ -10067,38 +9841,26 @@ 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", "")
 
-    # Parse transcript for context
-    transcript_data = {}
-    if transcript_path and os.path.exists(transcript_path):
-        transcript_data = parse_transcript(transcript_path)
+    # Build context injection for the AI
+    context = f"""[CONTEXT COMPACTION IMMINENT - {trigger.upper()}]
+CRITICAL: Before context is compacted, you MUST save conversation state:
 
-    # 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}]"
+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>")
 
-    # 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}
+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
 
-Active files detected: {files_list}
-Tool calls in session: {transcript_data.get('tool_call_count', 0)}
+3. After compaction, call session_init(is_post_compact=true) to restore context.
 
-After compaction, call session_init(is_post_compact=true) to restore context.
-{f"User instructions: {custom_instructions}" if custom_instructions else ""}"""
+{f"User instructions: {custom_instructions}" if custom_instructions else ""}
+[END COMPACTION WARNING]"""
 
     output = {
         "hookSpecificOutput": {
@@ -10212,760 +9974,80 @@ function mergeHooksIntoSettings(existingSettings, newHooks) {
   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 { hooks: {} };
-  }
-}
-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 filterWindsurfContextStreamHooks(hooks) {
-  if (!hooks) return [];
-  return hooks.filter((h) => !h.command?.includes("contextstream"));
-}
-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
-        }
-      ]
-    }
-  };
-  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, settingsScope, projectPath);
-      const installed = [scripts.preToolUse, scripts.userPrompt];
-      if (scripts.preCompact) installed.push(scripts.preCompact);
-      return {
-        editor: "claude",
-        installed,
-        hooksDir: getHooksDir()
-      };
-    }
-    case "cline": {
-      const scripts = await installClineHookScripts({ scope, projectPath });
-      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)
-      };
+    const filtered = existing.filter((m) => {
+      return !m.hooks?.some((h) => h.command?.includes("contextstream"));
+    });
+    existingHooks[hookType] = [...filtered, ...matchers];
+  }
+  settings.hooks = existingHooks;
+  return settings;
+}
+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);
     }
-    case "kilo": {
-      const scripts = await installKiloCodeHookScripts({ scope, projectPath });
-      return {
-        editor: "kilo",
-        installed: [scripts.preToolUse, scripts.userPromptSubmit],
-        hooksDir: getKiloCodeHooksDir(scope, projectPath)
-      };
+  } 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"));
     }
-    case "cursor": {
-      const scripts = await installCursorHookScripts();
-      return {
-        editor: "cursor",
-        installed: [scripts.preToolUse, scripts.beforeSubmit],
-        hooksDir: getCursorHooksDir()
-      };
+  }
+  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");
+      const merged = mergeHooksIntoSettings(existing, hooksConfig);
+      await writeClaudeSettings(merged, "user");
     }
-    case "windsurf": {
-      const scripts = await installWindsurfHookScripts({ scope, projectPath });
-      return {
-        editor: "windsurf",
-        installed: [scripts.preMcpToolUse, scripts.preUserPrompt],
-        hooksDir: getWindsurfHooksDir(scope, projectPath)
-      };
+    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);
     }
-    default:
-      throw new Error(`Unsupported editor: ${editor}`);
+    result.settings.push(settingsPath);
   }
+  return result;
 }
-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);
-    }
+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: {} };
   }
-  return results;
+}
+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);
 }
 
 // src/token-savings.ts
@@ -11042,75 +10124,9 @@ 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 = `
-\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.
+\u26A0\uFE0F [LESSONS - REVIEW BEFORE CHANGES]
+Past mistakes found that may be relevant. STOP and review before proceeding:
 `.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) {
@@ -11125,8 +10141,7 @@ function generateLessonsReminder(result) {
   return `
 
 ${LESSONS_REMINDER_PREFIX}
-${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`;
+${lessonLines.join("\n")}`;
 }
 function generateRulesUpdateWarning(rulesNotice) {
   if (!rulesNotice || rulesNotice.status !== "behind" && rulesNotice.status !== "missing") {
@@ -11149,16 +10164,12 @@ function generateVersionUpdateWarning(versionNotice) {
     return "";
   }
   return `
-\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}
-
-\u26A0\uFE0F IMPORTANT: You MUST tell the user about this update IMMEDIATELY.
-Do not proceed with other work until you have informed the user.
+\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.
 
-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
+**UPDATE NOW:** Run \`${versionNotice.upgrade_command || "npm update @contextstream/mcp-server"}\`
+Then restart Claude Code to use the new version.
 `.trim();
 }
 var DEFAULT_PARAM_DESCRIPTIONS = {
@@ -12019,7 +11030,6 @@ 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",
@@ -14814,7 +13824,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(
-          "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."
+          "Set to true when resuming after conversation compaction. This prioritizes session_snapshot restoration and recent decisions."
         )
       })
     },
@@ -14835,22 +13845,19 @@ 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();
-      const shouldRestoreContext = input.is_post_compact ?? RESTORE_CONTEXT_DEFAULT;
-      if (shouldRestoreContext) {
-        result.is_post_compact = true;
+      if (input.is_post_compact) {
         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 listResult = await client.listMemoryEvents({
+            const snapshotSearch = await client.searchEvents({
               workspace_id: workspaceIdForRestore,
               project_id: projectIdForRestore,
-              limit: 50
+              query: "session_snapshot",
+              event_types: ["session_snapshot"],
+              limit: 1
             });
-            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")
-            );
+            const snapshots = snapshotSearch?.data?.results || snapshotSearch?.results || snapshotSearch?.data || [];
             if (snapshots && snapshots.length > 0) {
               const latestSnapshot = snapshots[0];
               let snapshotData;
@@ -14859,52 +13866,13 @@ 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 = 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.";
+              result.post_compact_hint = "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.";
@@ -15577,16 +14545,14 @@ Use this in combination with session_init(is_post_compact=true) for seamless con
             structuredContent: toStructured(response2)
           };
         }
-        const listResult = await client.listMemoryEvents({
+        const searchResult = await client.searchEvents({
           workspace_id: workspaceId,
           project_id: projectId,
-          limit: 50
-          // Fetch more to filter
+          query: "session_snapshot",
+          event_types: ["session_snapshot"],
+          limit: input.max_snapshots || 1
         });
-        const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
-        const events = 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")
-        ).slice(0, input.max_snapshots || 1);
+        const events = searchResult?.data?.results || searchResult?.results || searchResult?.data || [];
         if (!events || events.length === 0) {
           return {
             content: [
@@ -16054,77 +15020,34 @@ 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 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;
+      const hasClaude = editors.includes("claude");
+      const shouldInstallHooks = hasClaude && input.install_hooks !== false;
       if (shouldInstallHooks) {
         try {
           if (input.dry_run) {
-            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" }
-                );
-              }
+            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" });
             }
           } else {
-            hooksResults = [];
-            const allHookResults = await installAllEditorHooks({
-              scope: "global",
-              editors: hookSupportedEditors,
+            const hookResult = await installClaudeCodeHooks({
+              scope: "user",
               includePreCompact: input.include_pre_compact
             });
-            for (const result of allHookResults) {
-              for (const file of result.installed) {
-                hooksResults.push({ editor: result.editor, file, status: "created" });
-              }
-            }
+            hooksResults = [
+              ...hookResult.scripts.map((f) => ({ file: f, status: "created" })),
+              ...hookResult.settings.map((f) => ({ file: f, status: "updated" }))
+            ];
           }
         } catch (err) {
           hooksResults = [{ file: "hooks", status: `error: ${err.message}` }];
         }
-      } else if (hookSupportedEditors.length > 0 && input.install_hooks === false) {
-        hooksPrompt = "Hooks skipped. AI may use default tools instead of ContextStream search.";
+      } else if (hasClaude && input.install_hooks === false) {
+        hooksPrompt = "Hooks skipped. Claude may use default tools instead of ContextStream search.";
       }
       const summary = {
         folder: folderPath,
@@ -16503,52 +15426,6 @@ 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,
@@ -16589,44 +15466,8 @@ This saves ~80% tokens compared to including full chat history.`,
         project_id: projectId,
         max_tokens: input.max_tokens
       });
-      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 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." : "";
       const searchRulesLine = SEARCH_RULES_REMINDER_ENABLED ? `
 
 ${SEARCH_RULES_REMINDER}` : "";
@@ -16634,18 +15475,12 @@ ${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)
@@ -16663,16 +15498,14 @@ ${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: finalContext + footer + allWarnings
+            text: result.context + footer + allWarnings
           }
         ],
-        structuredContent: toStructured(enrichedResultWithRestore)
+        structuredContent: toStructured(enrichedResult)
       };
     }
   );
@@ -17741,7 +16574,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       "session",
       {
         title: "Session",
-        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance), restore_context (restore state after compaction). Plan actions: capture_plan (save implementation plan), get_plan (retrieve plan with tasks), update_plan (modify plan), list_plans (list all plans).`,
+        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance). Plan actions: capture_plan (save implementation plan), get_plan (retrieve plan with tasks), update_plan (modify plan), list_plans (list all plans).`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "capture",
@@ -17759,9 +16592,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "capture_plan",
             "get_plan",
             "update_plan",
-            "list_plans",
-            // Context restore
-            "restore_context"
+            "list_plans"
           ]).describe("Action to perform"),
           workspace_id: external_exports.string().uuid().optional(),
           project_id: external_exports.string().uuid().optional(),
@@ -17783,8 +16614,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "lesson",
             "warning",
             "frustration",
-            "conversation",
-            "session_snapshot"
+            "conversation"
           ]).optional().describe("Event type for capture"),
           importance: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
           tags: external_exports.array(external_exports.string()).optional(),
@@ -17834,10 +16664,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           status: external_exports.enum(["draft", "active", "completed", "archived", "abandoned"]).optional().describe("Plan status"),
           due_at: external_exports.string().optional().describe("Due date for plan (ISO timestamp)"),
           source_tool: external_exports.string().optional().describe("Tool that generated this plan"),
-          include_tasks: external_exports.boolean().optional().describe("Include tasks when getting plan"),
-          // Restore context params
-          snapshot_id: external_exports.string().uuid().optional().describe("Specific snapshot ID to restore (defaults to most recent)"),
-          max_snapshots: external_exports.number().optional().default(1).describe("Number of recent snapshots to consider (default: 1)")
+          include_tasks: external_exports.boolean().optional().describe("Include tasks when getting plan")
         })
       },
       async (input) => {
@@ -18143,143 +16970,6 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               structuredContent: toStructured(result)
             };
           }
-          case "restore_context": {
-            if (!workspaceId) {
-              return errorResult(
-                "restore_context requires workspace_id. Call session_init first."
-              );
-            }
-            if (input.snapshot_id) {
-              const eventResult = await client.getEvent(input.snapshot_id);
-              const event = eventResult?.data || eventResult;
-              if (!event || !event.content) {
-                return errorResult(
-                  `Snapshot not found: ${input.snapshot_id}. The snapshot may have been deleted or does not exist.`
-                );
-              }
-              let snapshotData;
-              try {
-                snapshotData = JSON.parse(event.content);
-              } 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: 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) }],
-                structuredContent: toStructured(response2)
-              };
-            }
-            const listResult = await client.listMemoryEvents({
-              workspace_id: workspaceId,
-              project_id: projectId,
-              limit: 50
-              // Fetch more to filter
-            });
-            const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
-            const snapshotEvents = 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")
-            ).slice(0, input.max_snapshots || 1);
-            if (!snapshotEvents || snapshotEvents.length === 0) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: formatContent({
-                      restored: false,
-                      message: "No session snapshots found. Use session_capture_smart to save state before compaction.",
-                      hint: "Start fresh or use session_init to get recent context."
-                    })
-                  }
-                ]
-              };
-            }
-            const snapshots = snapshotEvents.map((event) => {
-              let snapshotData;
-              try {
-                snapshotData = JSON.parse(event.content || "{}");
-              } catch {
-                snapshotData = { conversation_summary: event.content };
-              }
-              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,
-              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) }],
-              structuredContent: toStructured(response)
-            };
-          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }
@@ -20844,7 +19534,8 @@ function registerPrompts(server) {
 }
 
 // src/session-manager.ts
-var SessionManager = class _SessionManager {
+var SessionManager = class {
+  // Conservative default for 100k context window
   constructor(server, client) {
     this.server = server;
     this.client = client;
@@ -20856,30 +19547,8 @@ var SessionManager = class _SessionManager {
     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
@@ -20922,40 +19591,17 @@ var SessionManager = class _SessionManager {
     this.folderPath = path9;
   }
   /**
-   * Mark that context_smart has been called in this session.
-   * Also increments the conversation turn counter for token estimation.
+   * Mark that context_smart has been called in this session
    */
   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).
    */
@@ -20994,52 +19640,6 @@ var SessionManager = class _SessionManager {
    */
   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.
@@ -21305,112 +19905,6 @@ var SessionManager = class _SessionManager {
     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
@@ -22166,9 +20660,6 @@ 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";
   }
@@ -22194,9 +20685,6 @@ 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";
   }
@@ -22300,8 +20788,6 @@ 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"
@@ -22317,7 +20803,7 @@ args = ["-y", "@contextstream/mcp-server"]
 [mcp_servers.contextstream.env]
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
-` + toolsetLine + contextPackLine + restoreContextLine + showTimingLine;
+` + toolsetLine + contextPackLine + showTimingLine;
   if (!exists) {
     await fs7.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
@@ -22679,12 +21165,6 @@ 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",
@@ -22735,7 +21215,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 2): ")) || "2";
+    const scopeChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 3): ")) || "3";
     const scope = scopeChoice === "1" ? "global" : scopeChoice === "2" ? "project" : "both";
     console.log("\nInstall MCP server config as:");
     if (hasCodex && !hasProjectMcpEditors) {
@@ -22759,22 +21239,20 @@ 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, restoreContextEnabled });
+    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled, showTiming });
     const mcpServerClaude = buildContextStreamMcpServer({
       apiUrl,
       apiKey,
       toolset,
       contextPackEnabled,
-      showTiming,
-      restoreContextEnabled
+      showTiming
     });
     const vsCodeServer = buildContextStreamVsCodeServer({
       apiUrl,
       apiKey,
       toolset,
       contextPackEnabled,
-      showTiming,
-      restoreContextEnabled
+      showTiming
     });
     const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
     if (needsGlobalMcpConfig) {
@@ -22794,8 +21272,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
               apiKey,
               toolset,
               contextPackEnabled,
-              showTiming,
-              restoreContextEnabled
+              showTiming
             });
             writeActions.push({ kind: "mcp-config", target: filePath, status });
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
@@ -22877,69 +21354,53 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         }
       }
     }
-    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) {
+    if (configuredEditors.includes("claude")) {
       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  AI Editor Hooks (Recommended)                                  \u2502");
+      console.log("\u2502  Claude Code 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: AI editors often use their default tools (Grep/Glob/Search)");
-      console.log("  instead of ContextStream smart search. Instructions decay over long chats.");
+      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("");
       console.log("  Solution: Install hooks that:");
-      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("  \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("");
       console.log("  You can disable hooks anytime with CONTEXTSTREAM_HOOK_ENABLED=false");
       console.log("");
       const installHooks = normalizeInput(
-        await rl.question("Install editor hooks? [Y/n] (recommended): ")
+        await rl.question("Install Claude Code hooks? [Y/n] (recommended): ")
       ).toLowerCase();
       if (installHooks !== "n" && installHooks !== "no") {
-        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"
+        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 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, AI may still use default tools instead of ContextStream.");
+        console.log("  Note: Without hooks, Claude 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");