@contextstream/mcp-server 0.4.41 → 0.4.43

package/dist/index.js

@@ -4542,7 +4542,7 @@ import { createRequire } from "module";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var UPGRADE_COMMAND = "npm update -g @contextstream/mcp-server";
+var UPGRADE_COMMAND = "npm install -g @contextstream/mcp-server@latest";
 var NPM_LATEST_URL = "https://registry.npmjs.org/@contextstream/mcp-server/latest";
 function getVersion() {
   try {
@@ -7689,6 +7689,7 @@ var ContextStreamClient = class {
         project_id: withDefaults.project_id,
         ...versionNotice2 ? { version_notice: versionNotice2 } : {},
         ...Array.isArray(data?.errors) ? { errors: data.errors } : {},
+        ...Array.isArray(data?.warnings) && data.warnings.length > 0 ? { warnings: data.warnings } : {},
         ...this.indexRefreshInProgress ? { index_status: "refreshing" } : {},
         ...data?.context_pressure ? { context_pressure: data.context_pressure } : {}
       };
@@ -8872,16 +8873,15 @@ function applyMcpToolPrefix(markdown, toolPrefix) {
   return markdown.replace(toolRegex, `${toolPrefix}$1`);
 }
 var CONTEXTSTREAM_RULES_FULL = `
-## \u{1F6A8} MANDATORY RULE: DISPLAY AT START OF EVERY RESPONSE \u{1F6A8}
+## ContextStream Rules
 
 <contextstream_rules>
-1. **SEARCH FIRST:** Before Glob/Grep/Search/Read \u2192 \`search(mode="hybrid", query="...")\` FIRST
-2. **EVERY MESSAGE:** Call \`context_smart(user_message="...")\` at start of response
-3. **LOCAL TOOLS:** ONLY if ContextStream search returns 0 results after retry
+1. **SIMPLE UTILITY?** (list/show/version) \u2192 Just execute, skip context calls
+2. **CODING TASK?** \u2192 session_init \u2192 context_smart \u2192 work \u2192 capture
+3. **SEARCH FIRST:** Before Glob/Grep/Read \u2192 \`search(mode="hybrid")\` FIRST
 </contextstream_rules>
 
-**You MUST display the <contextstream_rules> block verbatim at the start of EVERY response.**
-This is a self-referential rule that ensures these instructions stay in recent context.
+**Display this block at the start of responses to keep rules in context.**
 
 ---
 
@@ -8940,8 +8940,10 @@ This applies to **EVERY search** throughout the **ENTIRE conversation**, not jus
 - **Apply the prevention steps** from each lesson to avoid repeating mistakes
 
 ### On \`context_smart\`:
-- Check for any lessons in the returned context
-- Lessons may be included based on semantic relevance to the user's message
+- Check for \`[LESSONS_WARNING]\` tag in the response
+- If present, you **MUST** tell the user about the lessons before proceeding
+- Lessons are proactively fetched when risky actions are detected (refactor, migrate, deploy, etc.)
+- **Do not skip or bury this warning** - lessons represent real past mistakes
 
 ### Before ANY Non-Trivial Work:
 **ALWAYS call \`session(action="get_lessons", query="<topic>")\`** where \`<topic>\` matches what you're about to do:
@@ -8965,22 +8967,43 @@ You have access to ContextStream MCP tools for persistent memory and context.
 v0.4.x uses **~11 consolidated domain tools** for ~75% token reduction vs previous versions.
 Rules Version: ${RULES_VERSION}
 
-## TL;DR - REQUIRED EVERY MESSAGE
+## TL;DR - WHEN TO USE CONTEXT
 
-| Message | What to Call |
-|---------|--------------|
-| **1st message** | \`session_init(folder_path="...", context_hint="<user's message>")\`, then \`context_smart(...)\` |
-| **\u26A0\uFE0F After session_init** | **CHECK \`lessons\` field** - if present, read and apply them BEFORE any work |
-| **2nd+ messages** | \`context_smart(user_message="<user's message>", format="minified", max_tokens=400)\` |
-| **\u{1F50D} ANY code search** | \`search(mode="hybrid", query="...")\` \u2014 ALWAYS before Glob/Grep/Search/Read |
-| **\u26A0\uFE0F Before ANY risky work** | \`session(action="get_lessons", query="<topic>")\` \u2014 **MANDATORY, not optional** |
-| **After completing task** | \`session(action="capture", event_type="decision", ...)\` - MUST capture |
-| **User frustration/correction** | \`session(action="capture_lesson", ...)\` - MUST capture lessons |
-| **Command/tool error + fix** | \`session(action="capture_lesson", ...)\` - MUST capture lessons |
+| Request Type | What to Do |
+|--------------|------------|
+| **\u{1F680} Simple utility** (list workspaces, show version) | **Just execute directly** - skip session_init, context_smart, capture |
+| **\u{1F4BB} Coding task** (edit, create, refactor) | Full context: session_init \u2192 context_smart \u2192 work \u2192 capture |
+| **\u{1F50D} Code search/discovery** | session_init \u2192 context_smart \u2192 search() |
+| **\u26A0\uFE0F Risky work** (deploy, migrate, refactor) | Check lessons first: \`session(action="get_lessons")\` |
+| **User frustration/correction** | Capture lesson: \`session(action="capture_lesson", ...)\` |
 
-**NO EXCEPTIONS.** Do not skip even if you think you have enough context.
+### Simple Utility Operations - FAST PATH
 
-**First message rule:** After \`session_init\`:
+**For simple queries, just execute and respond:**
+- "list workspaces" \u2192 \`workspace(action="list")\` \u2192 done
+- "list projects" \u2192 \`project(action="list")\` \u2192 done
+- "show version" \u2192 \`help(action="version")\` \u2192 done
+- "what reminders do I have" \u2192 \`reminder(action="list")\` \u2192 done
+
+**No session_init. No context_smart. No capture.** These add noise, not value.
+
+### Coding Tasks - FULL CONTEXT
+
+| Step | What to Call |
+|------|--------------|
+| **1st message** | \`session_init(folder_path="...", context_hint="<msg>")\`, then \`context_smart(...)\` |
+| **2nd+ messages** | \`context_smart(user_message="<msg>", format="minified", max_tokens=400)\` |
+| **Code search** | \`search(mode="hybrid", query="...")\` \u2014 BEFORE Glob/Grep/Read |
+| **After significant work** | \`session(action="capture", event_type="decision", ...)\` |
+| **User correction** | \`session(action="capture_lesson", ...)\` |
+| **\u26A0\uFE0F When warnings received** | **STOP**, acknowledge, explain mitigation, then proceed |
+
+**How to detect simple utility operations:**
+- Single-word commands: "list", "show", "version", "help"
+- Data retrieval with no context dependency: "list my workspaces", "what projects do I have"
+- Status checks: "am I authenticated?", "what's the server version?"
+
+**First message rule (for coding tasks):** After \`session_init\`:
 1. Check for \`lessons\` in response - if present, READ and SUMMARIZE them to user
 2. Then call \`context_smart\` before any other tool or response
 
@@ -8994,9 +9017,9 @@ Rules Version: ${RULES_VERSION}
 
 v0.4.x consolidates ~58 individual tools into ~11 domain tools with action/mode dispatch:
 
-### Standalone Tools (Always Call)
-- **\`session_init\`** - Initialize session with workspace detection + context
-- **\`context_smart\`** - Semantic search for relevant context (CALL EVERY MESSAGE, including immediately after \`session_init\`)
+### Standalone Tools
+- **\`session_init\`** - Initialize session with workspace detection + context (skip for simple utility operations)
+- **\`context_smart\`** - Semantic search for relevant context (skip for simple utility operations)
 
 ### Domain Tools (Use action/mode parameter)
 
@@ -9043,10 +9066,21 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 ---
 
-### Rules Update Notices
+### Rules, Version & Lessons Notices
+
+**[RULES_NOTICE]** - Update rules via \`generate_rules()\` (or rerun setup).
 
-- If you see **[RULES_NOTICE]**, update rules via \`generate_rules()\` (or rerun setup).
-- If you see **[VERSION_NOTICE]**, tell the user to update MCP using the provided command.
+**[VERSION_NOTICE]** - You **MUST IMMEDIATELY** tell the user:
+  1. A new MCP server version is available
+  2. The exact update command to run
+  3. That they need to restart their AI tool after updating
+  **Do not skip this** - users often miss stderr warnings.
+
+**[LESSONS_WARNING]** - You **MUST** before proceeding:
+  1. Read all lessons listed
+  2. Tell the user about relevant lessons
+  3. Explain how you will avoid each past mistake
+  **This is critical** - ignoring lessons leads to repeated failures.
 
 ---
 
@@ -9106,6 +9140,24 @@ session(action="capture", event_type="session_snapshot", title="Pre-compaction s
 
 **NEVER fall back to local tools (Glob/Grep/Read) just because search returned 0 results on first try.** Retry first.
 
+### Enhanced Context (Server-Side Warnings)
+
+\`context_smart\` now includes **intelligent server-side filtering** that proactively surfaces relevant warnings:
+
+**Response fields:**
+- \`warnings\`: Array of warning strings (displayed with \u26A0\uFE0F prefix)
+
+**What triggers warnings:**
+- **Lessons**: Past mistakes relevant to the current query (via semantic matching)
+- **Risky actions**: Detected high-risk operations (deployments, migrations, destructive commands)
+- **Breaking changes**: When modifications may impact other parts of the codebase
+
+**When you receive warnings:**
+1. **STOP** and read each warning carefully
+2. **Acknowledge** the warning to the user
+3. **Explain** how you will avoid the issue
+4. Only proceed after addressing the warnings
+
 ### Search & Code Intelligence (ContextStream-first)
 
 \u26A0\uFE0F **STOP: Before using Search/Glob/Grep/Read/Explore** \u2192 Call \`search(mode="hybrid")\` FIRST. Use local tools ONLY if ContextStream returns 0 results.
@@ -9177,16 +9229,24 @@ If ContextStream returns results, stop and use them. NEVER use local Search/Expl
 
 ---
 
-### When to Capture (MANDATORY)
+### When to Capture
 
 | When | Call | Example |
 |------|------|---------|
 | User makes decision | \`session(action="capture", event_type="decision", ...)\` | "Let's use PostgreSQL" |
 | User states preference | \`session(action="capture", event_type="preference", ...)\` | "I prefer TypeScript" |
-| You complete a task | \`session(action="capture", event_type="task", ...)\` | Capture what was done |
+| Complete significant task | \`session(action="capture", event_type="task", ...)\` | Capture what was done |
 | Need past context | \`session(action="recall", query="...")\` | "What did we decide about X?" |
 
-**You MUST capture after completing any significant task.** This ensures future sessions have context.
+**DO NOT capture utility operations:**
+- \u274C "Listed workspaces" - not meaningful context
+- \u274C "Showed version" - not a decision
+- \u274C "Listed projects" - just data retrieval
+
+**DO capture meaningful work:**
+- \u2705 Decisions, preferences, completed features
+- \u2705 Lessons from mistakes
+- \u2705 Insights about architecture or patterns
 
 ---
 
@@ -9266,16 +9326,15 @@ memory(action="create_task", title="<task title>", plan_id="<plan_id from step 1
 See full documentation: https://contextstream.io/docs/mcp/tools
 `.trim();
 var CONTEXTSTREAM_RULES_MINIMAL = `
-## \u{1F6A8} MANDATORY RULE: DISPLAY AT START OF EVERY RESPONSE \u{1F6A8}
+## ContextStream Rules
 
 <contextstream_rules>
-1. **SEARCH FIRST:** Before Glob/Grep/Search/Read \u2192 \`search(mode="hybrid", query="...")\` FIRST
-2. **EVERY MESSAGE:** Call \`context_smart(user_message="...")\` at start of response
-3. **LOCAL TOOLS:** ONLY if ContextStream search returns 0 results after retry
+1. **SIMPLE UTILITY?** (list/show/version) \u2192 Just execute, skip context calls
+2. **CODING TASK?** \u2192 session_init \u2192 context_smart \u2192 work \u2192 capture
+3. **SEARCH FIRST:** Before Glob/Grep/Read \u2192 \`search(mode="hybrid")\` FIRST
 </contextstream_rules>
 
-**You MUST display the <contextstream_rules> block verbatim at the start of EVERY response.**
-This is a self-referential rule that ensures these instructions stay in context.
+**Display this block at the start of responses to keep rules in context.**
 
 ---
 
@@ -9284,7 +9343,7 @@ This is a self-referential rule that ensures these instructions stay in context.
 Rules Version: ${RULES_VERSION}
 **Note:** PreToolUse hooks block Glob/Grep/Search when ContextStream is available.
 
-### Required Every Message
+### For Coding Tasks
 
 | Action | Tool Call |
 |--------|-----------|
@@ -9318,6 +9377,33 @@ ContextStream search is **indexed** and returns semantic matches + context in ON
 | \`memory\` | \`memory(action="list_events", limit=10)\` |
 | \`graph\` | \`graph(action="dependencies", file_path="...")\` |
 
+### \u{1F680} FAST PATH: Simple Utility Operations
+
+**For simple utility commands, SKIP the ceremony and just execute directly:**
+
+| Command Type | Just Call | Skip |
+|--------------|-----------|------|
+| List workspaces | \`workspace(action="list")\` | session_init, context_smart, capture |
+| List projects | \`project(action="list")\` | session_init, context_smart, capture |
+| Show version | \`help(action="version")\` | session_init, context_smart, capture |
+| List reminders | \`reminder(action="list")\` | session_init, context_smart, capture |
+| Check auth | \`help(action="auth")\` | session_init, context_smart, capture |
+
+**Detect simple operations by these patterns:**
+- "list ...", "show ...", "what are my ...", "get ..."
+- Single-action queries with no context dependency
+- User just wants data, not analysis or coding help
+
+**DO NOT add overhead for utility operations:**
+- \u274C Don't call session_init just to list workspaces
+- \u274C Don't call context_smart for simple queries
+- \u274C Don't capture "listed workspaces" as an event (that's noise)
+
+**Use full context ceremony ONLY for:**
+- Coding tasks (edit, create, refactor, debug)
+- Search/discovery (finding code, understanding architecture)
+- Tasks where past decisions or lessons matter
+
 ### Lessons (Past Mistakes)
 
 - After \`session_init\`: Check for \`lessons\` field and apply before work
@@ -9326,8 +9412,32 @@ ContextStream search is **indexed** and returns semantic matches + context in ON
 
 ### Context Pressure & Compaction
 
-- If \`context_smart\` returns high/critical \`context_pressure\`: call \`session_capture_smart(...)\` to save state
-- After compaction (context lost): call \`session_init(..., is_post_compact=true)\` or \`session_restore_context()\`
+- If \`context_smart\` returns high/critical \`context_pressure\`: call \`session(action="capture", ...)\` to save state
+- PreCompact hooks automatically save snapshots before compaction (if installed)
+
+### Enhanced Context (Warnings)
+
+\`context_smart\` returns server-side \`warnings\` for lessons, risky actions, and breaking changes.
+When warnings are present: **STOP**, acknowledge them, explain mitigation, then proceed.
+
+### Automatic Context Restoration
+
+**Context restoration is now enabled by default.** Every \`session_init\` call automatically:
+- Restores context from recent snapshots (if available)
+- Returns \`restored_context\` field with snapshot data
+- Sets \`is_post_compact=true\` in response when restoration occurs
+
+**No special handling needed after compaction** - just call \`session_init\` normally.
+
+To disable automatic restoration:
+- Pass \`is_post_compact=false\` in the API call
+- Or set \`CONTEXTSTREAM_RESTORE_CONTEXT=false\` environment variable
+
+### Notices - MUST HANDLE IMMEDIATELY
+
+- **[VERSION_NOTICE]**: Tell the user about the update and command to run
+- **[RULES_NOTICE]**: Run \`generate_rules(overwrite_existing=true)\` to update
+- **[LESSONS_WARNING]**: Read lessons, tell user about them, explain how you'll avoid past mistakes
 
 ### Plans & Tasks
 
@@ -9353,13 +9463,6 @@ var TEMPLATES = {
     description: "Codex CLI agent instructions",
     build: (rules) => `# Codex CLI Instructions
 ${rules}
-`
-  },
-  windsurf: {
-    filename: ".windsurfrules",
-    description: "Windsurf AI rules",
-    build: (rules) => `# Windsurf Rules
-${rules}
 `
   },
   cursor: {
@@ -9805,7 +9908,7 @@ var PRECOMPACT_HOOK_SCRIPT = `#!/usr/bin/env python3
 ContextStream PreCompact Hook for Claude Code
 
 Runs BEFORE conversation context is compacted (manual via /compact or automatic).
-Injects a reminder for the AI to save conversation state using session_capture_smart.
+Automatically saves conversation state to ContextStream by parsing the transcript.
 
 Input (via stdin):
 {
@@ -9821,7 +9924,7 @@ Output (to stdout):
 {
   "hookSpecificOutput": {
     "hookEventName": "PreCompact",
-    "additionalContext": "... instructions for AI ..."
+    "additionalContext": "... status message ..."
   }
 }
 """
@@ -9829,8 +9932,149 @@ Output (to stdout):
 import json
 import sys
 import os
+import re
+import urllib.request
+import urllib.error
 
 ENABLED = os.environ.get("CONTEXTSTREAM_PRECOMPACT_ENABLED", "true").lower() == "true"
+AUTO_SAVE = os.environ.get("CONTEXTSTREAM_PRECOMPACT_AUTO_SAVE", "true").lower() == "true"
+API_URL = os.environ.get("CONTEXTSTREAM_API_URL", "https://api.contextstream.io")
+API_KEY = os.environ.get("CONTEXTSTREAM_API_KEY", "")
+
+WORKSPACE_ID = None
+
+def load_config_from_mcp_json(cwd):
+    """Load API config from .mcp.json if env vars not set."""
+    global API_URL, API_KEY, WORKSPACE_ID
+
+    # Try to find .mcp.json and .contextstream/config.json in cwd or parent directories
+    search_dir = cwd
+    for _ in range(5):  # Search up to 5 levels
+        # Load API config from .mcp.json
+        if not API_KEY:
+            mcp_path = os.path.join(search_dir, ".mcp.json")
+            if os.path.exists(mcp_path):
+                try:
+                    with open(mcp_path, 'r') as f:
+                        config = json.load(f)
+                    servers = config.get("mcpServers", {})
+                    cs_config = servers.get("contextstream", {})
+                    env = cs_config.get("env", {})
+                    if env.get("CONTEXTSTREAM_API_KEY"):
+                        API_KEY = env["CONTEXTSTREAM_API_KEY"]
+                    if env.get("CONTEXTSTREAM_API_URL"):
+                        API_URL = env["CONTEXTSTREAM_API_URL"]
+                except:
+                    pass
+
+        # Load workspace_id from .contextstream/config.json
+        if not WORKSPACE_ID:
+            cs_config_path = os.path.join(search_dir, ".contextstream", "config.json")
+            if os.path.exists(cs_config_path):
+                try:
+                    with open(cs_config_path, 'r') as f:
+                        cs_config = json.load(f)
+                    if cs_config.get("workspace_id"):
+                        WORKSPACE_ID = cs_config["workspace_id"]
+                except:
+                    pass
+
+        parent = os.path.dirname(search_dir)
+        if parent == search_dir:
+            break
+        search_dir = parent
+
+def parse_transcript(transcript_path):
+    """Parse transcript to extract active files, decisions, and context."""
+    active_files = set()
+    recent_messages = []
+    tool_calls = []
+
+    try:
+        with open(transcript_path, 'r') as f:
+            for line in f:
+                try:
+                    entry = json.loads(line.strip())
+                    msg_type = entry.get("type", "")
+
+                    # Extract files from tool calls
+                    if msg_type == "tool_use":
+                        tool_name = entry.get("name", "")
+                        tool_input = entry.get("input", {})
+                        tool_calls.append({"name": tool_name, "input": tool_input})
+
+                        # Extract file paths from common tools
+                        if tool_name in ["Read", "Write", "Edit", "NotebookEdit"]:
+                            file_path = tool_input.get("file_path") or tool_input.get("notebook_path")
+                            if file_path:
+                                active_files.add(file_path)
+                        elif tool_name == "Glob":
+                            pattern = tool_input.get("pattern", "")
+                            if pattern:
+                                active_files.add(f"[glob:{pattern}]")
+
+                    # Collect recent assistant messages for summary
+                    if msg_type == "assistant" and entry.get("content"):
+                        content = entry.get("content", "")
+                        if isinstance(content, str) and len(content) > 50:
+                            recent_messages.append(content[:500])
+
+                except json.JSONDecodeError:
+                    continue
+    except Exception as e:
+        pass
+
+    return {
+        "active_files": list(active_files)[-20:],  # Last 20 files
+        "tool_call_count": len(tool_calls),
+        "message_count": len(recent_messages),
+        "last_tools": [t["name"] for t in tool_calls[-10:]],  # Last 10 tool names
+    }
+
+def save_snapshot(session_id, transcript_data, trigger):
+    """Save snapshot to ContextStream API."""
+    if not API_KEY:
+        return False, "No API key configured"
+
+    snapshot_content = {
+        "session_id": session_id,
+        "trigger": trigger,
+        "captured_at": None,  # API will set timestamp
+        "active_files": transcript_data.get("active_files", []),
+        "tool_call_count": transcript_data.get("tool_call_count", 0),
+        "last_tools": transcript_data.get("last_tools", []),
+        "auto_captured": True,
+    }
+
+    payload = {
+        "event_type": "session_snapshot",
+        "title": f"Auto Pre-compaction Snapshot ({trigger})",
+        "content": json.dumps(snapshot_content),
+        "importance": "high",
+        "tags": ["session_snapshot", "pre_compaction", "auto_captured"],
+        "source_type": "hook",
+    }
+
+    # Add workspace_id if available
+    if WORKSPACE_ID:
+        payload["workspace_id"] = WORKSPACE_ID
+
+    try:
+        req = urllib.request.Request(
+            f"{API_URL}/api/v1/memory/events",
+            data=json.dumps(payload).encode('utf-8'),
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": API_KEY,
+            },
+            method="POST"
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            return True, "Snapshot saved"
+    except urllib.error.URLError as e:
+        return False, str(e)
+    except Exception as e:
+        return False, str(e)
 
 def main():
     if not ENABLED:
@@ -9841,26 +10085,38 @@ def main():
     except:
         sys.exit(0)
 
+    # Load config from .mcp.json if env vars not set
+    cwd = data.get("cwd", os.getcwd())
+    load_config_from_mcp_json(cwd)
+
+    session_id = data.get("session_id", "unknown")
+    transcript_path = data.get("transcript_path", "")
     trigger = data.get("trigger", "unknown")
     custom_instructions = data.get("custom_instructions", "")
 
-    # Build context injection for the AI
-    context = f"""[CONTEXT COMPACTION IMMINENT - {trigger.upper()}]
-CRITICAL: Before context is compacted, you MUST save conversation state:
+    # Parse transcript for context
+    transcript_data = {}
+    if transcript_path and os.path.exists(transcript_path):
+        transcript_data = parse_transcript(transcript_path)
 
-1. IMMEDIATELY call: mcp__contextstream__session(action="capture", event_type="session_snapshot", title="Pre-compaction snapshot", content="<JSON with: conversation_summary, active_goals, recent_decisions, active_files, unfinished_work>")
+    # Auto-save snapshot if enabled
+    auto_save_status = ""
+    if AUTO_SAVE and API_KEY:
+        success, msg = save_snapshot(session_id, transcript_data, trigger)
+        if success:
+            auto_save_status = f"\\n[ContextStream: Auto-saved snapshot with {len(transcript_data.get('active_files', []))} active files]"
+        else:
+            auto_save_status = f"\\n[ContextStream: Auto-save failed - {msg}]"
 
-2. Include in the snapshot:
-   - conversation_summary: Brief summary of what was discussed
-   - active_goals: List of goals/tasks in progress
-   - recent_decisions: Key decisions made in this session
-   - active_files: Files currently being worked on
-   - unfinished_work: Any incomplete tasks
+    # Build context injection for the AI (backup in case auto-save fails)
+    files_list = ", ".join(transcript_data.get("active_files", [])[:5]) or "none detected"
+    context = f"""[CONTEXT COMPACTION - {trigger.upper()}]{auto_save_status}
 
-3. After compaction, call session_init(is_post_compact=true) to restore context.
+Active files detected: {files_list}
+Tool calls in session: {transcript_data.get('tool_call_count', 0)}
 
-{f"User instructions: {custom_instructions}" if custom_instructions else ""}
-[END COMPACTION WARNING]"""
+After compaction, call session_init(is_post_compact=true) to restore context.
+{f"User instructions: {custom_instructions}" if custom_instructions else ""}"""
 
     output = {
         "hookSpecificOutput": {
@@ -9982,45 +10238,6 @@ function mergeHooksIntoSettings(existingSettings, newHooks) {
   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);
-    }
-  } 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"));
-    }
-  }
-  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");
-    }
-    result.settings.push(settingsPath);
-  }
-  if ((options.scope === "project" || options.scope === "both") && options.projectPath) {
-    const settingsPath = getClaudeSettingsPath("project", options.projectPath);
-    if (!options.dryRun) {
-      const existing = await readClaudeSettings("project", options.projectPath);
-      const merged = mergeHooksIntoSettings(existing, hooksConfig);
-      await writeClaudeSettings(merged, "project", options.projectPath);
-    }
-    result.settings.push(settingsPath);
-  }
-  return result;
-}
 function getIndexStatusPath() {
   return path5.join(homedir2(), ".contextstream", "indexed-projects.json");
 }
@@ -10049,6 +10266,547 @@ async function markProjectIndexed(projectPath, options) {
   };
   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
+  };
+}
+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)
+      };
+    }
+    case "kilo": {
+      const scripts = await installKiloCodeHookScripts({ scope, projectPath });
+      return {
+        editor: "kilo",
+        installed: [scripts.preToolUse, scripts.userPromptSubmit],
+        hooksDir: getKiloCodeHooksDir(scope, projectPath)
+      };
+    }
+    case "cursor": {
+      const scripts = await installCursorHookScripts();
+      return {
+        editor: "cursor",
+        installed: [scripts.preToolUse, scripts.beforeSubmit],
+        hooksDir: getCursorHooksDir()
+      };
+    }
+    default:
+      throw new Error(`Unsupported editor: ${editor}`);
+  }
+}
+async function installAllEditorHooks(options) {
+  const editors = options.editors || ["claude", "cline", "roo", "kilo", "cursor"];
+  const results = [];
+  for (const editor of editors) {
+    try {
+      const result = await installEditorHooks({
+        editor,
+        scope: options.scope,
+        projectPath: options.projectPath,
+        includePreCompact: options.includePreCompact
+      });
+      results.push(result);
+    } catch (error) {
+      console.error(`Failed to install hooks for ${editor}:`, error);
+    }
+  }
+  return results;
+}
 
 // src/token-savings.ts
 var TOKEN_SAVINGS_FORMULA_VERSION = 1;
@@ -10114,6 +10872,54 @@ function trackToolTokenSavings(client, tool, contextText, params, extraMetadata)
 }
 
 // src/tools.ts
+var LOG_LEVEL = (process.env.CONTEXTSTREAM_LOG_LEVEL || "normal").toLowerCase();
+var LOG_QUIET = LOG_LEVEL === "quiet";
+var LOG_VERBOSE = LOG_LEVEL === "verbose";
+var TOOL_DISPLAY_NAMES = {
+  session_init: "init",
+  session: "session",
+  context_smart: "context",
+  search: "search",
+  memory: "memory",
+  graph: "graph",
+  ai: "ai",
+  generate_rules: "rules",
+  generate_editor_rules: "rules",
+  help: "help",
+  workspace_bootstrap: "bootstrap",
+  workspace: "workspace",
+  github: "github",
+  slack: "slack",
+  notion: "notion",
+  jira: "jira",
+  ingest: "ingest",
+  // Hide internal tools
+  session_capture_smart: "",
+  session_restore_context: ""
+};
+function getToolDisplayName(toolName) {
+  if (toolName in TOOL_DISPLAY_NAMES) {
+    return TOOL_DISPLAY_NAMES[toolName];
+  }
+  return toolName.replace(/_/g, " ").replace(/^mcp__contextstream__/, "");
+}
+function logTool(toolName, status, details) {
+  if (LOG_QUIET && status !== "error") return;
+  const displayName = getToolDisplayName(toolName);
+  if (!displayName) return;
+  const icon = status === "start" ? "\u25E6" : status === "done" ? "\u2713" : "\u2717";
+  const message = details ? `${icon} ${displayName}: ${details}` : `${icon} ${displayName}`;
+  console.error(message);
+}
+function logSystem(message, level = "info") {
+  if (LOG_QUIET && level === "info") return;
+  const prefix = level === "error" ? "\u2717" : level === "warn" ? "!" : "\u2022";
+  console.error(`${prefix} ${message}`);
+}
+function logDebug(message) {
+  if (!LOG_VERBOSE) return;
+  console.error(`[DEBUG] ${message}`);
+}
 var LESSON_DEDUP_WINDOW_MS = 2 * 60 * 1e3;
 var recentLessonCaptures = /* @__PURE__ */ new Map();
 var SEARCH_RULES_REMINDER_ENABLED = process.env.CONTEXTSTREAM_SEARCH_REMINDER?.toLowerCase() !== "false";
@@ -10124,9 +10930,75 @@ BEFORE using EnterPlanMode/Task(Plan) \u2192 call mcp__contextstream__session(ac
 Local tools ONLY if ContextStream returns 0 results after retry.
 `.trim();
 var LESSONS_REMINDER_PREFIX = `
-\u26A0\uFE0F [LESSONS - REVIEW BEFORE CHANGES]
-Past mistakes found that may be relevant. STOP and review before proceeding:
+\u{1F6A8} [LESSONS_WARNING] Past Mistakes Found - READ BEFORE PROCEEDING!
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u26A0\uFE0F IMPORTANT: You MUST review these lessons and tell the user about relevant ones.
+These are mistakes from past sessions that you should NOT repeat.
 `.trim();
+var RISKY_ACTION_KEYWORDS = [
+  // Code changes
+  "refactor",
+  "rewrite",
+  "restructure",
+  "reorganize",
+  "migrate",
+  "delete",
+  "remove",
+  "drop",
+  "deprecate",
+  // Database
+  "database",
+  "migration",
+  "schema",
+  "sql",
+  // Deployment
+  "deploy",
+  "release",
+  "production",
+  "prod",
+  // API changes
+  "api",
+  "endpoint",
+  "breaking change",
+  // Architecture
+  "architecture",
+  "design",
+  "pattern",
+  // Testing
+  "test",
+  "testing",
+  // Security
+  "auth",
+  "security",
+  "permission",
+  "credential",
+  "access",
+  "token",
+  "secret",
+  // Version control
+  "git",
+  "commit",
+  "merge",
+  "rebase",
+  "push",
+  "force",
+  // Infrastructure
+  "config",
+  "environment",
+  "env",
+  "docker",
+  "kubernetes",
+  "k8s",
+  // Performance
+  "performance",
+  "optimize",
+  "cache",
+  "memory"
+];
+function detectRiskyActions(userMessage) {
+  const messageLower = userMessage.toLowerCase();
+  return RISKY_ACTION_KEYWORDS.filter((keyword) => messageLower.includes(keyword));
+}
 function generateLessonsReminder(result) {
   const lessons = result.lessons;
   if (!lessons || lessons.length === 0) {
@@ -10141,7 +11013,8 @@ function generateLessonsReminder(result) {
   return `
 
 ${LESSONS_REMINDER_PREFIX}
-${lessonLines.join("\n")}`;
+${lessonLines.join("\n")}
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`;
 }
 function generateRulesUpdateWarning(rulesNotice) {
   if (!rulesNotice || rulesNotice.status !== "behind" && rulesNotice.status !== "missing") {
@@ -10164,12 +11037,16 @@ function generateVersionUpdateWarning(versionNotice) {
     return "";
   }
   return `
-\u{1F6A8} [MCP SERVER OUTDATED - UPDATE RECOMMENDED]
-Current: ${versionNotice.current} \u2192 Latest: ${versionNotice.latest}
-New version may include critical bug fixes, performance improvements, and new features.
+\u{1F6A8} [VERSION_NOTICE] MCP Server Update Available!
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+Version: ${versionNotice.current} \u2192 ${versionNotice.latest}
+
+\u26A0\uFE0F IMPORTANT: You MUST tell the user about this update IMMEDIATELY.
+Do not proceed with other work until you have informed the user.
 
-**UPDATE NOW:** Run \`${versionNotice.upgrade_command || "npm update @contextstream/mcp-server"}\`
-Then restart Claude Code to use the new version.
+Update command: \`${versionNotice.upgrade_command || "npm update -g @contextstream/mcp-server"}\`
+After updating, restart the AI tool to use the new version.
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 `.trim();
 }
 var DEFAULT_PARAM_DESCRIPTIONS = {
@@ -10225,7 +11102,6 @@ var RULES_PROJECT_FILES = {
   codex: "AGENTS.md",
   claude: "CLAUDE.md",
   cursor: ".cursorrules",
-  windsurf: ".windsurfrules",
   cline: ".clinerules",
   kilo: path6.join(".kilocode", "rules", "contextstream.md"),
   roo: path6.join(".roo", "rules", "contextstream.md"),
@@ -10233,7 +11109,6 @@ var RULES_PROJECT_FILES = {
 };
 var RULES_GLOBAL_FILES = {
   codex: [path6.join(homedir3(), ".codex", "AGENTS.md")],
-  windsurf: [path6.join(homedir3(), ".codeium", "windsurf", "memories", "global_rules.md")],
   kilo: [path6.join(homedir3(), ".kilocode", "rules", "contextstream.md")],
   roo: [path6.join(homedir3(), ".roo", "rules", "contextstream.md")]
 };
@@ -10273,7 +11148,6 @@ function detectEditorFromClientName(clientName) {
   if (!clientName) return null;
   const normalized = clientName.toLowerCase().trim();
   if (normalized.includes("cursor")) return "cursor";
-  if (normalized.includes("windsurf") || normalized.includes("codeium")) return "windsurf";
   if (normalized.includes("claude")) return "claude";
   if (normalized.includes("cline")) return "cline";
   if (normalized.includes("kilo")) return "kilo";
@@ -10435,7 +11309,6 @@ var CONTEXTSTREAM_PREAMBLE_PATTERNS = [
   /^#\s+codex cli instructions$/i,
   /^#\s+claude code instructions$/i,
   /^#\s+cursor rules$/i,
-  /^#\s+windsurf rules$/i,
   /^#\s+cline rules$/i,
   /^#\s+kilo code rules$/i,
   /^#\s+roo code rules$/i,
@@ -11030,6 +11903,7 @@ var ALL_INTEGRATION_TOOLS = /* @__PURE__ */ new Set([
   ...CROSS_INTEGRATION_TOOLS
 ]);
 var AUTO_HIDE_INTEGRATIONS = process.env.CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS !== "false";
+var RESTORE_CONTEXT_DEFAULT = process.env.CONTEXTSTREAM_RESTORE_CONTEXT !== "false";
 var TOKEN_SENSITIVE_CLIENTS = /* @__PURE__ */ new Set([
   "claude",
   "claude-code",
@@ -11419,9 +12293,7 @@ function resolveToolFilter() {
   if (allowlistRaw) {
     const allowlist = parseToolList(allowlistRaw);
     if (allowlist.size === 0) {
-      console.error(
-        "[ContextStream] CONTEXTSTREAM_TOOL_ALLOWLIST is empty; using standard toolset."
-      );
+      logDebug("TOOL_ALLOWLIST is empty; using standard toolset");
       return { allowlist: STANDARD_TOOLSET, source: "standard", autoDetected: false };
     }
     return { allowlist, source: "allowlist", autoDetected: false };
@@ -11432,9 +12304,7 @@ function resolveToolFilter() {
     if (clientDetectedFromEnv && AUTO_TOOLSET_ENABLED) {
       const recommended = getRecommendedToolset(void 0, true);
       if (recommended) {
-        console.error(
-          "[ContextStream] Detected Claude Code via environment. Using light toolset for optimal token usage."
-        );
+        logDebug("Detected Claude Code, using light toolset");
         return { allowlist: recommended, source: "auto-claude", autoDetected: true };
       }
     }
@@ -11443,12 +12313,10 @@ function resolveToolFilter() {
   if (toolsetRaw.trim().toLowerCase() === "auto") {
     clientDetectedFromEnv = detectClaudeCodeFromEnv();
     if (clientDetectedFromEnv) {
-      console.error("[ContextStream] TOOLSET=auto: Detected Claude Code, using light toolset.");
+      logDebug("TOOLSET=auto: Detected Claude Code, using light toolset");
       return { allowlist: LIGHT_TOOLSET, source: "auto-claude", autoDetected: true };
     }
-    console.error(
-      "[ContextStream] TOOLSET=auto: Will adjust toolset based on MCP client (currently standard)."
-    );
+    logDebug("TOOLSET=auto: Will adjust based on MCP client");
     return { allowlist: STANDARD_TOOLSET, source: "auto-pending", autoDetected: true };
   }
   const key = toolsetRaw.trim().toLowerCase();
@@ -11459,9 +12327,7 @@ function resolveToolFilter() {
     }
     return { allowlist: resolved, source: key, autoDetected: false };
   }
-  console.error(
-    `[ContextStream] Unknown CONTEXTSTREAM_TOOLSET "${toolsetRaw}". Using standard toolset.`
-  );
+  logDebug(`Unknown TOOLSET "${toolsetRaw}"; using standard`);
   return { allowlist: STANDARD_TOOLSET, source: "standard", autoDetected: false };
 }
 function formatContent(data, forceFormat) {
@@ -11559,22 +12425,16 @@ function isDuplicateLessonCapture(signature) {
 }
 function setupClientDetection(server) {
   if (!AUTO_TOOLSET_ENABLED) {
-    console.error(
-      "[ContextStream] Auto-toolset: DISABLED (set CONTEXTSTREAM_AUTO_TOOLSET=true to enable)"
-    );
+    logDebug("Auto-toolset: DISABLED");
     return;
   }
   if (clientDetectedFromEnv) {
-    console.error(
-      "[ContextStream] Client detection: Already detected Claude Code from environment"
-    );
+    logDebug("Client detection: Already detected from environment");
     return;
   }
   const lowLevelServer = server.server;
   if (!lowLevelServer) {
-    console.error(
-      "[ContextStream] Warning: Could not access low-level MCP server for client detection"
-    );
+    logDebug("Warning: Could not access low-level MCP server for client detection");
     return;
   }
   lowLevelServer.oninitialized = () => {
@@ -11584,23 +12444,21 @@ function setupClientDetection(server) {
         detectedClientInfo = clientVersion;
         const clientName = clientVersion.name || "unknown";
         const clientVer = clientVersion.version || "unknown";
-        console.error(`[ContextStream] MCP Client detected: ${clientName} v${clientVer}`);
+        logDebug(`MCP Client detected: ${clientName} v${clientVer}`);
         if (isTokenSensitiveClient(clientName)) {
-          console.error(
-            "[ContextStream] Token-sensitive client detected. Consider using CONTEXTSTREAM_TOOLSET=light for optimal performance."
-          );
+          logDebug("Token-sensitive client detected");
           try {
             lowLevelServer.sendToolsListChanged?.();
-            console.error("[ContextStream] Emitted tools/list_changed notification");
+            logDebug("Emitted tools/list_changed notification");
           } catch (error) {
           }
         }
       }
     } catch (error) {
-      console.error("[ContextStream] Error in client detection callback:", error);
+      logSystem(`Error in client detection: ${error}`, "error");
     }
   };
-  console.error("[ContextStream] Client detection: Callback registered for MCP initialize");
+  logDebug("Client detection callback registered");
 }
 function registerTools(server, client, sessionManager) {
   const upgradeUrl2 = process.env.CONTEXTSTREAM_UPGRADE_URL || "https://contextstream.io/pricing";
@@ -11608,69 +12466,31 @@ function registerTools(server, client, sessionManager) {
   const toolAllowlist = toolFilter.allowlist;
   if (toolAllowlist) {
     const source = toolFilter.source;
-    const autoNote = toolFilter.autoDetected ? " (auto-detected)" : "";
-    const hint = source === "light" || source === "auto-claude" ? " Set CONTEXTSTREAM_TOOLSET=standard or complete for more tools." : source === "standard" ? " Set CONTEXTSTREAM_TOOLSET=complete for all tools." : source === "auto-pending" ? " Toolset may be adjusted when MCP client is detected." : "";
-    console.error(
-      `[ContextStream] Toolset: ${source} (${toolAllowlist.size} tools)${autoNote}.${hint}`
-    );
+    logDebug(`Toolset: ${source} (${toolAllowlist.size} tools)`);
   } else {
-    console.error(`[ContextStream] Toolset: complete (all tools).`);
+    logDebug("Toolset: complete (all tools)");
   }
   if (AUTO_TOOLSET_ENABLED) {
-    if (clientDetectedFromEnv) {
-      console.error("[ContextStream] Auto-toolset: ACTIVE (Claude Code detected from environment)");
-    } else {
-      console.error("[ContextStream] Auto-toolset: ENABLED (will detect MCP client on initialize)");
-    }
-  }
-  if (AUTO_HIDE_INTEGRATIONS) {
-    console.error(
-      `[ContextStream] Integration auto-hide: ENABLED (${ALL_INTEGRATION_TOOLS.size} tools hidden until integrations connected)`
-    );
-    console.error("[ContextStream] Set CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS=false to disable.");
-  } else {
-    console.error("[ContextStream] Integration auto-hide: disabled");
-  }
-  if (COMPACT_SCHEMA_ENABLED) {
-    console.error("[ContextStream] Schema mode: COMPACT (shorter descriptions, minimal params)");
-  } else {
-    console.error(
-      "[ContextStream] Schema mode: full (set CONTEXTSTREAM_SCHEMA_MODE=compact to reduce token overhead)"
-    );
-  }
-  if (PROGRESSIVE_MODE) {
-    const coreBundle = TOOL_BUNDLES.core;
-    console.error(
-      `[ContextStream] Progressive mode: ENABLED (starting with ${coreBundle.size} core tools)`
-    );
-    console.error(
-      "[ContextStream] Use tools_enable_bundle to unlock additional tool bundles dynamically."
-    );
-  }
-  if (ROUTER_MODE) {
-    console.error(
-      "[ContextStream] Router mode: ENABLED (all operations accessed via contextstream/contextstream_help)"
-    );
-    console.error(
-      "[ContextStream] Only 2 tools registered. Use contextstream_help to see available operations."
-    );
+    logDebug(clientDetectedFromEnv ? "Auto-toolset: ACTIVE" : "Auto-toolset: ENABLED");
   }
-  if (COMPACT_OUTPUT) {
-    console.error(
-      "[ContextStream] Output format: COMPACT (minified JSON, ~30% fewer tokens per response)"
-    );
+  if (AUTO_HIDE_INTEGRATIONS) {
+    logDebug(`Integration auto-hide: ENABLED (${ALL_INTEGRATION_TOOLS.size} tools hidden)`);
+  }
+  if (COMPACT_SCHEMA_ENABLED) {
+    logDebug("Schema mode: COMPACT");
   } else {
-    console.error(
-      "[ContextStream] Output format: pretty (set CONTEXTSTREAM_OUTPUT_FORMAT=compact for fewer tokens)"
-    );
+    logDebug("Schema mode: full");
+  }
+  if (PROGRESSIVE_MODE) {
+    const coreBundle = TOOL_BUNDLES.core;
+    logDebug(`Progressive mode: ENABLED (${coreBundle.size} core tools)`);
+  }
+  if (ROUTER_MODE) {
+    logDebug("Router mode: ENABLED");
   }
+  logDebug(COMPACT_OUTPUT ? "Output: COMPACT" : "Output: pretty");
   if (CONSOLIDATED_MODE) {
-    console.error(
-      `[ContextStream] Consolidated mode: ENABLED (~${CONSOLIDATED_TOOLS.size} domain tools, ~75% token reduction)`
-    );
-    console.error("[ContextStream] Set CONTEXTSTREAM_CONSOLIDATED=false to use individual tools.");
-  } else {
-    console.error("[ContextStream] Consolidated mode: disabled (using individual tools)");
+    logDebug(`Consolidated mode: ENABLED (~${CONSOLIDATED_TOOLS.size} domain tools)`);
   }
   const serverRef = server;
   const defaultProTools = /* @__PURE__ */ new Set([
@@ -11789,12 +12609,10 @@ function registerTools(server, client, sessionManager) {
         notion: notionConnected,
         workspaceId
       };
-      console.error(
-        `[ContextStream] Integration status: Slack=${slackConnected}, GitHub=${githubConnected}, Notion=${notionConnected}`
-      );
+      logDebug(`Integrations: Slack=${slackConnected}, GitHub=${githubConnected}, Notion=${notionConnected}`);
       return { slack: slackConnected, github: githubConnected, notion: notionConnected };
     } catch (error) {
-      console.error("[ContextStream] Failed to check integration status:", error);
+      logDebug(`Failed to check integration status: ${error}`);
       return { slack: false, github: false, notion: false };
     }
   }
@@ -11815,11 +12633,9 @@ function registerTools(server, client, sessionManager) {
         try {
           server.server?.sendToolsListChanged?.();
           toolsListChangedNotified = true;
-          console.error(
-            "[ContextStream] Emitted tools/list_changed notification (integrations detected)"
-          );
+          logDebug("Emitted tools/list_changed notification (integrations detected)");
         } catch (error) {
-          console.error("[ContextStream] Failed to emit tools/list_changed:", error);
+          logDebug(`Failed to emit tools/list_changed: ${error}`);
         }
       }
     }
@@ -12087,7 +12903,7 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
       lowLevelServer.sendToolsListChanged?.();
     } catch {
     }
-    console.error(`[ContextStream] Bundle '${bundleName}' enabled with ${toolsEnabled} tools.`);
+    logSystem(`bundle '${bundleName}' enabled (${toolsEnabled} tools)`);
     return {
       success: true,
       message: `Enabled bundle '${bundleName}' with ${toolsEnabled} tools.`,
@@ -12196,33 +13012,27 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
         if (options.preflight) {
           const fileCheck = await countIndexableFiles(resolvedPath, { maxFiles: 1 });
           if (fileCheck.count === 0) {
-            console.error(
-              `[ContextStream] No indexable files found in ${resolvedPath}. Skipping ingest.`
-            );
+            logDebug(`No indexable files in ${resolvedPath}`);
             return;
           }
         }
         let totalIndexed = 0;
         let batchCount = 0;
-        console.error(
-          `[ContextStream] Starting background ingestion for project ${projectId} from ${resolvedPath}`
-        );
+        logTool("ingest", "start", `indexing ${resolvedPath}`);
         for await (const batch of readAllFilesInBatches(resolvedPath, { batchSize: 50 })) {
           const result = await client.ingestFiles(projectId, batch, ingestOptions);
           totalIndexed += result.data?.files_indexed ?? batch.length;
           batchCount++;
         }
-        console.error(
-          `[ContextStream] Completed background ingestion: ${totalIndexed} files in ${batchCount} batches`
-        );
+        logTool("ingest", "done", `${totalIndexed} files`);
         try {
           await markProjectIndexed(resolvedPath, { project_id: projectId });
-          console.error(`[ContextStream] Marked project as indexed: ${resolvedPath}`);
+          logDebug(`Marked project as indexed: ${resolvedPath}`);
         } catch (markError) {
-          console.error(`[ContextStream] Failed to mark project as indexed:`, markError);
+          logDebug(`Failed to mark project as indexed: ${markError}`);
         }
       } catch (error) {
-        console.error(`[ContextStream] Ingestion failed:`, error);
+        logTool("ingest", "error", `${error}`);
       }
     })();
   }
@@ -12467,9 +13277,7 @@ Use contextstream_help({}) to see available operations.`
         };
       }
     );
-    console.error(
-      `[ContextStream] Router mode: Registered 2 meta-tools, ${operationsRegistry.size} operations available via dispatcher.`
-    );
+    logDebug(`Router mode: 2 meta-tools, ${operationsRegistry.size} operations`);
   }
   registerTool(
     "workspaces_list",
@@ -12629,7 +13437,7 @@ Access: Free`,
             rulesSkipped = ruleResults.filter((r) => r.status.startsWith("skipped")).map((r) => r.filename);
           }
         } catch (err) {
-          console.error("[ContextStream] Failed to write project config:", err);
+          logDebug(`Failed to write project config: ${err}`);
         }
       }
       const response = {
@@ -13145,10 +13953,7 @@ Access: Free`,
         const stats = await client.projectStatistics(projectId);
         estimate = estimateGraphIngestMinutes(stats);
       } catch (error) {
-        console.error(
-          "[ContextStream] Failed to fetch project statistics for graph ingest estimate:",
-          error
-        );
+        logDebug(`Failed to fetch project statistics for graph estimate: ${error}`);
       }
       const result = await client.graphIngest({ project_id: projectId, wait });
       const estimateText = estimate ? `Estimated time: ${estimate.min}-${estimate.max} min${estimate.basis ? ` (based on ${estimate.basis})` : ""}.` : "Estimated time varies with repo size.";
@@ -13824,7 +14629,7 @@ This does semantic search on the first message. You only need context_smart on s
           "If true, skip automatic project creation/matching. Use for parent folders containing multiple projects where you want workspace-level context but no project-specific context."
         ),
         is_post_compact: external_exports.boolean().optional().describe(
-          "Set to true when resuming after conversation compaction. This prioritizes session_snapshot restoration and recent decisions."
+          "Controls context restoration from recent snapshots. Defaults to true (always restores). Set to false to skip restoration. Can also be controlled via CONTEXTSTREAM_RESTORE_CONTEXT environment variable."
         )
       })
     },
@@ -13845,19 +14650,22 @@ This does semantic search on the first message. You only need context_smart on s
       }
       const result = await client.initSession(input, ideRoots);
       result.tools_hint = getCoreToolsHint();
-      if (input.is_post_compact) {
+      const shouldRestoreContext = input.is_post_compact ?? RESTORE_CONTEXT_DEFAULT;
+      if (shouldRestoreContext) {
+        result.is_post_compact = true;
         const workspaceIdForRestore = typeof result.workspace_id === "string" ? result.workspace_id : void 0;
         const projectIdForRestore = typeof result.project_id === "string" ? result.project_id : void 0;
         if (workspaceIdForRestore) {
           try {
-            const snapshotSearch = await client.searchEvents({
+            const listResult = await client.listMemoryEvents({
               workspace_id: workspaceIdForRestore,
               project_id: projectIdForRestore,
-              query: "session_snapshot",
-              event_types: ["session_snapshot"],
-              limit: 1
+              limit: 50
             });
-            const snapshots = snapshotSearch?.data?.results || snapshotSearch?.results || snapshotSearch?.data || [];
+            const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
+            const snapshots = allEvents.filter(
+              (e) => e.event_type === "session_snapshot" || e.metadata?.original_type === "session_snapshot" || e.metadata?.tags?.includes("session_snapshot") || e.tags?.includes("session_snapshot")
+            );
             if (snapshots && snapshots.length > 0) {
               const latestSnapshot = snapshots[0];
               let snapshotData;
@@ -13866,19 +14674,58 @@ This does semantic search on the first message. You only need context_smart on s
               } catch {
                 snapshotData = { conversation_summary: latestSnapshot.content };
               }
+              const prevSessionId = snapshotData.session_id || latestSnapshot.session_id;
+              const sessionLinking = {};
+              if (prevSessionId) {
+                sessionLinking.previous_session_id = prevSessionId;
+                const workingOn = [];
+                const activeFiles = snapshotData.active_files;
+                const lastTools = snapshotData.last_tools;
+                if (activeFiles && activeFiles.length > 0) {
+                  workingOn.push(`Files: ${activeFiles.slice(0, 5).join(", ")}${activeFiles.length > 5 ? ` (+${activeFiles.length - 5} more)` : ""}`);
+                }
+                if (lastTools && lastTools.length > 0) {
+                  const toolCounts = lastTools.reduce((acc, tool) => {
+                    acc[tool] = (acc[tool] || 0) + 1;
+                    return acc;
+                  }, {});
+                  const topTools = Object.entries(toolCounts).sort(([, a], [, b]) => b - a).slice(0, 3).map(([tool]) => tool);
+                  workingOn.push(`Recent tools: ${topTools.join(", ")}`);
+                }
+                if (workingOn.length > 0) {
+                  sessionLinking.previous_session_summary = workingOn.join("; ");
+                }
+                const relatedSessionIds = /* @__PURE__ */ new Set();
+                snapshots.forEach((s) => {
+                  let sData;
+                  try {
+                    sData = JSON.parse(s.content || "{}");
+                  } catch {
+                    sData = {};
+                  }
+                  const sSessionId = sData.session_id || s.session_id;
+                  if (sSessionId && sSessionId !== prevSessionId) {
+                    relatedSessionIds.add(sSessionId);
+                  }
+                });
+                if (relatedSessionIds.size > 0) {
+                  sessionLinking.related_sessions = Array.from(relatedSessionIds);
+                }
+              }
               result.restored_context = {
                 snapshot_id: latestSnapshot.id,
                 captured_at: snapshotData.captured_at || latestSnapshot.created_at,
+                session_linking: Object.keys(sessionLinking).length > 0 ? sessionLinking : void 0,
                 ...snapshotData
               };
               result.is_post_compact = true;
-              result.post_compact_hint = "Session restored from pre-compaction snapshot. Review the 'restored_context' to continue where you left off.";
+              result.post_compact_hint = prevSessionId ? `Session restored from session ${prevSessionId}. Review 'restored_context' to continue where you left off.` : "Session restored from pre-compaction snapshot. Review the 'restored_context' to continue where you left off.";
             } else {
               result.is_post_compact = true;
               result.post_compact_hint = "Post-compaction session started, but no snapshots found. Use context_smart to retrieve relevant context.";
             }
           } catch (err) {
-            console.error("[ContextStream] Failed to restore post-compact context:", err);
+            logDebug(`Failed to restore post-compact context: ${err}`);
             result.is_post_compact = true;
             result.post_compact_hint = "Post-compaction session started. Snapshot restoration failed, use context_smart for context.";
           }
@@ -13919,10 +14766,7 @@ This does semantic search on the first message. You only need context_smart on s
             hint: intStatus.slack || intStatus.github ? "Integration tools are now available in the tool list." : "Connect integrations at https://contextstream.io/settings/integrations to enable Slack/GitHub tools."
           };
         } catch (error) {
-          console.error(
-            "[ContextStream] Failed to check integration status in session_init:",
-            error
-          );
+          logDebug(`Failed to check integration status: ${error}`);
         }
       }
       result.modes = {
@@ -14017,7 +14861,7 @@ ${benefitsList}` : "",
         const projectId = typeof result.project_id === "string" ? result.project_id : void 0;
         const projectName = typeof result.project_name === "string" ? result.project_name : void 0;
         markProjectIndexed(folderPathForRules, { project_id: projectId, project_name: projectName }).catch(
-          (err) => console.error("[ContextStream] Failed to mark project as indexed:", err)
+          (err) => logDebug(`Failed to mark project as indexed: ${err}`)
         );
       }
       if (noticeLines.length > 0) {
@@ -14133,7 +14977,7 @@ Optionally generates AI editor rules for automatic ContextStream usage.`,
         workspace_name: external_exports.string().optional().describe("Workspace name for reference"),
         create_parent_mapping: external_exports.boolean().optional().describe("Also create a parent folder mapping (e.g., /dev/maker/* -> workspace)"),
         generate_editor_rules: external_exports.boolean().optional().describe(
-          "Generate AI editor rules for Windsurf, Cursor, Cline, Kilo Code, Roo Code, Claude Code, and Aider"
+          "Generate AI editor rules for Cursor, Cline, Kilo Code, Roo Code, Claude Code, and Aider"
         ),
         overwrite_existing: external_exports.boolean().optional().describe("Allow overwriting existing rule files when generating editor rules")
       })
@@ -14545,14 +15389,16 @@ Use this in combination with session_init(is_post_compact=true) for seamless con
             structuredContent: toStructured(response2)
           };
         }
-        const searchResult = await client.searchEvents({
+        const listResult = await client.listMemoryEvents({
           workspace_id: workspaceId,
           project_id: projectId,
-          query: "session_snapshot",
-          event_types: ["session_snapshot"],
-          limit: input.max_snapshots || 1
+          limit: 50
+          // Fetch more to filter
         });
-        const events = searchResult?.data?.results || searchResult?.results || searchResult?.data || [];
+        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);
         if (!events || events.length === 0) {
           return {
             content: [
@@ -14923,7 +15769,7 @@ Example: "What were the auth decisions?" or "What are my TypeScript preferences?
     "generate_rules",
     {
       title: "Generate ContextStream rules",
-      description: `Generate AI rule files for editors (Windsurf, Cursor, Cline, Kilo Code, Roo Code, Claude Code, Aider).
+      description: `Generate AI rule files for editors (Cursor, Cline, Kilo Code, Roo Code, Claude Code, Aider).
 Defaults to the current project folder; no folder_path required when run from a project.
 Supported editors: ${getAvailableEditors().join(", ")}`,
       inputSchema: external_exports.object({
@@ -14931,7 +15777,6 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
         editors: external_exports.array(
           external_exports.enum([
             "codex",
-            "windsurf",
             "cursor",
             "cline",
             "kilo",
@@ -15020,34 +15865,70 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
       const globalPrompt = input.apply_global ? "Global rule update complete." : globalTargets.length > 0 ? "Apply rules globally too? Re-run with apply_global: true." : "No global rule locations are known for these editors.";
       let hooksResults;
       let hooksPrompt;
-      const hasClaude = editors.includes("claude");
-      const shouldInstallHooks = hasClaude && input.install_hooks !== false;
+      const editorHookMap = {
+        claude: "claude",
+        cline: "cline",
+        roo: "roo",
+        kilo: "kilo",
+        cursor: "cursor"
+      };
+      const hookSupportedEditors = editors.filter((e) => e in editorHookMap);
+      const shouldInstallHooks = hookSupportedEditors.length > 0 && input.install_hooks !== false;
       if (shouldInstallHooks) {
         try {
           if (input.dry_run) {
-            hooksResults = [
-              { file: "~/.claude/hooks/contextstream-redirect.py", status: "dry run - would create" },
-              { file: "~/.claude/hooks/contextstream-reminder.py", status: "dry run - would create" },
-              { file: "~/.claude/settings.json", status: "dry run - would update" }
-            ];
-            if (input.include_pre_compact) {
-              hooksResults.push({ file: "~/.claude/hooks/contextstream-precompact.py", status: "dry run - would create" });
+            hooksResults = [];
+            for (const editor of hookSupportedEditors) {
+              if (editor === "claude") {
+                hooksResults.push(
+                  { editor, file: "~/.claude/hooks/contextstream-redirect.py", status: "dry run - would create" },
+                  { editor, file: "~/.claude/hooks/contextstream-reminder.py", status: "dry run - would create" },
+                  { editor, file: "~/.claude/settings.json", status: "dry run - would update" }
+                );
+                if (input.include_pre_compact) {
+                  hooksResults.push({ editor, file: "~/.claude/hooks/contextstream-precompact.py", status: "dry run - would create" });
+                }
+              } else if (editor === "cline") {
+                hooksResults.push(
+                  { editor, file: "~/Documents/Cline/Rules/Hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/Documents/Cline/Rules/Hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "roo") {
+                hooksResults.push(
+                  { editor, file: "~/.roo/hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/.roo/hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "kilo") {
+                hooksResults.push(
+                  { editor, file: "~/.kilocode/hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/.kilocode/hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "cursor") {
+                hooksResults.push(
+                  { editor, file: "~/.cursor/hooks/contextstream-pretooluse.py", status: "dry run - would create" },
+                  { editor, file: "~/.cursor/hooks/contextstream-beforesubmit.py", status: "dry run - would create" },
+                  { editor, file: "~/.cursor/hooks.json", status: "dry run - would update" }
+                );
+              }
             }
           } else {
-            const hookResult = await installClaudeCodeHooks({
-              scope: "user",
+            hooksResults = [];
+            const allHookResults = await installAllEditorHooks({
+              scope: "global",
+              editors: hookSupportedEditors,
               includePreCompact: input.include_pre_compact
             });
-            hooksResults = [
-              ...hookResult.scripts.map((f) => ({ file: f, status: "created" })),
-              ...hookResult.settings.map((f) => ({ file: f, status: "updated" }))
-            ];
+            for (const result of allHookResults) {
+              for (const file of result.installed) {
+                hooksResults.push({ editor: result.editor, file, status: "created" });
+              }
+            }
           }
         } catch (err) {
           hooksResults = [{ file: "hooks", status: `error: ${err.message}` }];
         }
-      } else if (hasClaude && input.install_hooks === false) {
-        hooksPrompt = "Hooks skipped. Claude may use default tools instead of ContextStream search.";
+      } else if (hookSupportedEditors.length > 0 && input.install_hooks === false) {
+        hooksPrompt = "Hooks skipped. AI may use default tools instead of ContextStream search.";
       }
       const summary = {
         folder: folderPath,
@@ -15069,7 +15950,7 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
     "generate_editor_rules",
     {
       title: "Generate editor AI rules",
-      description: `Generate AI rule files for editors (Windsurf, Cursor, Cline, Kilo Code, Roo Code, Claude Code, Aider).
+      description: `Generate AI rule files for editors (Cursor, Cline, Kilo Code, Roo Code, Claude Code, Aider).
 These rules instruct the AI to automatically use ContextStream for memory and context.
 Supported editors: ${getAvailableEditors().join(", ")}`,
       inputSchema: external_exports.object({
@@ -15077,7 +15958,6 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
         editors: external_exports.array(
           external_exports.enum([
             "codex",
-            "windsurf",
             "cursor",
             "cline",
             "kilo",
@@ -15426,6 +16306,52 @@ This saves ~80% tokens compared to including full chat history.`,
         }
         sessionManager.addTokens(input.user_message);
       }
+      let postCompactContext = "";
+      let postCompactRestored = false;
+      if (sessionManager && sessionManager.shouldRestorePostCompact() && workspaceId) {
+        try {
+          const listResult = await client.listMemoryEvents({
+            workspace_id: workspaceId,
+            project_id: projectId,
+            limit: 20
+          });
+          const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
+          const snapshotEvent = allEvents.find(
+            (e) => e.event_type === "session_snapshot" || e.metadata?.original_type === "session_snapshot" || e.tags?.includes("session_snapshot")
+          );
+          if (snapshotEvent && snapshotEvent.content) {
+            let snapshotData;
+            try {
+              snapshotData = JSON.parse(snapshotEvent.content);
+            } catch {
+              snapshotData = { conversation_summary: snapshotEvent.content };
+            }
+            const summary = snapshotData.conversation_summary || snapshotData.summary || "";
+            const decisions = snapshotData.key_decisions || [];
+            const unfinished = snapshotData.unfinished_work || snapshotData.pending_tasks || [];
+            const files = snapshotData.active_files || [];
+            const parts = [];
+            parts.push("\u{1F4CB} [POST-COMPACTION CONTEXT RESTORED]");
+            if (summary) parts.push(`Summary: ${summary}`);
+            if (Array.isArray(decisions) && decisions.length > 0) {
+              parts.push(`Decisions: ${decisions.slice(0, 5).join("; ")}`);
+            }
+            if (Array.isArray(unfinished) && unfinished.length > 0) {
+              parts.push(`Unfinished: ${unfinished.slice(0, 3).join("; ")}`);
+            }
+            if (Array.isArray(files) && files.length > 0) {
+              parts.push(`Active files: ${files.slice(0, 5).join(", ")}`);
+            }
+            parts.push("---");
+            postCompactContext = parts.join("\n") + "\n\n";
+            postCompactRestored = true;
+            sessionManager.markPostCompactRestoreCompleted();
+            logSystem("context restored");
+          }
+        } catch (err) {
+          logDebug(`Failed to restore post-compact context: ${err}`);
+        }
+      }
       const result = await client.getSmartContext({
         user_message: input.user_message,
         workspace_id: workspaceId,
@@ -15466,8 +16392,44 @@ This saves ~80% tokens compared to including full chat history.`,
         project_id: projectId,
         max_tokens: input.max_tokens
       });
-      const hasLessons = result.context.includes("|L:") || result.context.includes("L:") || result.context.toLowerCase().includes("lesson");
-      const lessonsWarningLine = hasLessons ? "\n\n\u26A0\uFE0F [LESSONS DETECTED] Review the L: items above - these are past mistakes. STOP and review before making similar changes." : "";
+      let lessonsWarningLine = "";
+      const riskyKeywords = detectRiskyActions(input.user_message);
+      if (riskyKeywords.length > 0 && workspaceId) {
+        try {
+          const lessons = await client.getHighPriorityLessons({
+            workspace_id: workspaceId,
+            project_id: projectId,
+            context_hint: riskyKeywords.join(" "),
+            limit: 5
+          });
+          if (lessons.length > 0) {
+            const lessonLines = lessons.slice(0, 5).map((l, i) => {
+              const severity = l.severity === "critical" ? "\u{1F6A8}" : l.severity === "high" ? "\u26A0\uFE0F" : "\u{1F4DD}";
+              const title = l.title || "Untitled lesson";
+              const prevention = l.prevention || "";
+              return `${i + 1}. ${severity} ${title}${prevention ? `: ${prevention.slice(0, 100)}` : ""}`;
+            });
+            lessonsWarningLine = `
+
+\u{1F6A8} [LESSONS_WARNING] Relevant Lessons for "${riskyKeywords.slice(0, 3).join(", ")}"
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u26A0\uFE0F IMPORTANT: You MUST tell the user about these lessons before proceeding.
+These are past mistakes that may be relevant to the current task.
+
+${lessonLines.join("\n")}
+
+Action: Review each lesson and explain to the user how you will avoid these mistakes.
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`;
+          }
+        } catch {
+        }
+      }
+      if (!lessonsWarningLine) {
+        const hasLessonsInContext = result.context.includes("|L:") || result.context.includes("L:") || result.context.toLowerCase().includes("lesson");
+        if (hasLessonsInContext) {
+          lessonsWarningLine = "\n\n\u26A0\uFE0F [LESSONS_WARNING] Lessons found in context - review the L: items above before making changes.";
+        }
+      }
       const searchRulesLine = SEARCH_RULES_REMINDER_ENABLED ? `
 
 ${SEARCH_RULES_REMINDER}` : "";
@@ -15475,20 +16437,29 @@ ${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)
 Action: ${cp.suggested_action === "prepare_save" ? "Consider saving important decisions and conversation state soon." : cp.suggested_action}`;
         }
       }
+      const serverWarnings = result.warnings || [];
+      const serverWarningsLine = serverWarnings.length > 0 ? "\n\n" + serverWarnings.map((w) => `\u26A0\uFE0F ${w}`).join("\n") : "";
       const allWarnings = [
-        lessonsWarningLine,
+        serverWarningsLine || lessonsWarningLine,
+        // Server warnings OR client-side lesson detection
         rulesWarningLine ? `
 
 ${rulesWarningLine}` : "",
@@ -15498,14 +16469,16 @@ ${versionWarningLine}` : "",
         contextPressureWarning,
         searchRulesLine
       ].filter(Boolean).join("");
+      const finalContext = postCompactContext + result.context;
+      const enrichedResultWithRestore = postCompactRestored ? { ...enrichedResult, post_compact_restored: true } : enrichedResult;
       return {
         content: [
           {
             type: "text",
-            text: result.context + footer + allWarnings
+            text: finalContext + footer + allWarnings
           }
         ],
-        structuredContent: toStructured(enrichedResult)
+        structuredContent: toStructured(enrichedResultWithRestore)
       };
     }
   );
@@ -16097,6 +17070,8 @@ Returns: the created page ID, URL, title, and timestamps.
 Use this to save notes, documentation, or any content to Notion.
 Supports Markdown content which is automatically converted to Notion blocks.
 
+IMPORTANT: If using parent_database_id, you MUST call integration(provider="notion", action="list_databases") FIRST to get valid database IDs. Do NOT use database IDs from memory or previous conversations - they may be stale or inaccessible.
+
 Example prompts:
 - "Create a Notion page with today's meeting notes"
 - "Save this documentation to Notion"
@@ -16106,7 +17081,7 @@ Example prompts:
         project_id: external_exports.string().uuid().optional().describe("Project ID (uses session default if not provided). If provided, the memory event will be scoped to this project."),
         title: external_exports.string().describe("Page title"),
         content: external_exports.string().optional().describe("Page content in Markdown format"),
-        parent_database_id: external_exports.string().optional().describe("Parent database ID to create page in"),
+        parent_database_id: external_exports.string().optional().describe("Parent database ID. MUST call integration(provider='notion', action='list_databases') first to get valid IDs - do NOT use IDs from memory"),
         parent_page_id: external_exports.string().optional().describe("Parent page ID to create page under")
       })
     },
@@ -16574,7 +17549,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). 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), 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).`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "capture",
@@ -16592,7 +17567,9 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "capture_plan",
             "get_plan",
             "update_plan",
-            "list_plans"
+            "list_plans",
+            // Context restore
+            "restore_context"
           ]).describe("Action to perform"),
           workspace_id: external_exports.string().uuid().optional(),
           project_id: external_exports.string().uuid().optional(),
@@ -16614,7 +17591,8 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "lesson",
             "warning",
             "frustration",
-            "conversation"
+            "conversation",
+            "session_snapshot"
           ]).optional().describe("Event type for capture"),
           importance: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
           tags: external_exports.array(external_exports.string()).optional(),
@@ -16664,7 +17642,10 @@ 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")
+          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)")
         })
       },
       async (input) => {
@@ -16970,6 +17951,143 @@ 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}`);
         }
@@ -18079,7 +19197,7 @@ ${formatContent(result)}`
           title: external_exports.string().optional().describe("Page/database title (for Notion create_page/update_page/create_database)"),
           content: external_exports.string().optional().describe("Page content in Markdown (for Notion create_page/update_page)"),
           description: external_exports.string().optional().describe("Database description (for Notion create_database)"),
-          parent_database_id: external_exports.string().optional().describe("Parent database ID (for Notion create_page)"),
+          parent_database_id: external_exports.string().optional().describe("Parent database ID (for Notion create_page). MUST call list_databases first - do NOT use IDs from memory"),
           parent_page_id: external_exports.string().optional().describe("Parent page ID (for Notion create_page/create_database)"),
           page_id: external_exports.string().optional().describe("Page ID (for Notion get_page/update_page)"),
           database_id: external_exports.string().optional().describe("Database ID (for Notion query_database/search_pages/activity)"),
@@ -18673,9 +19791,7 @@ Each domain tool has an 'action' parameter for specific operations.` : "";
         }
       }
     );
-    console.error(
-      `[ContextStream] Consolidated mode: Registered ${CONSOLIDATED_TOOLS.size} domain tools.`
-    );
+    logDebug(`Consolidated mode: ${CONSOLIDATED_TOOLS.size} domain tools`);
   }
 }
 function registerLimitedTools(server) {
@@ -18710,7 +19826,7 @@ After setup, restart your editor to enable all ContextStream tools.`
       };
     }
   );
-  console.error("[ContextStream] Limited mode: Registered setup helper tool only.");
+  logSystem("limited mode (run setup)");
 }
 
 // src/resources.ts
@@ -19492,7 +20608,7 @@ function registerPrompts(server) {
               "First:",
               "- If you can infer the project folder path from the environment/IDE roots, use it.",
               "- Otherwise ask me for an absolute folder path.",
-              "- Ask which editor(s) (codex,windsurf,cursor,cline,kilo,roo,claude,aider,antigravity) or default to all.",
+              "- Ask which editor(s) (codex,cursor,cline,kilo,roo,claude,aider,antigravity) or default to all.",
               "",
               "Then call `generate_rules` and confirm which files were created/updated.",
               "Ask if the user also wants to apply rules globally (pass apply_global: true)."
@@ -19534,8 +20650,7 @@ function registerPrompts(server) {
 }
 
 // src/session-manager.ts
-var SessionManager = class {
-  // Conservative default for 100k context window
+var SessionManager = class _SessionManager {
   constructor(server, client) {
     this.server = server;
     this.client = client;
@@ -19547,8 +20662,30 @@ var SessionManager = class {
     this.contextSmartCalled = false;
     this.warningShown = false;
     // Token tracking for context pressure calculation
+    // Note: MCP servers cannot see actual token usage (AI responses, thinking, system prompts).
+    // We use a heuristic: tracked tokens + (turns * estimated tokens per turn)
     this.sessionTokens = 0;
     this.contextThreshold = 7e4;
+    // Conservative default for 100k context window
+    this.conversationTurns = 0;
+    // Continuous checkpointing
+    this.toolCallCount = 0;
+    this.checkpointInterval = 20;
+    // Save checkpoint every N tool calls
+    this.lastCheckpointAt = 0;
+    this.activeFiles = /* @__PURE__ */ new Set();
+    this.recentToolCalls = [];
+    this.checkpointEnabled = process.env.CONTEXTSTREAM_CHECKPOINT_ENABLED?.toLowerCase() === "true";
+    // Post-compaction restoration tracking
+    // Tracks when context pressure was high/critical so we can detect post-compaction state
+    this.lastHighPressureAt = null;
+    this.lastHighPressureTokens = 0;
+    this.postCompactRestoreCompleted = false;
+  }
+  static {
+    // Each conversation turn typically includes: user message (~500), AI response (~1500),
+    // system prompt overhead (~500), and reasoning (~1500). Conservative estimate: 3000/turn
+    this.TOKENS_PER_TURN_ESTIMATE = 3e3;
   }
   /**
    * Check if session has been auto-initialized
@@ -19591,17 +20728,40 @@ var SessionManager = class {
     this.folderPath = path9;
   }
   /**
-   * Mark that context_smart has been called in this session
+   * Mark that context_smart has been called in this session.
+   * Also increments the conversation turn counter for token estimation.
    */
   markContextSmartCalled() {
     this.contextSmartCalled = true;
+    this.conversationTurns++;
   }
   /**
    * Get current session token count for context pressure calculation.
+   *
+   * This returns an ESTIMATED count based on:
+   * 1. Tokens tracked through ContextStream tools (actual)
+   * 2. Estimated tokens per conversation turn (heuristic)
+   *
+   * Note: MCP servers cannot see actual AI token usage (responses, thinking,
+   * system prompts). This estimate helps provide a more realistic context
+   * pressure signal.
    */
   getSessionTokens() {
+    const turnEstimate = this.conversationTurns * _SessionManager.TOKENS_PER_TURN_ESTIMATE;
+    return this.sessionTokens + turnEstimate;
+  }
+  /**
+   * Get the raw tracked tokens (without turn-based estimation).
+   */
+  getRawTrackedTokens() {
     return this.sessionTokens;
   }
+  /**
+   * Get the current conversation turn count.
+   */
+  getConversationTurns() {
+    return this.conversationTurns;
+  }
   /**
    * Get the context threshold (max tokens before compaction warning).
    */
@@ -19640,6 +20800,52 @@ var SessionManager = class {
    */
   resetTokenCount() {
     this.sessionTokens = 0;
+    this.conversationTurns = 0;
+  }
+  /**
+   * Record that context pressure is high/critical.
+   * Called when context_smart returns high or critical pressure level.
+   */
+  markHighContextPressure() {
+    this.lastHighPressureAt = Date.now();
+    this.lastHighPressureTokens = this.getSessionTokens();
+  }
+  /**
+   * Check if we should attempt post-compaction restoration.
+   *
+   * Detection heuristic:
+   * 1. We recorded high/critical context pressure recently (within 10 minutes)
+   * 2. Current token count is very low (< 5000) compared to when pressure was high
+   * 3. We haven't already restored in this session
+   *
+   * This indicates compaction likely happened and we should restore context.
+   */
+  shouldRestorePostCompact() {
+    if (this.postCompactRestoreCompleted) {
+      return false;
+    }
+    if (!this.lastHighPressureAt) {
+      return false;
+    }
+    const elapsed = Date.now() - this.lastHighPressureAt;
+    if (elapsed > 10 * 60 * 1e3) {
+      return false;
+    }
+    const currentTokens = this.getSessionTokens();
+    const tokenDrop = this.lastHighPressureTokens - currentTokens;
+    if (currentTokens > 1e4 || tokenDrop < this.lastHighPressureTokens * 0.5) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Mark post-compaction restoration as completed.
+   * Prevents multiple restoration attempts in the same session.
+   */
+  markPostCompactRestoreCompleted() {
+    this.postCompactRestoreCompleted = true;
+    this.lastHighPressureAt = null;
+    this.lastHighPressureTokens = 0;
   }
   /**
    * Check if context_smart has been called and warn if not.
@@ -19905,6 +21111,112 @@ var SessionManager = class {
     parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
     return parts.join("\n");
   }
+  // =========================================================================
+  // Continuous Checkpointing
+  // =========================================================================
+  /**
+   * Track a tool call for checkpointing purposes.
+   * Call this after each tool execution to track files and trigger periodic checkpoints.
+   */
+  trackToolCall(toolName, input) {
+    this.toolCallCount++;
+    this.recentToolCalls.push({ name: toolName, timestamp: Date.now() });
+    if (this.recentToolCalls.length > 50) {
+      this.recentToolCalls = this.recentToolCalls.slice(-50);
+    }
+    if (input) {
+      const filePath = input.file_path || input.notebook_path || input.path;
+      if (filePath && typeof filePath === "string") {
+        this.activeFiles.add(filePath);
+        if (this.activeFiles.size > 30) {
+          const arr = Array.from(this.activeFiles);
+          this.activeFiles = new Set(arr.slice(-30));
+        }
+      }
+    }
+    this.maybeCheckpoint();
+  }
+  /**
+   * Save a checkpoint if the interval has been reached.
+   */
+  async maybeCheckpoint() {
+    if (!this.checkpointEnabled || !this.initialized || !this.context) {
+      return;
+    }
+    const callsSinceLastCheckpoint = this.toolCallCount - this.lastCheckpointAt;
+    if (callsSinceLastCheckpoint < this.checkpointInterval) {
+      return;
+    }
+    this.lastCheckpointAt = this.toolCallCount;
+    await this.saveCheckpoint("periodic");
+  }
+  /**
+   * Get the list of active files being worked on.
+   */
+  getActiveFiles() {
+    return Array.from(this.activeFiles);
+  }
+  /**
+   * Get recent tool call names.
+   */
+  getRecentToolNames() {
+    return this.recentToolCalls.map((t) => t.name);
+  }
+  /**
+   * Get the current tool call count.
+   */
+  getToolCallCount() {
+    return this.toolCallCount;
+  }
+  /**
+   * Save a checkpoint snapshot to ContextStream.
+   */
+  async saveCheckpoint(trigger) {
+    if (!this.initialized || !this.context) {
+      return false;
+    }
+    const workspaceId = this.context.workspace_id;
+    if (!workspaceId) {
+      return false;
+    }
+    const checkpointData = {
+      trigger,
+      checkpoint_number: Math.floor(this.toolCallCount / this.checkpointInterval),
+      tool_call_count: this.toolCallCount,
+      session_tokens: this.sessionTokens,
+      active_files: this.getActiveFiles(),
+      recent_tools: this.getRecentToolNames().slice(-10),
+      captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+      auto_captured: true
+    };
+    try {
+      await this.client.captureContext({
+        workspace_id: workspaceId,
+        project_id: this.context.project_id,
+        event_type: "session_snapshot",
+        title: `Checkpoint #${checkpointData.checkpoint_number} (${trigger})`,
+        content: JSON.stringify(checkpointData),
+        importance: trigger === "periodic" ? "low" : "medium",
+        tags: ["session_snapshot", "checkpoint", trigger]
+      });
+      return true;
+    } catch (err) {
+      console.error("[ContextStream] Failed to save checkpoint:", err);
+      return false;
+    }
+  }
+  /**
+   * Enable or disable continuous checkpointing.
+   */
+  setCheckpointEnabled(enabled) {
+    this.checkpointEnabled = enabled;
+  }
+  /**
+   * Set the checkpoint interval (tool calls between checkpoints).
+   */
+  setCheckpointInterval(interval) {
+    this.checkpointInterval = Math.max(5, interval);
+  }
 };
 
 // src/http-gateway.ts
@@ -20268,7 +21580,6 @@ var EDITOR_LABELS = {
   codex: "Codex CLI",
   claude: "Claude Code",
   cursor: "Cursor / VS Code",
-  windsurf: "Windsurf",
   cline: "Cline",
   kilo: "Kilo Code",
   roo: "Roo Code",
@@ -20347,7 +21658,6 @@ var CONTEXTSTREAM_PREAMBLE_PATTERNS2 = [
   /^#\s+codex cli instructions$/i,
   /^#\s+claude code instructions$/i,
   /^#\s+cursor rules$/i,
-  /^#\s+windsurf rules$/i,
   /^#\s+cline rules$/i,
   /^#\s+kilo code rules$/i,
   /^#\s+roo code rules$/i,
@@ -20489,8 +21799,6 @@ function globalRulesPathForEditor(editor) {
       return path8.join(home, ".codex", "AGENTS.md");
     case "claude":
       return path8.join(home, ".claude", "CLAUDE.md");
-    case "windsurf":
-      return path8.join(home, ".codeium", "windsurf", "memories", "global_rules.md");
     case "cline":
       return path8.join(home, "Documents", "Cline", "Rules", "contextstream.md");
     case "kilo":
@@ -20537,25 +21845,6 @@ async function isClaudeInstalled() {
   }
   return anyPathExists(candidates);
 }
-async function isWindsurfInstalled() {
-  const home = homedir5();
-  const candidates = [
-    path8.join(home, ".codeium"),
-    path8.join(home, ".codeium", "windsurf"),
-    path8.join(home, ".config", "codeium")
-  ];
-  if (process.platform === "darwin") {
-    candidates.push(path8.join(home, "Library", "Application Support", "Windsurf"));
-    candidates.push(path8.join(home, "Library", "Application Support", "Codeium"));
-  } else if (process.platform === "win32") {
-    const appData = process.env.APPDATA;
-    if (appData) {
-      candidates.push(path8.join(appData, "Windsurf"));
-      candidates.push(path8.join(appData, "Codeium"));
-    }
-  }
-  return anyPathExists(candidates);
-}
 async function isClineInstalled() {
   const home = homedir5();
   const candidates = [
@@ -20634,8 +21923,6 @@ async function isEditorInstalled(editor) {
       return isClaudeInstalled();
     case "cursor":
       return isCursorInstalled();
-    case "windsurf":
-      return isWindsurfInstalled();
     case "cline":
       return isClineInstalled();
     case "kilo":
@@ -20660,6 +21947,9 @@ function buildContextStreamMcpServer(params) {
     env.CONTEXTSTREAM_PROGRESSIVE_MODE = "true";
   }
   env.CONTEXTSTREAM_CONTEXT_PACK = params.contextPackEnabled === false ? "false" : "true";
+  if (params.restoreContextEnabled === false) {
+    env.CONTEXTSTREAM_RESTORE_CONTEXT = "false";
+  }
   if (params.showTiming) {
     env.CONTEXTSTREAM_SHOW_TIMING = "true";
   }
@@ -20685,6 +21975,9 @@ function buildContextStreamVsCodeServer(params) {
     env.CONTEXTSTREAM_PROGRESSIVE_MODE = "true";
   }
   env.CONTEXTSTREAM_CONTEXT_PACK = params.contextPackEnabled === false ? "false" : "true";
+  if (params.restoreContextEnabled === false) {
+    env.CONTEXTSTREAM_RESTORE_CONTEXT = "false";
+  }
   if (params.showTiming) {
     env.CONTEXTSTREAM_SHOW_TIMING = "true";
   }
@@ -20788,6 +22081,8 @@ async function upsertCodexTomlConfig(filePath, params) {
 ` : "";
   const contextPackLine = `CONTEXTSTREAM_CONTEXT_PACK = "${params.contextPackEnabled === false ? "false" : "true"}"
 `;
+  const restoreContextLine = params.restoreContextEnabled === false ? `CONTEXTSTREAM_RESTORE_CONTEXT = "false"
+` : "";
   const showTimingLine = params.showTiming ? `CONTEXTSTREAM_SHOW_TIMING = "true"
 ` : "";
   const commandLine = IS_WINDOWS ? `command = "cmd"
@@ -20803,7 +22098,7 @@ args = ["-y", "@contextstream/mcp-server"]
 [mcp_servers.contextstream.env]
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
-` + toolsetLine + contextPackLine + showTimingLine;
+` + toolsetLine + contextPackLine + restoreContextLine + showTimingLine;
   if (!exists) {
     await fs7.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
@@ -20933,6 +22228,26 @@ async function runSetupWizard(args) {
     console.log("This configures ContextStream MCP + rules for your AI editor(s).");
     if (dryRun) console.log("DRY RUN: no files will be written.\n");
     else console.log("");
+    const versionNotice = await getUpdateNotice();
+    if (versionNotice?.behind) {
+      console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+      console.log(`\u26A0\uFE0F  You're running an outdated version (v${versionNotice.current})`);
+      console.log(`   Latest version is v${versionNotice.latest}`);
+      console.log("");
+      console.log("   To use the latest version, exit and run:");
+      console.log("   npx -y @contextstream/mcp-server@latest setup");
+      console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+      console.log("");
+      const continueAnyway = normalizeInput(
+        await rl.question("Continue with current version anyway? [y/N]: ")
+      ).toLowerCase();
+      if (continueAnyway !== "y" && continueAnyway !== "yes") {
+        console.log("\nExiting. Run the command above to use the latest version.");
+        rl.close();
+        return;
+      }
+      console.log("");
+    }
     const savedCreds = await readSavedCredentials();
     const apiUrlDefault = normalizeApiUrl(
       process.env.CONTEXTSTREAM_API_URL || savedCreds?.api_url || "https://api.contextstream.io"
@@ -21125,11 +22440,7 @@ Code: ${device.user_code}`);
         }
       }
     }
-    console.log("Rules detail level (in the generated rules file):\n");
-    console.log("  1) Standard (recommended) \u2014 concise, high-signal (lower token overhead)");
-    console.log("  2) Enhanced \u2014 more guidance + examples (higher token overhead)");
-    const modeChoice = normalizeInput(await rl.question("Choose [1/2] (default 1): ")) || "1";
-    const mode = modeChoice === "2" ? "full" : "minimal";
+    const mode = "full";
     const detectedPlanName = await client.getPlanName();
     const detectedGraphTier = await client.getGraphTier();
     const graphTierLabel = detectedGraphTier === "full" ? "full graph" : detectedGraphTier === "lite" ? "graph-lite" : "none";
@@ -21165,11 +22476,16 @@ 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",
       "cursor",
-      "windsurf",
       "cline",
       "kilo",
       "roo",
@@ -21215,7 +22531,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     console.log("  1) Global");
     console.log("  2) Project");
     console.log("  3) Both");
-    const scopeChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 3): ")) || "3";
+    const scopeChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 2): ")) || "2";
     const scope = scopeChoice === "1" ? "global" : scopeChoice === "2" ? "project" : "both";
     console.log("\nInstall MCP server config as:");
     if (hasCodex && !hasProjectMcpEditors) {
@@ -21232,27 +22548,29 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         );
       }
     }
-    const mcpChoiceDefault = hasCodex && !hasProjectMcpEditors ? "1" : "3";
+    const mcpChoiceDefault = hasCodex && !hasProjectMcpEditors ? "1" : "2";
     const mcpChoice = normalizeInput(
       await rl.question(
         `Choose [${hasCodex && !hasProjectMcpEditors ? "1/2" : "1/2/3/4"}] (default ${mcpChoiceDefault}): `
       )
     ) || mcpChoiceDefault;
     const mcpScope = mcpChoice === "2" && hasCodex && !hasProjectMcpEditors ? "skip" : mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
-    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled, showTiming });
+    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled, showTiming, restoreContextEnabled });
     const mcpServerClaude = buildContextStreamMcpServer({
       apiUrl,
       apiKey,
       toolset,
       contextPackEnabled,
-      showTiming
+      showTiming,
+      restoreContextEnabled
     });
     const vsCodeServer = buildContextStreamVsCodeServer({
       apiUrl,
       apiKey,
       toolset,
       contextPackEnabled,
-      showTiming
+      showTiming,
+      restoreContextEnabled
     });
     const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
     if (needsGlobalMcpConfig) {
@@ -21272,24 +22590,13 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
               apiKey,
               toolset,
               contextPackEnabled,
-              showTiming
+              showTiming,
+              restoreContextEnabled
             });
             writeActions.push({ kind: "mcp-config", target: filePath, status });
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
             continue;
           }
-          if (editor === "windsurf") {
-            const filePath = path8.join(homedir5(), ".codeium", "windsurf", "mcp_config.json");
-            if (dryRun) {
-              writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
-              console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
-              continue;
-            }
-            const status = await upsertJsonMcpConfig(filePath, mcpServer);
-            writeActions.push({ kind: "mcp-config", target: filePath, status });
-            console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
-            continue;
-          }
           if (editor === "claude") {
             const desktopPath = claudeDesktopConfigPath();
             if (desktopPath) {
@@ -21354,53 +22661,68 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         }
       }
     }
-    if (configuredEditors.includes("claude")) {
+    const HOOKS_SUPPORTED_EDITORS = {
+      claude: "claude",
+      cursor: "cursor",
+      cline: "cline",
+      roo: "roo",
+      kilo: "kilo",
+      codex: null,
+      // No hooks API
+      aider: null,
+      // No hooks API
+      antigravity: null
+      // No hooks API
+    };
+    const hookEligibleEditors = configuredEditors.filter(
+      (e) => HOOKS_SUPPORTED_EDITORS[e] !== null
+    );
+    if (hookEligibleEditors.length > 0) {
       console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-      console.log("\u2502  Claude Code Hooks (Recommended)                                \u2502");
+      console.log("\u2502  AI Editor Hooks (Recommended)                                  \u2502");
       console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
       console.log("");
-      console.log("  Problem: Claude Code often ignores CLAUDE.md instructions and uses");
-      console.log("  its default tools (Grep/Glob/Search) instead of ContextStream search.");
-      console.log("  This happens because instructions decay over long conversations.");
+      console.log("  Problem: AI editors often use their default tools (Grep/Glob/Search)");
+      console.log("  instead of ContextStream smart search. Instructions decay over long chats.");
       console.log("");
       console.log("  Solution: Install hooks that:");
-      console.log("  \u2713 Block default search tools (Grep/Glob/Search) \u2192 redirect to ContextStream");
-      console.log("  \u2713 Block built-in plan mode \u2192 redirect to ContextStream plans (persistent)");
-      console.log("  \u2713 Inject reminders on every message to keep rules in context");
-      console.log("  \u2713 Result: Faster searches, persistent plans across sessions");
+      console.log("  \u2713 Use ContextStream (indexed, faster) with default tool use");
+      console.log("  \u2713 Use ContextStream plans (persistent) with default tool use");
+      console.log("  \u2713 Inject reminders to keep rules in context");
+      console.log("");
+      console.log(`  Hooks available for: ${hookEligibleEditors.map((e) => EDITOR_LABELS[e]).join(", ")}`);
       console.log("");
       console.log("  You can disable hooks anytime with CONTEXTSTREAM_HOOK_ENABLED=false");
       console.log("");
       const installHooks = normalizeInput(
-        await rl.question("Install Claude Code hooks? [Y/n] (recommended): ")
+        await rl.question("Install editor hooks? [Y/n] (recommended): ")
       ).toLowerCase();
       if (installHooks !== "n" && installHooks !== "no") {
-        try {
-          if (dryRun) {
-            console.log("- Would install hooks to ~/.claude/hooks/");
-            console.log("- Would update ~/.claude/settings.json");
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "hooks", "contextstream-redirect.py"), status: "dry-run" });
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "hooks", "contextstream-reminder.py"), status: "dry-run" });
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "settings.json"), status: "dry-run" });
-          } else {
-            const result = await installClaudeCodeHooks({ scope: "user" });
-            result.scripts.forEach((script) => {
-              writeActions.push({ kind: "mcp-config", target: script, status: "created" });
-              console.log(`- Created hook: ${script}`);
-            });
-            result.settings.forEach((settings) => {
-              writeActions.push({ kind: "mcp-config", target: settings, status: "updated" });
-              console.log(`- Updated settings: ${settings}`);
+        for (const editor of hookEligibleEditors) {
+          const hookEditor = HOOKS_SUPPORTED_EDITORS[editor];
+          if (!hookEditor) continue;
+          try {
+            if (dryRun) {
+              console.log(`- ${EDITOR_LABELS[editor]}: would install hooks`);
+              continue;
+            }
+            const result = await installEditorHooks({
+              editor: hookEditor,
+              scope: "global"
             });
+            for (const script of result.installed) {
+              writeActions.push({ kind: "hooks", target: script, status: "created" });
+              console.log(`- ${EDITOR_LABELS[editor]}: installed ${path8.basename(script)}`);
+            }
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(`- ${EDITOR_LABELS[editor]}: failed to install hooks: ${message}`);
           }
-          console.log("  Hooks installed. Disable with CONTEXTSTREAM_HOOK_ENABLED=false");
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          console.log(`- Failed to install hooks: ${message}`);
         }
+        console.log("  Hooks installed. Disable with CONTEXTSTREAM_HOOK_ENABLED=false");
       } else {
         console.log("- Skipped hooks installation.");
-        console.log("  Note: Without hooks, Claude may still use default tools instead of ContextStream.");
+        console.log("  Note: Without hooks, AI may still use default tools instead of ContextStream.");
       }
     }
     console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
@@ -21729,11 +23051,7 @@ Applying to ${projects.length} project(s)...`);
       "- Toggle Response Timing with CONTEXTSTREAM_SHOW_TIMING=true|false."
     );
     console.log("");
-    console.log("You're set up! Now try these prompts in your AI tool:");
-    console.log('  1) "session summary"');
-    console.log(`  2) "remember we're using PostgreSQL"`);
-    console.log('  3) "what did we decide about auth?"');
-    console.log("");
+    console.log("You're all set! ContextStream gives your AI persistent memory, semantic code search, and cross-session context.");
     console.log("More at: https://contextstream.io/docs/mcp");
   } finally {
     rl.close();
@@ -21883,13 +23201,21 @@ async function main() {
   if (ENABLE_PROMPTS2) {
     registerPrompts(server);
   }
-  console.error(`ContextStream MCP server v${VERSION} starting...`);
-  console.error(`API URL: ${config.apiUrl}`);
-  console.error(`Auth: ${config.apiKey ? "API Key" : config.jwt ? "JWT" : "None"}`);
-  console.error(`Auto-Context: ENABLED (context loads on first tool call)`);
+  const logLevel = (process.env.CONTEXTSTREAM_LOG_LEVEL || "normal").toLowerCase();
+  const logQuiet = logLevel === "quiet";
+  const logVerbose = logLevel === "verbose";
+  if (!logQuiet) {
+    console.error(`\u2501\u2501\u2501 ContextStream v${VERSION} \u2501\u2501\u2501`);
+  }
+  if (logVerbose) {
+    console.error(`  API: ${config.apiUrl}`);
+    console.error(`  Auth: ${config.apiKey ? "API Key" : config.jwt ? "JWT" : "None"}`);
+  }
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("ContextStream MCP server connected and ready");
+  if (!logQuiet) {
+    console.error("\u2713 ready");
+  }
   showFirstRunMessage();
   checkForUpdates().catch(() => {
   });