@contextstream/mcp-server 0.4.37 → 0.4.39

package/dist/index.js

@@ -5,7 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -4676,7 +4682,8 @@ var configSchema = external_exports.object({
   defaultProjectId: external_exports.string().uuid().optional(),
   userAgent: external_exports.string().default(`contextstream-mcp/${VERSION}`),
   allowHeaderAuth: external_exports.boolean().optional(),
-  contextPackEnabled: external_exports.boolean().default(true)
+  contextPackEnabled: external_exports.boolean().default(true),
+  showTiming: external_exports.boolean().default(false)
 });
 var MISSING_CREDENTIALS_ERROR = "Set CONTEXTSTREAM_API_KEY or CONTEXTSTREAM_JWT for authentication (or CONTEXTSTREAM_ALLOW_HEADER_AUTH=true for header-based auth).";
 function isMissingCredentialsError(err) {
@@ -4690,6 +4697,7 @@ function loadConfig() {
   const contextPackEnabled = parseBooleanEnv(
     process.env.CONTEXTSTREAM_CONTEXT_PACK ?? process.env.CONTEXTSTREAM_CONTEXT_PACK_ENABLED
   );
+  const showTiming = parseBooleanEnv(process.env.CONTEXTSTREAM_SHOW_TIMING);
   const parsed = configSchema.safeParse({
     apiUrl: process.env.CONTEXTSTREAM_API_URL,
     apiKey: process.env.CONTEXTSTREAM_API_KEY,
@@ -4698,7 +4706,8 @@ function loadConfig() {
     defaultProjectId: process.env.CONTEXTSTREAM_PROJECT_ID,
     userAgent: process.env.CONTEXTSTREAM_USER_AGENT,
     allowHeaderAuth,
-    contextPackEnabled
+    contextPackEnabled,
+    showTiming
   });
   if (!parsed.success) {
     const missing = parsed.error.errors.map((e) => e.path.join(".")).join(", ");
@@ -5572,6 +5581,47 @@ var INGEST_BENEFITS = [
   "Allow the AI assistant to find relevant code without manual file navigation",
   "Build a searchable knowledge base of your codebase structure"
 ];
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "Cargo.toml",
+  "pyproject.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle",
+  "Gemfile",
+  "composer.json",
+  ".contextstream"
+];
+function isMultiProjectFolder(folderPath) {
+  try {
+    const fs8 = __require("fs");
+    const pathModule = __require("path");
+    const rootHasGit = fs8.existsSync(pathModule.join(folderPath, ".git"));
+    const entries = fs8.readdirSync(folderPath, { withFileTypes: true });
+    const subdirs = entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules"
+    );
+    const projectSubdirs = [];
+    for (const subdir of subdirs) {
+      const subdirPath = pathModule.join(folderPath, subdir.name);
+      for (const marker of PROJECT_MARKERS) {
+        if (fs8.existsSync(pathModule.join(subdirPath, marker))) {
+          projectSubdirs.push(subdir.name);
+          break;
+        }
+      }
+    }
+    const isMultiProject = projectSubdirs.length >= 1 && (!rootHasGit || projectSubdirs.length >= 2);
+    return {
+      isMultiProject,
+      projectCount: projectSubdirs.length,
+      projectNames: projectSubdirs
+    };
+  } catch {
+    return { isMultiProject: false, projectCount: 0, projectNames: [] };
+  }
+}
 var ContextStreamClient = class {
   constructor(config) {
     this.config = config;
@@ -6607,7 +6657,25 @@ var ContextStreamClient = class {
         return context;
       }
     }
-    if (!projectId && workspaceId && rootPath && params.auto_index !== false) {
+    let autoDetectedMultiProject = false;
+    if (!params.skip_project_creation && !projectId && rootPath) {
+      const detection = isMultiProjectFolder(rootPath);
+      if (detection.isMultiProject) {
+        autoDetectedMultiProject = true;
+        context.workspace_only_mode = true;
+        context.auto_detected_multi_project = true;
+        context.detected_projects = detection.projectNames;
+        context.project_skipped_reason = `Auto-detected ${detection.projectCount} projects in folder: ${detection.projectNames.slice(0, 5).join(", ")}${detection.projectCount > 5 ? "..." : ""}. Working at workspace level.`;
+        console.error(
+          `[ContextStream] Auto-detected multi-project folder with ${detection.projectCount} projects: ${detection.projectNames.slice(0, 5).join(", ")}`
+        );
+      }
+    }
+    if (params.skip_project_creation) {
+      context.workspace_only_mode = true;
+      context.project_skipped_reason = "skip_project_creation=true - working at workspace level for multi-project folder";
+    } else if (autoDetectedMultiProject) {
+    } else if (!projectId && workspaceId && rootPath && params.auto_index !== false) {
       const projectName = path4.basename(rootPath) || "My Project";
       try {
         const projects = await this.listProjects({ workspace_id: workspaceId });
@@ -6918,11 +6986,16 @@ var ContextStreamClient = class {
    * Persists the selection to .contextstream/config.json for future sessions.
    */
   async associateWorkspace(params) {
-    const { folder_path, workspace_id, workspace_name, create_parent_mapping } = params;
+    const { folder_path, workspace_id, workspace_name, create_parent_mapping, version, configured_editors, context_pack, api_url } = params;
     const saved = writeLocalConfig(folder_path, {
       workspace_id,
       workspace_name,
-      associated_at: (/* @__PURE__ */ new Date()).toISOString()
+      associated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      version,
+      configured_editors,
+      context_pack,
+      api_url,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
     });
     if (create_parent_mapping) {
       const parentDir = path4.dirname(folder_path);
@@ -7593,7 +7666,10 @@ var ContextStreamClient = class {
           distill: params.distill,
           client_version: VERSION,
           rules_version: VERSION,
-          notice_inline: false
+          notice_inline: false,
+          // Session token tracking for context pressure
+          ...params.session_tokens !== void 0 && { session_tokens: params.session_tokens },
+          ...params.context_threshold !== void 0 && { context_threshold: params.context_threshold }
         }
       });
       const data = unwrapApiResponse(apiResult);
@@ -7613,7 +7689,8 @@ var ContextStreamClient = class {
         project_id: withDefaults.project_id,
         ...versionNotice2 ? { version_notice: versionNotice2 } : {},
         ...Array.isArray(data?.errors) ? { errors: data.errors } : {},
-        ...this.indexRefreshInProgress ? { index_status: "refreshing" } : {}
+        ...this.indexRefreshInProgress ? { index_status: "refreshing" } : {},
+        ...data?.context_pressure ? { context_pressure: data.context_pressure } : {}
       };
     } catch (err) {
       const message2 = err instanceof Error ? err.message : String(err);
@@ -8795,16 +8872,15 @@ function applyMcpToolPrefix(markdown, toolPrefix) {
   return markdown.replace(toolRegex, `${toolPrefix}$1`);
 }
 var CONTEXTSTREAM_RULES_FULL = `
-## \u{1F6A8} MANDATORY RULE: DISPLAY AT START OF EVERY RESPONSE \u{1F6A8}
+## ContextStream Rules
 
 <contextstream_rules>
-1. **SEARCH FIRST:** Before Glob/Grep/Search/Read \u2192 \`search(mode="hybrid", query="...")\` FIRST
-2. **EVERY MESSAGE:** Call \`context_smart(user_message="...")\` at start of response
-3. **LOCAL TOOLS:** ONLY if ContextStream search returns 0 results after retry
+1. **SIMPLE UTILITY?** (list/show/version) \u2192 Just execute, skip context calls
+2. **CODING TASK?** \u2192 session_init \u2192 context_smart \u2192 work \u2192 capture
+3. **SEARCH FIRST:** Before Glob/Grep/Read \u2192 \`search(mode="hybrid")\` FIRST
 </contextstream_rules>
 
-**You MUST display the <contextstream_rules> block verbatim at the start of EVERY response.**
-This is a self-referential rule that ensures these instructions stay in recent context.
+**Display this block at the start of responses to keep rules in context.**
 
 ---
 
@@ -8863,8 +8939,10 @@ This applies to **EVERY search** throughout the **ENTIRE conversation**, not jus
 - **Apply the prevention steps** from each lesson to avoid repeating mistakes
 
 ### On \`context_smart\`:
-- Check for any lessons in the returned context
-- Lessons may be included based on semantic relevance to the user's message
+- Check for \`[LESSONS_WARNING]\` tag in the response
+- If present, you **MUST** tell the user about the lessons before proceeding
+- Lessons are proactively fetched when risky actions are detected (refactor, migrate, deploy, etc.)
+- **Do not skip or bury this warning** - lessons represent real past mistakes
 
 ### Before ANY Non-Trivial Work:
 **ALWAYS call \`session(action="get_lessons", query="<topic>")\`** where \`<topic>\` matches what you're about to do:
@@ -8888,22 +8966,42 @@ You have access to ContextStream MCP tools for persistent memory and context.
 v0.4.x uses **~11 consolidated domain tools** for ~75% token reduction vs previous versions.
 Rules Version: ${RULES_VERSION}
 
-## TL;DR - REQUIRED EVERY MESSAGE
+## TL;DR - WHEN TO USE CONTEXT
+
+| 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", ...)\` |
+
+### Simple Utility Operations - FAST PATH
 
-| 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 |
+**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", ...)\` |
 
-**NO EXCEPTIONS.** Do not skip even if you think you have enough context.
+**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:** After \`session_init\`:
+**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
 
@@ -8917,9 +9015,9 @@ Rules Version: ${RULES_VERSION}
 
 v0.4.x consolidates ~58 individual tools into ~11 domain tools with action/mode dispatch:
 
-### Standalone Tools (Always Call)
-- **\`session_init\`** - Initialize session with workspace detection + context
-- **\`context_smart\`** - Semantic search for relevant context (CALL EVERY MESSAGE, including immediately after \`session_init\`)
+### Standalone Tools
+- **\`session_init\`** - Initialize session with workspace detection + context (skip for simple utility operations)
+- **\`context_smart\`** - Semantic search for relevant context (skip for simple utility operations)
 
 ### Domain Tools (Use action/mode parameter)
 
@@ -8966,10 +9064,21 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 ---
 
-### Rules Update Notices
+### Rules, Version & Lessons Notices
 
-- 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.
+**[RULES_NOTICE]** - Update rules via \`generate_rules()\` (or rerun setup).
+
+**[VERSION_NOTICE]** - You **MUST IMMEDIATELY** tell the user:
+  1. A new MCP server version is available
+  2. The exact update command to run
+  3. That they need to restart their AI tool after updating
+  **Do not skip this** - users often miss stderr warnings.
+
+**[LESSONS_WARNING]** - You **MUST** before proceeding:
+  1. Read all lessons listed
+  2. Tell the user about relevant lessons
+  3. Explain how you will avoid each past mistake
+  **This is critical** - ignoring lessons leads to repeated failures.
 
 ---
 
@@ -8981,6 +9090,39 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 ---
 
+### Context Pressure & Compaction Awareness
+
+ContextStream tracks context pressure to help you stay ahead of conversation compaction:
+
+**Automatic tracking:** Token usage is tracked automatically. \`context_smart\` returns \`context_pressure\` when usage is high.
+
+**When \`context_smart\` returns \`context_pressure\` with high/critical level:**
+1. Review the \`suggested_action\` field:
+   - \`prepare_save\`: Start thinking about saving important state
+   - \`save_now\`: Immediately call \`session(action="capture", event_type="session_snapshot")\` to preserve state
+
+**PreCompact Hook (Optional):** If enabled, Claude Code will inject a reminder to save state before compaction.
+Enable with: \`generate_rules(install_hooks=true, include_pre_compact=true)\`
+
+**Before compaction happens (when warned):**
+\`\`\`
+session(action="capture", event_type="session_snapshot", title="Pre-compaction snapshot", content="{
+  \\"conversation_summary\\": \\"<summarize what we've been doing>\\",
+  \\"current_goal\\": \\"<the main task>\\",
+  \\"active_files\\": [\\"file1.ts\\", \\"file2.ts\\"],
+  \\"recent_decisions\\": [{title: \\"...\\", rationale: \\"...\\"}],
+  \\"unfinished_work\\": [{task: \\"...\\", status: \\"...\\", next_steps: \\"...\\"}]
+}")
+\`\`\`
+
+**After compaction (when context seems lost):**
+1. Call \`session_init(folder_path="...", is_post_compact=true)\` - this auto-restores the most recent snapshot
+2. Or call \`session_restore_context()\` directly to get the saved state
+3. Review the \`restored_context\` to understand prior work
+4. Acknowledge to the user what was restored and continue
+
+---
+
 ### Index Status (Auto-Managed)
 
 **Indexing is automatic.** After \`session_init\`, the project is auto-indexed in the background.
@@ -9067,16 +9209,24 @@ If ContextStream returns results, stop and use them. NEVER use local Search/Expl
 
 ---
 
-### When to Capture (MANDATORY)
+### When to Capture
 
 | When | Call | Example |
 |------|------|---------|
 | User makes decision | \`session(action="capture", event_type="decision", ...)\` | "Let's use PostgreSQL" |
 | User states preference | \`session(action="capture", event_type="preference", ...)\` | "I prefer TypeScript" |
-| You complete a task | \`session(action="capture", event_type="task", ...)\` | Capture what was done |
+| Complete significant task | \`session(action="capture", event_type="task", ...)\` | Capture what was done |
 | Need past context | \`session(action="recall", query="...")\` | "What did we decide about X?" |
 
-**You MUST capture after completing any significant task.** This ensures future sessions have context.
+**DO NOT capture utility operations:**
+- \u274C "Listed workspaces" - not meaningful context
+- \u274C "Showed version" - not a decision
+- \u274C "Listed projects" - just data retrieval
+
+**DO capture meaningful work:**
+- \u2705 Decisions, preferences, completed features
+- \u2705 Lessons from mistakes
+- \u2705 Insights about architecture or patterns
 
 ---
 
@@ -9156,16 +9306,15 @@ memory(action="create_task", title="<task title>", plan_id="<plan_id from step 1
 See full documentation: https://contextstream.io/docs/mcp/tools
 `.trim();
 var CONTEXTSTREAM_RULES_MINIMAL = `
-## \u{1F6A8} MANDATORY RULE: DISPLAY AT START OF EVERY RESPONSE \u{1F6A8}
+## ContextStream Rules
 
 <contextstream_rules>
-1. **SEARCH FIRST:** Before Glob/Grep/Search/Read \u2192 \`search(mode="hybrid", query="...")\` FIRST
-2. **EVERY MESSAGE:** Call \`context_smart(user_message="...")\` at start of response
-3. **LOCAL TOOLS:** ONLY if ContextStream search returns 0 results after retry
+1. **SIMPLE UTILITY?** (list/show/version) \u2192 Just execute, skip context calls
+2. **CODING TASK?** \u2192 session_init \u2192 context_smart \u2192 work \u2192 capture
+3. **SEARCH FIRST:** Before Glob/Grep/Read \u2192 \`search(mode="hybrid")\` FIRST
 </contextstream_rules>
 
-**You MUST display the <contextstream_rules> block verbatim at the start of EVERY response.**
-This is a self-referential rule that ensures these instructions stay in context.
+**Display this block at the start of responses to keep rules in context.**
 
 ---
 
@@ -9174,7 +9323,7 @@ This is a self-referential rule that ensures these instructions stay in context.
 Rules Version: ${RULES_VERSION}
 **Note:** PreToolUse hooks block Glob/Grep/Search when ContextStream is available.
 
-### Required Every Message
+### For Coding Tasks
 
 | Action | Tool Call |
 |--------|-----------|
@@ -9208,18 +9357,79 @@ 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
 - Before risky work: \`session(action="get_lessons", query="<topic>")\`
 - On mistakes: \`session(action="capture_lesson", title="...", trigger="...", impact="...", prevention="...")\`
 
+### Context Pressure & Compaction
+
+- If \`context_smart\` returns high/critical \`context_pressure\`: call \`session(action="capture", ...)\` to save state
+- PreCompact hooks automatically save snapshots before compaction (if installed)
+
+### Automatic Context Restoration
+
+**Context restoration is now enabled by default.** Every \`session_init\` call automatically:
+- Restores context from recent snapshots (if available)
+- Returns \`restored_context\` field with snapshot data
+- Sets \`is_post_compact=true\` in response when restoration occurs
+
+**No special handling needed after compaction** - just call \`session_init\` normally.
+
+To disable automatic restoration:
+- Pass \`is_post_compact=false\` in the API call
+- Or set \`CONTEXTSTREAM_RESTORE_CONTEXT=false\` environment variable
+
+### Notices - MUST HANDLE IMMEDIATELY
+
+- **[VERSION_NOTICE]**: Tell the user about the update and command to run
+- **[RULES_NOTICE]**: Run \`generate_rules(overwrite_existing=true)\` to update
+- **[LESSONS_WARNING]**: Read lessons, tell user about them, explain how you'll avoid past mistakes
+
 ### Plans & Tasks
 
 When user asks for a plan, use ContextStream (not EnterPlanMode):
 1. \`session(action="capture_plan", title="...", steps=[...])\`
 2. \`memory(action="create_task", title="...", plan_id="<id>")\`
 
+### Workspace-Only Mode (Multi-Project Folders)
+
+If working in a parent folder containing multiple projects:
+\`\`\`
+session_init(folder_path="...", skip_project_creation=true)
+\`\`\`
+
+This enables workspace-level memory and context without project-specific indexing.
+Use for monorepos or folders with multiple independent projects.
+
 Full docs: https://contextstream.io/docs/mcp/tools
 `.trim();
 var TEMPLATES = {
@@ -9672,6 +9882,234 @@ def main():
     print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": REMINDER}}))
     sys.exit(0)
 
+if __name__ == "__main__":
+    main()
+`;
+var PRECOMPACT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreCompact Hook for Claude Code
+
+Runs BEFORE conversation context is compacted (manual via /compact or automatic).
+Automatically saves conversation state to ContextStream by parsing the transcript.
+
+Input (via stdin):
+{
+  "session_id": "...",
+  "transcript_path": "/path/to/transcript.jsonl",
+  "permission_mode": "default",
+  "hook_event_name": "PreCompact",
+  "trigger": "manual" | "auto",
+  "custom_instructions": "..."
+}
+
+Output (to stdout):
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreCompact",
+    "additionalContext": "... status message ..."
+  }
+}
+"""
+
+import json
+import sys
+import os
+import re
+import urllib.request
+import urllib.error
+
+ENABLED = os.environ.get("CONTEXTSTREAM_PRECOMPACT_ENABLED", "true").lower() == "true"
+AUTO_SAVE = os.environ.get("CONTEXTSTREAM_PRECOMPACT_AUTO_SAVE", "true").lower() == "true"
+API_URL = os.environ.get("CONTEXTSTREAM_API_URL", "https://api.contextstream.io")
+API_KEY = os.environ.get("CONTEXTSTREAM_API_KEY", "")
+
+WORKSPACE_ID = None
+
+def load_config_from_mcp_json(cwd):
+    """Load API config from .mcp.json if env vars not set."""
+    global API_URL, API_KEY, WORKSPACE_ID
+
+    # Try to find .mcp.json and .contextstream/config.json in cwd or parent directories
+    search_dir = cwd
+    for _ in range(5):  # Search up to 5 levels
+        # Load API config from .mcp.json
+        if not API_KEY:
+            mcp_path = os.path.join(search_dir, ".mcp.json")
+            if os.path.exists(mcp_path):
+                try:
+                    with open(mcp_path, 'r') as f:
+                        config = json.load(f)
+                    servers = config.get("mcpServers", {})
+                    cs_config = servers.get("contextstream", {})
+                    env = cs_config.get("env", {})
+                    if env.get("CONTEXTSTREAM_API_KEY"):
+                        API_KEY = env["CONTEXTSTREAM_API_KEY"]
+                    if env.get("CONTEXTSTREAM_API_URL"):
+                        API_URL = env["CONTEXTSTREAM_API_URL"]
+                except:
+                    pass
+
+        # Load workspace_id from .contextstream/config.json
+        if not WORKSPACE_ID:
+            cs_config_path = os.path.join(search_dir, ".contextstream", "config.json")
+            if os.path.exists(cs_config_path):
+                try:
+                    with open(cs_config_path, 'r') as f:
+                        cs_config = json.load(f)
+                    if cs_config.get("workspace_id"):
+                        WORKSPACE_ID = cs_config["workspace_id"]
+                except:
+                    pass
+
+        parent = os.path.dirname(search_dir)
+        if parent == search_dir:
+            break
+        search_dir = parent
+
+def parse_transcript(transcript_path):
+    """Parse transcript to extract active files, decisions, and context."""
+    active_files = set()
+    recent_messages = []
+    tool_calls = []
+
+    try:
+        with open(transcript_path, 'r') as f:
+            for line in f:
+                try:
+                    entry = json.loads(line.strip())
+                    msg_type = entry.get("type", "")
+
+                    # Extract files from tool calls
+                    if msg_type == "tool_use":
+                        tool_name = entry.get("name", "")
+                        tool_input = entry.get("input", {})
+                        tool_calls.append({"name": tool_name, "input": tool_input})
+
+                        # Extract file paths from common tools
+                        if tool_name in ["Read", "Write", "Edit", "NotebookEdit"]:
+                            file_path = tool_input.get("file_path") or tool_input.get("notebook_path")
+                            if file_path:
+                                active_files.add(file_path)
+                        elif tool_name == "Glob":
+                            pattern = tool_input.get("pattern", "")
+                            if pattern:
+                                active_files.add(f"[glob:{pattern}]")
+
+                    # Collect recent assistant messages for summary
+                    if msg_type == "assistant" and entry.get("content"):
+                        content = entry.get("content", "")
+                        if isinstance(content, str) and len(content) > 50:
+                            recent_messages.append(content[:500])
+
+                except json.JSONDecodeError:
+                    continue
+    except Exception as e:
+        pass
+
+    return {
+        "active_files": list(active_files)[-20:],  # Last 20 files
+        "tool_call_count": len(tool_calls),
+        "message_count": len(recent_messages),
+        "last_tools": [t["name"] for t in tool_calls[-10:]],  # Last 10 tool names
+    }
+
+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:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    # Load config from .mcp.json if env vars not set
+    cwd = data.get("cwd", os.getcwd())
+    load_config_from_mcp_json(cwd)
+
+    session_id = data.get("session_id", "unknown")
+    transcript_path = data.get("transcript_path", "")
+    trigger = data.get("trigger", "unknown")
+    custom_instructions = data.get("custom_instructions", "")
+
+    # Parse transcript for context
+    transcript_data = {}
+    if transcript_path and os.path.exists(transcript_path):
+        transcript_data = parse_transcript(transcript_path)
+
+    # Auto-save snapshot if enabled
+    auto_save_status = ""
+    if AUTO_SAVE and API_KEY:
+        success, msg = save_snapshot(session_id, transcript_data, trigger)
+        if success:
+            auto_save_status = f"\\n[ContextStream: Auto-saved snapshot with {len(transcript_data.get('active_files', []))} active files]"
+        else:
+            auto_save_status = f"\\n[ContextStream: Auto-save failed - {msg}]"
+
+    # Build context injection for the AI (backup in case auto-save fails)
+    files_list = ", ".join(transcript_data.get("active_files", [])[:5]) or "none detected"
+    context = f"""[CONTEXT COMPACTION - {trigger.upper()}]{auto_save_status}
+
+Active files detected: {files_list}
+Tool calls in session: {transcript_data.get('tool_call_count', 0)}
+
+After compaction, call session_init(is_post_compact=true) to restore context.
+{f"User instructions: {custom_instructions}" if custom_instructions else ""}"""
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreCompact",
+            "additionalContext": context
+        }
+    }
+
+    print(json.dumps(output))
+    sys.exit(0)
+
 if __name__ == "__main__":
     main()
 `;
@@ -9687,11 +10125,12 @@ function getClaudeSettingsPath(scope, projectPath) {
 function getHooksDir() {
   return path5.join(homedir2(), ".claude", "hooks");
 }
-function buildHooksConfig() {
+function buildHooksConfig(options) {
   const hooksDir = getHooksDir();
   const preToolUsePath = path5.join(hooksDir, "contextstream-redirect.py");
   const userPromptPath = path5.join(hooksDir, "contextstream-reminder.py");
-  return {
+  const preCompactPath = path5.join(hooksDir, "contextstream-precompact.py");
+  const config = {
     PreToolUse: [
       {
         matcher: "Glob|Grep|Search|Task|EnterPlanMode",
@@ -9717,15 +10156,40 @@ function buildHooksConfig() {
       }
     ]
   };
+  if (options?.includePreCompact) {
+    config.PreCompact = [
+      {
+        // Match both manual (/compact) and automatic compaction
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: `python3 "${preCompactPath}"`,
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  return config;
 }
-async function installHookScripts() {
+async function installHookScripts(options) {
   const hooksDir = getHooksDir();
   await fs4.mkdir(hooksDir, { recursive: true });
   const preToolUsePath = path5.join(hooksDir, "contextstream-redirect.py");
   const userPromptPath = path5.join(hooksDir, "contextstream-reminder.py");
+  const preCompactPath = path5.join(hooksDir, "contextstream-precompact.py");
   await fs4.writeFile(preToolUsePath, PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
   await fs4.writeFile(userPromptPath, USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
-  return { preToolUse: preToolUsePath, userPrompt: userPromptPath };
+  const result = {
+    preToolUse: preToolUsePath,
+    userPrompt: userPromptPath
+  };
+  if (options?.includePreCompact) {
+    await fs4.writeFile(preCompactPath, PRECOMPACT_HOOK_SCRIPT, { mode: 493 });
+    result.preCompact = preCompactPath;
+  }
+  return result;
 }
 async function readClaudeSettings(scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
@@ -9756,39 +10220,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();
-    result.scripts.push(scripts.preToolUse, scripts.userPrompt);
-  } else {
-    const hooksDir = getHooksDir();
-    result.scripts.push(
-      path5.join(hooksDir, "contextstream-redirect.py"),
-      path5.join(hooksDir, "contextstream-reminder.py")
-    );
-  }
-  const hooksConfig = buildHooksConfig();
-  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");
 }
@@ -9817,138 +10248,928 @@ async function markProjectIndexed(projectPath, options) {
   };
   await writeIndexStatus(status);
 }
-
-// src/token-savings.ts
-var TOKEN_SAVINGS_FORMULA_VERSION = 1;
-var MAX_CHARS_PER_EVENT = 2e7;
-var BASE_OVERHEAD_CHARS = 500;
-var CANDIDATE_MULTIPLIERS = {
-  // context_smart: Replaces reading multiple files to gather context
-  context_smart: 5,
-  ai_context_budget: 5,
-  // search: Semantic search replaces iterative Glob/Grep/Read cycles
-  search_semantic: 4.5,
-  search_hybrid: 4,
-  search_keyword: 2.5,
-  search_pattern: 3,
-  search_exhaustive: 3.5,
-  search_refactor: 3,
-  // session: Recall/search replaces reading through history
-  session_recall: 5,
-  session_smart_search: 4,
-  session_user_context: 3,
-  session_summary: 4,
-  // graph: Would require extensive file traversal
-  graph_dependencies: 8,
-  graph_impact: 10,
-  graph_call_path: 8,
-  graph_related: 6,
-  // memory: Context retrieval
-  memory_search: 3.5,
-  memory_decisions: 3,
-  memory_timeline: 3,
-  memory_summary: 4
-};
-function clampCharCount(value) {
-  if (!Number.isFinite(value) || value <= 0) return 0;
-  return Math.min(MAX_CHARS_PER_EVENT, Math.floor(value));
-}
-function trackToolTokenSavings(client, tool, contextText, params, extraMetadata) {
-  try {
-    const contextChars = clampCharCount(contextText.length);
-    const multiplier = CANDIDATE_MULTIPLIERS[tool] ?? 3;
-    const baseOverhead = contextChars > 0 ? BASE_OVERHEAD_CHARS : 0;
-    const estimatedCandidate = Math.round(contextChars * multiplier + baseOverhead);
-    const candidateChars = Math.max(contextChars, clampCharCount(estimatedCandidate));
-    client.trackTokenSavings({
-      tool,
-      workspace_id: params?.workspace_id,
-      project_id: params?.project_id,
-      candidate_chars: candidateChars,
-      context_chars: contextChars,
-      max_tokens: params?.max_tokens,
-      metadata: {
-        method: "multiplier_estimate",
-        formula_version: TOKEN_SAVINGS_FORMULA_VERSION,
-        source: "mcp-server",
-        multiplier,
-        base_overhead_chars: baseOverhead,
-        ...extraMetadata ?? {}
-      }
-    }).catch(() => {
-    });
-  } catch {
-  }
+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"
 }
+"""
 
-// src/tools.ts
-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";
-var SEARCH_RULES_REMINDER = `
-\u26A0\uFE0F [SEARCH RULES - READ EVERY TIME]
-BEFORE using Glob/Grep/Read/Search/Explore \u2192 call mcp__contextstream__search(mode="hybrid", query="...") FIRST
-BEFORE using EnterPlanMode/Task(Plan) \u2192 call mcp__contextstream__session(action="capture_plan", ...) instead
-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:
-`.trim();
-function generateLessonsReminder(result) {
-  const lessons = result.lessons;
-  if (!lessons || lessons.length === 0) {
-    return "";
-  }
-  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 || l.trigger || "";
-    return `${i + 1}. ${severity} ${title}${prevention ? `: ${prevention.slice(0, 100)}` : ""}`;
-  });
-  return `
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
 
-${LESSONS_REMINDER_PREFIX}
-${lessonLines.join("\n")}`;
-}
-function generateRulesUpdateWarning(rulesNotice) {
-  if (!rulesNotice || rulesNotice.status !== "behind" && rulesNotice.status !== "missing") {
-    return "";
-  }
-  const isMissing = rulesNotice.status === "missing";
-  const current = rulesNotice.current ?? "none";
-  const latest = rulesNotice.latest;
-  return `
-\u{1F6A8} [RULES ${isMissing ? "MISSING" : "OUTDATED"} - ACTION REQUIRED]
-${isMissing ? "ContextStream rules are NOT installed." : `Rules version ${current} \u2192 ${latest} available.`}
-${isMissing ? "AI behavior may be suboptimal without proper rules." : "New rules include important improvements for better AI behavior."}
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+STALE_THRESHOLD_DAYS = 7
 
-**UPDATE NOW:** Run \`mcp__contextstream__generate_rules(overwrite_existing=true)\`
-This is SAFE - only the ContextStream block is updated, your custom rules are preserved.
-`.trim();
-}
-function generateVersionUpdateWarning(versionNotice) {
-  if (!versionNotice?.behind) {
-    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.
+DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
 
-**UPDATE NOW:** Run \`${versionNotice.upgrade_command || "npm update @contextstream/mcp-server"}\`
-Then restart Claude Code to use the new version.
-`.trim();
-}
-var DEFAULT_PARAM_DESCRIPTIONS = {
-  api_key: "ContextStream API key.",
-  apiKey: "ContextStream API key.",
-  jwt: "ContextStream JWT for authentication.",
-  workspace_id: "Workspace ID (UUID).",
-  workspaceId: "Workspace ID (UUID).",
-  project_id: "Project ID (UUID).",
-  projectId: "Project ID (UUID).",
-  node_id: "Node ID (UUID).",
+def is_discovery_glob(pattern):
+    pattern_lower = pattern.lower()
+    for p in DISCOVERY_PATTERNS:
+        if p in pattern_lower:
+            return True
+    if pattern_lower.startswith("**/*.") or pattern_lower.startswith("**/"):
+        return True
+    if "**" in pattern or "*/" in pattern:
+        return True
+    return False
+
+def is_discovery_grep(file_path):
+    if not file_path or file_path in [".", "./", "*", "**"]:
+        return True
+    if "*" in file_path or "**" in file_path:
+        return True
+    return False
+
+def is_project_indexed(workspace_roots):
+    """Check if any workspace root is in an indexed project."""
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+
+    for workspace in workspace_roots:
+        cwd_path = Path(workspace).resolve()
+        for project_path, info in projects.items():
+            try:
+                indexed_path = Path(project_path).resolve()
+                if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                    indexed_at = info.get("indexed_at")
+                    if indexed_at:
+                        try:
+                            indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                            if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                                return True, True
+                        except:
+                            pass
+                    return True, False
+            except:
+                continue
+    return False, False
+
+def output_allow(context_mod=None):
+    result = {"cancel": False}
+    if context_mod:
+        result["contextModification"] = context_mod
+    print(json.dumps(result))
+    sys.exit(0)
+
+def output_block(error_msg, context_mod=None):
+    result = {"cancel": True, "errorMessage": error_msg}
+    if context_mod:
+        result["contextModification"] = context_mod
+    print(json.dumps(result))
+    sys.exit(0)
+
+def main():
+    if not ENABLED:
+        output_allow()
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        output_allow()
+
+    hook_name = data.get("hookName", "")
+    if hook_name != "PreToolUse":
+        output_allow()
+
+    tool = data.get("toolName", "")
+    params = data.get("toolParameters", {})
+    workspace_roots = data.get("workspaceRoots", [])
+
+    # Check if project is indexed
+    is_indexed, is_stale = is_project_indexed(workspace_roots)
+    if not is_indexed:
+        output_allow()
+
+    # Check for discovery patterns
+    if tool == "list_files" or tool == "search_files":
+        pattern = params.get("path", "") or params.get("regex", "")
+        if is_discovery_glob(pattern) or is_discovery_grep(pattern):
+            output_block(
+                f"Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster. Only use local tools if ContextStream returns 0 results.",
+                "[CONTEXTSTREAM] Use ContextStream search for code discovery."
+            )
+
+    elif tool == "read_file":
+        # Allow read_file by default - blocking discovery at search level is enough
+        pass
+
+    output_allow()
+
+if __name__ == "__main__":
+    main()
+`;
+var CLINE_USER_PROMPT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream UserPromptSubmit Hook for Cline
+Injects reminder about ContextStream rules on every message.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+REMINDER = """[CONTEXTSTREAM RULES]
+1. BEFORE list_files/search_files/read_file: mcp__contextstream__search(mode="hybrid") FIRST
+2. Call context_smart at start of EVERY response
+3. Local tools ONLY if ContextStream returns 0 results
+[END RULES]"""
+
+def main():
+    if not ENABLED:
+        print(json.dumps({"cancel": False}))
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        print(json.dumps({"cancel": False}))
+        sys.exit(0)
+
+    print(json.dumps({
+        "cancel": False,
+        "contextModification": REMINDER
+    }))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+function getClineHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), "Documents", "Cline", "Rules", "Hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".clinerules", "hooks");
+}
+async function installClineHookScripts(options) {
+  const hooksDir = getClineHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  await fs4.writeFile(preToolUsePath, CLINE_PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
+  return {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+}
+function getRooCodeHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), ".roo", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".roo", "hooks");
+}
+async function installRooCodeHookScripts(options) {
+  const hooksDir = getRooCodeHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  await fs4.writeFile(preToolUsePath, CLINE_PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
+  return {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+}
+function getKiloCodeHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), ".kilocode", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".kilocode", "hooks");
+}
+async function installKiloCodeHookScripts(options) {
+  const hooksDir = getKiloCodeHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "PreToolUse");
+  const userPromptPath = path5.join(hooksDir, "UserPromptSubmit");
+  await fs4.writeFile(preToolUsePath, CLINE_PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
+  return {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+}
+var CURSOR_PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreToolUse Hook for Cursor
+Blocks discovery tools and redirects to ContextStream search.
+
+Cursor hooks use JSON output format:
+{
+  "decision": "allow" | "deny",
+  "reason": "optional error description"
+}
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+STALE_THRESHOLD_DAYS = 7
+
+DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
+
+def is_discovery_glob(pattern):
+    pattern_lower = pattern.lower()
+    for p in DISCOVERY_PATTERNS:
+        if p in pattern_lower:
+            return True
+    if pattern_lower.startswith("**/*.") or pattern_lower.startswith("**/"):
+        return True
+    if "**" in pattern or "*/" in pattern:
+        return True
+    return False
+
+def is_discovery_grep(file_path):
+    if not file_path or file_path in [".", "./", "*", "**"]:
+        return True
+    if "*" in file_path or "**" in file_path:
+        return True
+    return False
+
+def is_project_indexed(workspace_roots):
+    """Check if any workspace root is in an indexed project."""
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+
+    for workspace in workspace_roots:
+        cwd_path = Path(workspace).resolve()
+        for project_path, info in projects.items():
+            try:
+                indexed_path = Path(project_path).resolve()
+                if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                    indexed_at = info.get("indexed_at")
+                    if indexed_at:
+                        try:
+                            indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                            if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                                return True, True
+                        except:
+                            pass
+                    return True, False
+            except:
+                continue
+    return False, False
+
+def output_allow():
+    print(json.dumps({"decision": "allow"}))
+    sys.exit(0)
+
+def output_deny(reason):
+    print(json.dumps({"decision": "deny", "reason": reason}))
+    sys.exit(0)
+
+def main():
+    if not ENABLED:
+        output_allow()
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        output_allow()
+
+    hook_name = data.get("hook_event_name", "")
+    if hook_name != "preToolUse":
+        output_allow()
+
+    tool = data.get("tool_name", "")
+    params = data.get("tool_input", {}) or data.get("parameters", {})
+    workspace_roots = data.get("workspace_roots", [])
+
+    # Check if project is indexed
+    is_indexed, _ = is_project_indexed(workspace_roots)
+    if not is_indexed:
+        output_allow()
+
+    # Check for Cursor tools
+    if tool in ["Glob", "glob", "list_files"]:
+        pattern = params.get("pattern", "") or params.get("path", "")
+        if is_discovery_glob(pattern):
+            output_deny(
+                f"Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster."
+            )
+
+    elif tool in ["Grep", "grep", "search_files", "ripgrep"]:
+        pattern = params.get("pattern", "") or params.get("regex", "")
+        file_path = params.get("path", "")
+        if is_discovery_grep(file_path):
+            output_deny(
+                f"Use mcp__contextstream__search(mode=\\"keyword\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster."
+            )
+
+    output_allow()
+
+if __name__ == "__main__":
+    main()
+`;
+var CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream BeforeSubmitPrompt Hook for Cursor
+Injects reminder about ContextStream rules.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+def main():
+    if not ENABLED:
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+    print(json.dumps({
+        "continue": True,
+        "user_message": "[CONTEXTSTREAM] Search with mcp__contextstream__search before using Glob/Grep/Read"
+    }))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+function getCursorHooksConfigPath(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), ".cursor", "hooks.json");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".cursor", "hooks.json");
+}
+function getCursorHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path5.join(homedir2(), ".cursor", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path5.join(projectPath, ".cursor", "hooks");
+}
+async function readCursorHooksConfig(scope, projectPath) {
+  const configPath = getCursorHooksConfigPath(scope, projectPath);
+  try {
+    const content = await fs4.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, hooks: {} };
+  }
+}
+async function writeCursorHooksConfig(config, scope, projectPath) {
+  const configPath = getCursorHooksConfigPath(scope, projectPath);
+  const dir = path5.dirname(configPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function installCursorHookScripts(options) {
+  const hooksDir = getCursorHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "contextstream-pretooluse.py");
+  const beforeSubmitPath = path5.join(hooksDir, "contextstream-beforesubmit.py");
+  await fs4.writeFile(preToolUsePath, CURSOR_PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(beforeSubmitPath, CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT, { mode: 493 });
+  const existingConfig = await readCursorHooksConfig(options.scope, options.projectPath);
+  const filterContextStreamHooks = (hooks) => {
+    if (!hooks) return [];
+    return hooks.filter((h) => !h.command?.includes("contextstream"));
+  };
+  const config = {
+    version: 1,
+    hooks: {
+      ...existingConfig.hooks,
+      preToolUse: [
+        ...filterContextStreamHooks(existingConfig.hooks.preToolUse),
+        {
+          command: `python3 "${preToolUsePath}"`,
+          type: "command",
+          timeout: 5,
+          matcher: { tool_name: "Glob|Grep|search_files|list_files|ripgrep" }
+        }
+      ],
+      beforeSubmitPrompt: [
+        ...filterContextStreamHooks(existingConfig.hooks.beforeSubmitPrompt),
+        {
+          command: `python3 "${beforeSubmitPath}"`,
+          type: "command",
+          timeout: 5
+        }
+      ]
+    }
+  };
+  await writeCursorHooksConfig(config, options.scope, options.projectPath);
+  const configPath = getCursorHooksConfigPath(options.scope, options.projectPath);
+  return {
+    preToolUse: preToolUsePath,
+    beforeSubmitPrompt: beforeSubmitPath,
+    config: configPath
+  };
+}
+var WINDSURF_PRE_MCP_TOOL_USE_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream pre_mcp_tool_use Hook for Windsurf
+Blocks discovery tools and redirects to ContextStream search.
+
+Exit codes:
+- 0: Allow action to proceed
+- 2: Block action (message to stderr)
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+
+# Tools to redirect
+DISCOVERY_TOOLS = {
+    "read_file": "Use mcp__contextstream__search(mode=\\"hybrid\\") for discovery",
+    "search_files": "Use mcp__contextstream__search(mode=\\"hybrid\\")",
+    "list_files": "Use mcp__contextstream__search(mode=\\"pattern\\")",
+    "codebase_search": "Use mcp__contextstream__search(mode=\\"hybrid\\")",
+    "grep_search": "Use mcp__contextstream__search(mode=\\"keyword\\")",
+}
+
+def is_project_indexed(workspace_roots):
+    """Check if any workspace has a .contextstream/index marker."""
+    for root in workspace_roots:
+        marker = os.path.join(root, ".contextstream", "index.json")
+        if os.path.exists(marker):
+            return True, root
+    return False, None
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    tool_info = data.get("tool_info", {})
+    tool_name = tool_info.get("tool_name", "")
+
+    # For MCP tools, check the server and tool
+    mcp_server = tool_info.get("mcp_server", "")
+
+    # Get workspace roots from the data
+    workspace_roots = []
+    if "working_directory" in data:
+        workspace_roots.append(data["working_directory"])
+
+    # Check if project is indexed
+    is_indexed, _ = is_project_indexed(workspace_roots)
+    if not is_indexed:
+        sys.exit(0)
+
+    # Check if this is a discovery tool we should redirect
+    if tool_name in DISCOVERY_TOOLS:
+        message = DISCOVERY_TOOLS[tool_name]
+        print(message, file=sys.stderr)
+        sys.exit(2)
+
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+var WINDSURF_PRE_USER_PROMPT_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream pre_user_prompt Hook for Windsurf
+Injects reminder about ContextStream rules.
+
+Note: This hook runs before prompt processing but cannot modify the prompt.
+It primarily serves for logging and validation purposes.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    # Allow the prompt to proceed
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+function getWindsurfHooksConfigPath(scope, projectPath) {
+  if (scope === "project" && projectPath) {
+    return path5.join(projectPath, ".windsurf", "hooks.json");
+  }
+  return path5.join(homedir2(), ".codeium", "windsurf", "hooks.json");
+}
+function getWindsurfHooksDir(scope, projectPath) {
+  if (scope === "project" && projectPath) {
+    return path5.join(projectPath, ".windsurf", "hooks");
+  }
+  return path5.join(homedir2(), ".codeium", "windsurf", "hooks");
+}
+async function readWindsurfHooksConfig(scope, projectPath) {
+  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
+  try {
+    const content = await fs4.promises.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { hooks: {} };
+  }
+}
+async function writeWindsurfHooksConfig(config, scope, projectPath) {
+  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
+  const configDir = path5.dirname(configPath);
+  await fs4.promises.mkdir(configDir, { recursive: true });
+  await fs4.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+function filterWindsurfContextStreamHooks(hooks) {
+  if (!hooks) return [];
+  return hooks.filter((h) => !h.command?.includes("contextstream"));
+}
+async function installWindsurfHookScripts(options) {
+  const scope = options.scope || "global";
+  const hooksDir = getWindsurfHooksDir(scope, options.projectPath);
+  await fs4.promises.mkdir(hooksDir, { recursive: true });
+  const preMcpToolUsePath = path5.join(hooksDir, "contextstream-pretooluse.py");
+  const preUserPromptPath = path5.join(hooksDir, "contextstream-reminder.py");
+  await fs4.promises.writeFile(preMcpToolUsePath, WINDSURF_PRE_MCP_TOOL_USE_SCRIPT);
+  await fs4.promises.writeFile(preUserPromptPath, WINDSURF_PRE_USER_PROMPT_SCRIPT);
+  if (process.platform !== "win32") {
+    await fs4.promises.chmod(preMcpToolUsePath, 493);
+    await fs4.promises.chmod(preUserPromptPath, 493);
+  }
+  const existingConfig = await readWindsurfHooksConfig(scope, options.projectPath);
+  const config = {
+    hooks: {
+      ...existingConfig.hooks,
+      pre_mcp_tool_use: [
+        ...filterWindsurfContextStreamHooks(existingConfig.hooks.pre_mcp_tool_use),
+        {
+          command: `python3 "${preMcpToolUsePath}"`,
+          show_output: true
+        }
+      ],
+      pre_user_prompt: [
+        ...filterWindsurfContextStreamHooks(existingConfig.hooks.pre_user_prompt),
+        {
+          command: `python3 "${preUserPromptPath}"`,
+          show_output: false
+        }
+      ]
+    }
+  };
+  await writeWindsurfHooksConfig(config, scope, options.projectPath);
+  const configPath = getWindsurfHooksConfigPath(scope, options.projectPath);
+  return {
+    preMcpToolUse: preMcpToolUsePath,
+    preUserPrompt: preUserPromptPath,
+    config: configPath
+  };
+}
+async function installEditorHooks(options) {
+  const { editor, scope, projectPath, includePreCompact } = options;
+  switch (editor) {
+    case "claude": {
+      if (scope === "project" && !projectPath) {
+        throw new Error("projectPath required for project scope");
+      }
+      const scripts = await installHookScripts({ includePreCompact });
+      const hooksConfig = buildHooksConfig({ includePreCompact });
+      const settingsScope = scope === "global" ? "user" : "project";
+      const existing = await readClaudeSettings(settingsScope, projectPath);
+      const merged = mergeHooksIntoSettings(existing, hooksConfig);
+      await writeClaudeSettings(merged, settingsScope, projectPath);
+      const installed = [scripts.preToolUse, scripts.userPrompt];
+      if (scripts.preCompact) installed.push(scripts.preCompact);
+      return {
+        editor: "claude",
+        installed,
+        hooksDir: getHooksDir()
+      };
+    }
+    case "cline": {
+      const scripts = await installClineHookScripts({ scope, projectPath });
+      return {
+        editor: "cline",
+        installed: [scripts.preToolUse, scripts.userPromptSubmit],
+        hooksDir: getClineHooksDir(scope, projectPath)
+      };
+    }
+    case "roo": {
+      const scripts = await installRooCodeHookScripts({ scope, projectPath });
+      return {
+        editor: "roo",
+        installed: [scripts.preToolUse, scripts.userPromptSubmit],
+        hooksDir: getRooCodeHooksDir(scope, projectPath)
+      };
+    }
+    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()
+      };
+    }
+    case "windsurf": {
+      const scripts = await installWindsurfHookScripts({ scope, projectPath });
+      return {
+        editor: "windsurf",
+        installed: [scripts.preMcpToolUse, scripts.preUserPrompt],
+        hooksDir: getWindsurfHooksDir(scope, projectPath)
+      };
+    }
+    default:
+      throw new Error(`Unsupported editor: ${editor}`);
+  }
+}
+async function installAllEditorHooks(options) {
+  const editors = options.editors || ["claude", "cline", "roo", "kilo", "cursor", "windsurf"];
+  const results = [];
+  for (const editor of editors) {
+    try {
+      const result = await installEditorHooks({
+        editor,
+        scope: options.scope,
+        projectPath: options.projectPath,
+        includePreCompact: options.includePreCompact
+      });
+      results.push(result);
+    } catch (error) {
+      console.error(`Failed to install hooks for ${editor}:`, error);
+    }
+  }
+  return results;
+}
+
+// src/token-savings.ts
+var TOKEN_SAVINGS_FORMULA_VERSION = 1;
+var MAX_CHARS_PER_EVENT = 2e7;
+var BASE_OVERHEAD_CHARS = 500;
+var CANDIDATE_MULTIPLIERS = {
+  // context_smart: Replaces reading multiple files to gather context
+  context_smart: 5,
+  ai_context_budget: 5,
+  // search: Semantic search replaces iterative Glob/Grep/Read cycles
+  search_semantic: 4.5,
+  search_hybrid: 4,
+  search_keyword: 2.5,
+  search_pattern: 3,
+  search_exhaustive: 3.5,
+  search_refactor: 3,
+  // session: Recall/search replaces reading through history
+  session_recall: 5,
+  session_smart_search: 4,
+  session_user_context: 3,
+  session_summary: 4,
+  // graph: Would require extensive file traversal
+  graph_dependencies: 8,
+  graph_impact: 10,
+  graph_call_path: 8,
+  graph_related: 6,
+  // memory: Context retrieval
+  memory_search: 3.5,
+  memory_decisions: 3,
+  memory_timeline: 3,
+  memory_summary: 4
+};
+function clampCharCount(value) {
+  if (!Number.isFinite(value) || value <= 0) return 0;
+  return Math.min(MAX_CHARS_PER_EVENT, Math.floor(value));
+}
+function trackToolTokenSavings(client, tool, contextText, params, extraMetadata) {
+  try {
+    const contextChars = clampCharCount(contextText.length);
+    const multiplier = CANDIDATE_MULTIPLIERS[tool] ?? 3;
+    const baseOverhead = contextChars > 0 ? BASE_OVERHEAD_CHARS : 0;
+    const estimatedCandidate = Math.round(contextChars * multiplier + baseOverhead);
+    const candidateChars = Math.max(contextChars, clampCharCount(estimatedCandidate));
+    client.trackTokenSavings({
+      tool,
+      workspace_id: params?.workspace_id,
+      project_id: params?.project_id,
+      candidate_chars: candidateChars,
+      context_chars: contextChars,
+      max_tokens: params?.max_tokens,
+      metadata: {
+        method: "multiplier_estimate",
+        formula_version: TOKEN_SAVINGS_FORMULA_VERSION,
+        source: "mcp-server",
+        multiplier,
+        base_overhead_chars: baseOverhead,
+        ...extraMetadata ?? {}
+      }
+    }).catch(() => {
+    });
+  } catch {
+  }
+}
+
+// src/tools.ts
+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";
+var SEARCH_RULES_REMINDER = `
+\u26A0\uFE0F [SEARCH RULES - READ EVERY TIME]
+BEFORE using Glob/Grep/Read/Search/Explore \u2192 call mcp__contextstream__search(mode="hybrid", query="...") FIRST
+BEFORE using EnterPlanMode/Task(Plan) \u2192 call mcp__contextstream__session(action="capture_plan", ...) instead
+Local tools ONLY if ContextStream returns 0 results after retry.
+`.trim();
+var LESSONS_REMINDER_PREFIX = `
+\u{1F6A8} [LESSONS_WARNING] Past Mistakes Found - READ BEFORE PROCEEDING!
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u26A0\uFE0F IMPORTANT: You MUST review these lessons and tell the user about relevant ones.
+These are mistakes from past sessions that you should NOT repeat.
+`.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) {
+    return "";
+  }
+  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 || l.trigger || "";
+    return `${i + 1}. ${severity} ${title}${prevention ? `: ${prevention.slice(0, 100)}` : ""}`;
+  });
+  return `
+
+${LESSONS_REMINDER_PREFIX}
+${lessonLines.join("\n")}
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`;
+}
+function generateRulesUpdateWarning(rulesNotice) {
+  if (!rulesNotice || rulesNotice.status !== "behind" && rulesNotice.status !== "missing") {
+    return "";
+  }
+  const isMissing = rulesNotice.status === "missing";
+  const current = rulesNotice.current ?? "none";
+  const latest = rulesNotice.latest;
+  return `
+\u{1F6A8} [RULES ${isMissing ? "MISSING" : "OUTDATED"} - ACTION REQUIRED]
+${isMissing ? "ContextStream rules are NOT installed." : `Rules version ${current} \u2192 ${latest} available.`}
+${isMissing ? "AI behavior may be suboptimal without proper rules." : "New rules include important improvements for better AI behavior."}
+
+**UPDATE NOW:** Run \`mcp__contextstream__generate_rules(overwrite_existing=true)\`
+This is SAFE - only the ContextStream block is updated, your custom rules are preserved.
+`.trim();
+}
+function generateVersionUpdateWarning(versionNotice) {
+  if (!versionNotice?.behind) {
+    return "";
+  }
+  return `
+\u{1F6A8} [VERSION_NOTICE] MCP Server Update Available!
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+Version: ${versionNotice.current} \u2192 ${versionNotice.latest}
+
+\u26A0\uFE0F IMPORTANT: You MUST tell the user about this update IMMEDIATELY.
+Do not proceed with other work until you have informed the user.
+
+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 = {
+  api_key: "ContextStream API key.",
+  apiKey: "ContextStream API key.",
+  jwt: "ContextStream JWT for authentication.",
+  workspace_id: "Workspace ID (UUID).",
+  workspaceId: "Workspace ID (UUID).",
+  project_id: "Project ID (UUID).",
+  projectId: "Project ID (UUID).",
+  node_id: "Node ID (UUID).",
   event_id: "Event ID (UUID).",
   reminder_id: "Reminder ID (UUID).",
   folder_path: "Absolute path to the local folder.",
@@ -10618,13 +11839,17 @@ function resolveAuthOverride(extra) {
   return { workspaceId, projectId };
 }
 var LIGHT_TOOLSET = /* @__PURE__ */ new Set([
-  // Core session tools (13)
+  // Core session tools (15)
   "session_init",
   "session_tools",
   "context_smart",
   "context_feedback",
   "session_summary",
   "session_capture",
+  "session_capture_smart",
+  // Pre-compaction state capture
+  "session_restore_context",
+  // Post-compaction context restore
   "session_capture_lesson",
   "session_get_lessons",
   "session_recall",
@@ -10664,13 +11889,17 @@ var LIGHT_TOOLSET = /* @__PURE__ */ new Set([
   "mcp_server_version"
 ]);
 var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
-  // Core session tools (14)
+  // Core session tools (16)
   "session_init",
   "session_tools",
   "context_smart",
   "context_feedback",
   "session_summary",
   "session_capture",
+  "session_capture_smart",
+  // Pre-compaction state capture
+  "session_restore_context",
+  // Post-compaction context restore
   "session_capture_lesson",
   "session_get_lessons",
   "session_recall",
@@ -10790,6 +12019,7 @@ var ALL_INTEGRATION_TOOLS = /* @__PURE__ */ new Set([
   ...CROSS_INTEGRATION_TOOLS
 ]);
 var AUTO_HIDE_INTEGRATIONS = process.env.CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS !== "false";
+var RESTORE_CONTEXT_DEFAULT = process.env.CONTEXTSTREAM_RESTORE_CONTEXT !== "false";
 var TOKEN_SENSITIVE_CLIENTS = /* @__PURE__ */ new Set([
   "claude",
   "claude-code",
@@ -11121,6 +12351,7 @@ function parsePositiveInt(raw, fallback) {
 }
 var OUTPUT_FORMAT = process.env.CONTEXTSTREAM_OUTPUT_FORMAT || "compact";
 var COMPACT_OUTPUT = OUTPUT_FORMAT === "compact";
+var SHOW_TIMING = process.env.CONTEXTSTREAM_SHOW_TIMING === "true" || process.env.CONTEXTSTREAM_SHOW_TIMING === "1";
 var DEFAULT_SEARCH_LIMIT = parsePositiveInt(process.env.CONTEXTSTREAM_SEARCH_LIMIT, 3);
 var DEFAULT_SEARCH_CONTENT_MAX_CHARS = parsePositiveInt(
   process.env.CONTEXTSTREAM_SEARCH_MAX_CHARS,
@@ -11233,6 +12464,31 @@ function toStructured(data) {
   }
   return void 0;
 }
+function formatTimingSummary(roundTripMs, resultCount) {
+  if (!SHOW_TIMING) return "";
+  const countStr = resultCount !== void 0 ? `${resultCount} results` : "done";
+  return `\u2713 ${countStr} in ${roundTripMs}ms
+
+`;
+}
+function getResultCount(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const response = data;
+  const dataObj = response.data;
+  if (dataObj?.results && Array.isArray(dataObj.results)) {
+    return dataObj.results.length;
+  }
+  if (typeof dataObj?.total === "number") {
+    return dataObj.total;
+  }
+  if (typeof dataObj?.count === "number") {
+    return dataObj.count;
+  }
+  if (dataObj?.paths && Array.isArray(dataObj.paths)) {
+    return dataObj.paths.length;
+  }
+  return void 0;
+}
 function readStatNumber(payload, key) {
   if (!payload || typeof payload !== "object") return void 0;
   const direct = payload[key];
@@ -13553,10 +14809,17 @@ This does semantic search on the first message. You only need context_smart on s
         auto_index: external_exports.boolean().optional().describe("Automatically create and index project from IDE workspace (default: true)"),
         allow_no_workspace: external_exports.boolean().optional().describe(
           "If true, allow session_init to return connected even if no workspace is resolved (workspace-level tools may not work)."
+        ),
+        skip_project_creation: external_exports.boolean().optional().describe(
+          "If true, skip automatic project creation/matching. Use for parent folders containing multiple projects where you want workspace-level context but no project-specific context."
+        ),
+        is_post_compact: external_exports.boolean().optional().describe(
+          "Controls context restoration from recent snapshots. Defaults to true (always restores). Set to false to skip restoration. Can also be controlled via CONTEXTSTREAM_RESTORE_CONTEXT environment variable."
         )
       })
     },
     async (input) => {
+      const startTime = Date.now();
       let ideRoots = [];
       try {
         const rootsResponse = await server.server.listRoots();
@@ -13572,8 +14835,90 @@ This does semantic search on the first message. You only need context_smart on s
       }
       const result = await client.initSession(input, ideRoots);
       result.tools_hint = getCoreToolsHint();
+      const shouldRestoreContext = input.is_post_compact ?? RESTORE_CONTEXT_DEFAULT;
+      if (shouldRestoreContext) {
+        result.is_post_compact = true;
+        const workspaceIdForRestore = typeof result.workspace_id === "string" ? result.workspace_id : void 0;
+        const projectIdForRestore = typeof result.project_id === "string" ? result.project_id : void 0;
+        if (workspaceIdForRestore) {
+          try {
+            const listResult = await client.listMemoryEvents({
+              workspace_id: workspaceIdForRestore,
+              project_id: projectIdForRestore,
+              limit: 50
+            });
+            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;
+              try {
+                snapshotData = JSON.parse(latestSnapshot.content);
+              } catch {
+                snapshotData = { conversation_summary: latestSnapshot.content };
+              }
+              const prevSessionId = snapshotData.session_id || latestSnapshot.session_id;
+              const sessionLinking = {};
+              if (prevSessionId) {
+                sessionLinking.previous_session_id = prevSessionId;
+                const workingOn = [];
+                const activeFiles = snapshotData.active_files;
+                const lastTools = snapshotData.last_tools;
+                if (activeFiles && activeFiles.length > 0) {
+                  workingOn.push(`Files: ${activeFiles.slice(0, 5).join(", ")}${activeFiles.length > 5 ? ` (+${activeFiles.length - 5} more)` : ""}`);
+                }
+                if (lastTools && lastTools.length > 0) {
+                  const toolCounts = lastTools.reduce((acc, tool) => {
+                    acc[tool] = (acc[tool] || 0) + 1;
+                    return acc;
+                  }, {});
+                  const topTools = Object.entries(toolCounts).sort(([, a], [, b]) => b - a).slice(0, 3).map(([tool]) => tool);
+                  workingOn.push(`Recent tools: ${topTools.join(", ")}`);
+                }
+                if (workingOn.length > 0) {
+                  sessionLinking.previous_session_summary = workingOn.join("; ");
+                }
+                const relatedSessionIds = /* @__PURE__ */ new Set();
+                snapshots.forEach((s) => {
+                  let sData;
+                  try {
+                    sData = JSON.parse(s.content || "{}");
+                  } catch {
+                    sData = {};
+                  }
+                  const sSessionId = sData.session_id || s.session_id;
+                  if (sSessionId && sSessionId !== prevSessionId) {
+                    relatedSessionIds.add(sSessionId);
+                  }
+                });
+                if (relatedSessionIds.size > 0) {
+                  sessionLinking.related_sessions = Array.from(relatedSessionIds);
+                }
+              }
+              result.restored_context = {
+                snapshot_id: latestSnapshot.id,
+                captured_at: snapshotData.captured_at || latestSnapshot.created_at,
+                session_linking: Object.keys(sessionLinking).length > 0 ? sessionLinking : void 0,
+                ...snapshotData
+              };
+              result.is_post_compact = true;
+              result.post_compact_hint = prevSessionId ? `Session restored from session ${prevSessionId}. Review 'restored_context' to continue where you left off.` : "Session restored from pre-compaction snapshot. Review the 'restored_context' to continue where you left off.";
+            } 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);
+            result.is_post_compact = true;
+            result.post_compact_hint = "Post-compaction session started. Snapshot restoration failed, use context_smart for context.";
+          }
+        }
+      }
       if (sessionManager) {
         sessionManager.markInitialized(result);
+        sessionManager.resetTokenCount();
       }
       const folderPathForRules = input.folder_path || ideRoots[0] || resolveFolderPath(void 0, sessionManager);
       if (sessionManager && folderPathForRules) {
@@ -13720,6 +15065,12 @@ ${noticeLines.filter(Boolean).join("\n")}`;
         text = `${text}
 
 ${SEARCH_RULES_REMINDER}`;
+      }
+      const roundTripMs = Date.now() - startTime;
+      if (SHOW_TIMING) {
+        text = `\u2713 session initialized in ${roundTripMs}ms
+
+${text}`;
       }
       return {
         content: [{ type: "text", text }],
@@ -13997,8 +15348,11 @@ Use this to persist decisions, insights, preferences, or important information.`
           // Extracted lesson from correction
           "warning",
           // Proactive reminder
-          "frustration"
+          "frustration",
           // User expressed frustration
+          // Compaction awareness
+          "session_snapshot"
+          // Pre-compaction state capture
         ]).describe("Type of context being captured"),
         title: external_exports.string().describe("Brief title for the captured context"),
         content: external_exports.string().describe("Full content/details to capture"),
@@ -14030,27 +15384,245 @@ Use this to persist decisions, insights, preferences, or important information.`
           workspaceId = ctx.workspace_id;
           projectId = projectId || ctx.project_id;
         }
-      }
-      if (!workspaceId) {
+      }
+      if (!workspaceId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+            }
+          ],
+          isError: true
+        };
+      }
+      const result = await client.captureContext({
+        ...input,
+        workspace_id: workspaceId,
+        project_id: projectId
+      });
+      return {
+        content: [{ type: "text", text: formatContent(result) }],
+        structuredContent: toStructured(result)
+      };
+    }
+  );
+  registerTool(
+    "session_capture_smart",
+    {
+      title: "Smart capture for conversation compaction",
+      description: `Intelligently capture conversation state before compaction or context loss.
+This creates a session_snapshot that can be restored after compaction.
+
+Use when:
+- Context pressure is high/critical (context_smart returns threshold_warning)
+- Before manual /compact commands
+- When significant work progress needs preservation
+
+Captures:
+- Conversation summary and current goals
+- Active files being worked on
+- Recent decisions with rationale
+- Unfinished work items
+- User preferences expressed in session
+
+The snapshot is automatically prioritized during post-compaction session_init.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        project_id: external_exports.string().uuid().optional(),
+        conversation_summary: external_exports.string().describe("AI's summary of the conversation so far - what was discussed and accomplished"),
+        current_goal: external_exports.string().optional().describe("The primary goal or task being worked on"),
+        active_files: external_exports.array(external_exports.string()).optional().describe("List of files currently being worked on"),
+        recent_decisions: external_exports.array(
+          external_exports.object({
+            title: external_exports.string(),
+            rationale: external_exports.string().optional()
+          })
+        ).optional().describe("Key decisions made in this session with their rationale"),
+        unfinished_work: external_exports.array(
+          external_exports.object({
+            task: external_exports.string(),
+            status: external_exports.string().optional(),
+            next_steps: external_exports.string().optional()
+          })
+        ).optional().describe("Work items that are in progress or pending"),
+        user_preferences: external_exports.array(external_exports.string()).optional().describe("Preferences expressed by user during this session"),
+        priority_items: external_exports.array(external_exports.string()).optional().describe("User-flagged important items to remember"),
+        metadata: external_exports.record(external_exports.unknown()).optional().describe("Additional context to preserve")
+      })
+    },
+    async (input) => {
+      let workspaceId = input.workspace_id;
+      let projectId = input.project_id;
+      if (!workspaceId && sessionManager) {
+        const ctx = sessionManager.getContext();
+        if (ctx) {
+          workspaceId = ctx.workspace_id;
+          projectId = projectId || ctx.project_id;
+        }
+      }
+      if (!workspaceId) {
+        return errorResult(
+          "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+        );
+      }
+      const snapshotContent = {
+        conversation_summary: input.conversation_summary,
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (input.current_goal) {
+        snapshotContent.current_goal = input.current_goal;
+      }
+      if (input.active_files?.length) {
+        snapshotContent.active_files = input.active_files;
+      }
+      if (input.recent_decisions?.length) {
+        snapshotContent.recent_decisions = input.recent_decisions;
+      }
+      if (input.unfinished_work?.length) {
+        snapshotContent.unfinished_work = input.unfinished_work;
+      }
+      if (input.user_preferences?.length) {
+        snapshotContent.user_preferences = input.user_preferences;
+      }
+      if (input.priority_items?.length) {
+        snapshotContent.priority_items = input.priority_items;
+      }
+      if (input.metadata) {
+        snapshotContent.metadata = input.metadata;
+      }
+      const result = await client.captureContext({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        event_type: "session_snapshot",
+        title: `Session Snapshot: ${input.current_goal || "Conversation State"}`,
+        content: JSON.stringify(snapshotContent, null, 2),
+        importance: "high",
+        tags: ["session_snapshot", "pre_compaction"]
+      });
+      const response = {
+        ...result,
+        snapshot_id: result?.data?.id || result?.id,
+        message: "Session state captured successfully. This snapshot will be prioritized after compaction.",
+        hint: "After compaction, call session_init with is_post_compact=true to restore this context."
+      };
+      return {
+        content: [{ type: "text", text: formatContent(response) }],
+        structuredContent: toStructured(response)
+      };
+    }
+  );
+  registerTool(
+    "session_restore_context",
+    {
+      title: "Restore context after compaction",
+      description: `Restore conversation context after compaction or context loss.
+Call this after conversation compaction to retrieve saved session state.
+
+Returns structured context including:
+- conversation_summary: What was being discussed
+- current_goal: The primary task being worked on
+- active_files: Files that were being modified
+- recent_decisions: Key decisions made in the session
+- unfinished_work: Tasks that are still in progress
+- user_preferences: Preferences expressed during the session
+
+Use this in combination with session_init(is_post_compact=true) for seamless continuation.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        project_id: external_exports.string().uuid().optional(),
+        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) => {
+      let workspaceId = input.workspace_id;
+      let projectId = input.project_id;
+      if (!workspaceId && sessionManager) {
+        const ctx = sessionManager.getContext();
+        if (ctx) {
+          workspaceId = ctx.workspace_id;
+          projectId = projectId || ctx.project_id;
+        }
+      }
+      if (!workspaceId) {
+        return errorResult(
+          "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+        );
+      }
+      try {
+        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 snapshotData2;
+          try {
+            snapshotData2 = JSON.parse(event.content);
+          } catch {
+            snapshotData2 = { conversation_summary: event.content };
+          }
+          const response2 = {
+            restored: true,
+            snapshot_id: event.id,
+            captured_at: snapshotData2.captured_at || event.created_at,
+            ...snapshotData2,
+            hint: "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 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: [
+              {
+                type: "text",
+                text: formatContent({
+                  restored: false,
+                  message: "No session snapshots found. This may be a new session or snapshots have not been captured.",
+                  hint: "Use session_capture_smart to save session state before compaction."
+                })
+              }
+            ]
+          };
+        }
+        const latestEvent = events[0];
+        let snapshotData;
+        try {
+          snapshotData = JSON.parse(latestEvent.content);
+        } catch {
+          snapshotData = { conversation_summary: latestEvent.content };
+        }
+        const response = {
+          restored: true,
+          snapshot_id: latestEvent.id,
+          captured_at: snapshotData.captured_at || latestEvent.created_at,
+          ...snapshotData,
+          hint: "Context restored. Continue the conversation with awareness of the above state."
+        };
         return {
-          content: [
-            {
-              type: "text",
-              text: "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
-            }
-          ],
-          isError: true
+          content: [{ type: "text", text: formatContent(response) }],
+          structuredContent: toStructured(response)
         };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResult(`Failed to restore context: ${message}`);
       }
-      const result = await client.captureContext({
-        ...input,
-        workspace_id: workspaceId,
-        project_id: projectId
-      });
-      return {
-        content: [{ type: "text", text: formatContent(result) }],
-        structuredContent: toStructured(result)
-      };
     }
   );
   registerTool(
@@ -14411,6 +15983,7 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
         overwrite_existing: external_exports.boolean().optional().describe("Allow overwriting existing rule files (ContextStream block only)"),
         apply_global: external_exports.boolean().optional().describe("Also write global rule files for supported editors"),
         install_hooks: external_exports.boolean().optional().describe("Install Claude Code hooks to enforce ContextStream-first search. Defaults to true for Claude users. Set to false to skip."),
+        include_pre_compact: external_exports.boolean().optional().describe("Include PreCompact hook for automatic state saving before context compaction. Defaults to false."),
         dry_run: external_exports.boolean().optional().describe("If true, return content without writing files")
       })
     },
@@ -14481,28 +16054,77 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
       const globalPrompt = input.apply_global ? "Global rule update complete." : globalTargets.length > 0 ? "Apply rules globally too? Re-run with apply_global: true." : "No global rule locations are known for these editors.";
       let hooksResults;
       let hooksPrompt;
-      const hasClaude = editors.includes("claude");
-      const shouldInstallHooks = hasClaude && input.install_hooks !== false;
+      const editorHookMap = {
+        claude: "claude",
+        cline: "cline",
+        roo: "roo",
+        kilo: "kilo",
+        cursor: "cursor",
+        windsurf: "windsurf"
+      };
+      const hookSupportedEditors = editors.filter((e) => e in editorHookMap);
+      const shouldInstallHooks = hookSupportedEditors.length > 0 && input.install_hooks !== false;
       if (shouldInstallHooks) {
         try {
           if (input.dry_run) {
-            hooksResults = [
-              { file: "~/.claude/hooks/contextstream-redirect.py", status: "dry run - would create" },
-              { file: "~/.claude/hooks/contextstream-reminder.py", status: "dry run - would create" },
-              { file: "~/.claude/settings.json", status: "dry run - would update" }
-            ];
+            hooksResults = [];
+            for (const editor of hookSupportedEditors) {
+              if (editor === "claude") {
+                hooksResults.push(
+                  { editor, file: "~/.claude/hooks/contextstream-redirect.py", status: "dry run - would create" },
+                  { editor, file: "~/.claude/hooks/contextstream-reminder.py", status: "dry run - would create" },
+                  { editor, file: "~/.claude/settings.json", status: "dry run - would update" }
+                );
+                if (input.include_pre_compact) {
+                  hooksResults.push({ editor, file: "~/.claude/hooks/contextstream-precompact.py", status: "dry run - would create" });
+                }
+              } else if (editor === "cline") {
+                hooksResults.push(
+                  { editor, file: "~/Documents/Cline/Rules/Hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/Documents/Cline/Rules/Hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "roo") {
+                hooksResults.push(
+                  { editor, file: "~/.roo/hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/.roo/hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "kilo") {
+                hooksResults.push(
+                  { editor, file: "~/.kilocode/hooks/PreToolUse", status: "dry run - would create" },
+                  { editor, file: "~/.kilocode/hooks/UserPromptSubmit", status: "dry run - would create" }
+                );
+              } else if (editor === "cursor") {
+                hooksResults.push(
+                  { editor, file: "~/.cursor/hooks/contextstream-pretooluse.py", status: "dry run - would create" },
+                  { editor, file: "~/.cursor/hooks/contextstream-beforesubmit.py", status: "dry run - would create" },
+                  { editor, file: "~/.cursor/hooks.json", status: "dry run - would update" }
+                );
+              } else if (editor === "windsurf") {
+                hooksResults.push(
+                  { editor, file: "~/.codeium/windsurf/hooks/contextstream-pretooluse.py", status: "dry run - would create" },
+                  { editor, file: "~/.codeium/windsurf/hooks/contextstream-reminder.py", status: "dry run - would create" },
+                  { editor, file: "~/.codeium/windsurf/hooks.json", status: "dry run - would update" }
+                );
+              }
+            }
           } else {
-            const hookResult = await installClaudeCodeHooks({ scope: "user" });
-            hooksResults = [
-              ...hookResult.scripts.map((f) => ({ file: f, status: "created" })),
-              ...hookResult.settings.map((f) => ({ file: f, status: "updated" }))
-            ];
+            hooksResults = [];
+            const allHookResults = await installAllEditorHooks({
+              scope: "global",
+              editors: hookSupportedEditors,
+              includePreCompact: input.include_pre_compact
+            });
+            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,
@@ -14851,10 +16473,13 @@ This saves ~80% tokens compared to including full chat history.`,
         max_tokens: external_exports.number().optional().describe("Maximum tokens for context (default: 800)"),
         format: external_exports.enum(["minified", "readable", "structured"]).optional().describe("Context format (default: minified)"),
         mode: external_exports.enum(["standard", "pack"]).optional().describe("Context pack mode (default: pack when enabled)"),
-        distill: external_exports.boolean().optional().describe("Use distillation for context pack (default: true)")
+        distill: external_exports.boolean().optional().describe("Use distillation for context pack (default: true)"),
+        session_tokens: external_exports.number().optional().describe("Cumulative session token count for context pressure calculation"),
+        context_threshold: external_exports.number().optional().describe("Custom context window threshold (defaults to 70k)")
       })
     },
     async (input) => {
+      const startTime = Date.now();
       if (sessionManager) {
         sessionManager.markContextSmartCalled();
       }
@@ -14867,6 +16492,63 @@ This saves ~80% tokens compared to including full chat history.`,
           projectId = projectId || ctx.project_id;
         }
       }
+      let sessionTokens = input.session_tokens;
+      let contextThreshold = input.context_threshold;
+      if (sessionManager) {
+        if (sessionTokens === void 0) {
+          sessionTokens = sessionManager.getSessionTokens();
+        }
+        if (contextThreshold === void 0) {
+          contextThreshold = sessionManager.getContextThreshold();
+        }
+        sessionManager.addTokens(input.user_message);
+      }
+      let postCompactContext = "";
+      let postCompactRestored = false;
+      if (sessionManager && sessionManager.shouldRestorePostCompact() && workspaceId) {
+        try {
+          const listResult = await client.listMemoryEvents({
+            workspace_id: workspaceId,
+            project_id: projectId,
+            limit: 20
+          });
+          const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
+          const snapshotEvent = allEvents.find(
+            (e) => e.event_type === "session_snapshot" || e.metadata?.original_type === "session_snapshot" || e.tags?.includes("session_snapshot")
+          );
+          if (snapshotEvent && snapshotEvent.content) {
+            let snapshotData;
+            try {
+              snapshotData = JSON.parse(snapshotEvent.content);
+            } catch {
+              snapshotData = { conversation_summary: snapshotEvent.content };
+            }
+            const summary = snapshotData.conversation_summary || snapshotData.summary || "";
+            const decisions = snapshotData.key_decisions || [];
+            const unfinished = snapshotData.unfinished_work || snapshotData.pending_tasks || [];
+            const files = snapshotData.active_files || [];
+            const parts = [];
+            parts.push("\u{1F4CB} [POST-COMPACTION CONTEXT RESTORED]");
+            if (summary) parts.push(`Summary: ${summary}`);
+            if (Array.isArray(decisions) && decisions.length > 0) {
+              parts.push(`Decisions: ${decisions.slice(0, 5).join("; ")}`);
+            }
+            if (Array.isArray(unfinished) && unfinished.length > 0) {
+              parts.push(`Unfinished: ${unfinished.slice(0, 3).join("; ")}`);
+            }
+            if (Array.isArray(files) && files.length > 0) {
+              parts.push(`Active files: ${files.slice(0, 5).join(", ")}`);
+            }
+            parts.push("---");
+            postCompactContext = parts.join("\n") + "\n\n";
+            postCompactRestored = true;
+            sessionManager.markPostCompactRestoreCompleted();
+            console.error("[ContextStream] Post-compaction context restored automatically");
+          }
+        } catch (err) {
+          console.error("[ContextStream] Failed to restore post-compact context:", err);
+        }
+      }
       const result = await client.getSmartContext({
         user_message: input.user_message,
         workspace_id: workspaceId,
@@ -14874,11 +16556,18 @@ This saves ~80% tokens compared to including full chat history.`,
         max_tokens: input.max_tokens,
         format: input.format,
         mode: input.mode,
-        distill: input.distill
+        distill: input.distill,
+        session_tokens: sessionTokens,
+        context_threshold: contextThreshold
       });
+      if (sessionManager && result.token_estimate) {
+        sessionManager.addTokens(result.token_estimate);
+      }
+      const roundTripMs = Date.now() - startTime;
+      const timingStr = SHOW_TIMING ? ` | ${roundTripMs}ms` : "";
       const footer = `
 ---
-\u{1F3AF} ${result.sources_used} sources | ~${result.token_estimate} tokens | format: ${result.format}`;
+\u{1F3AF} ${result.sources_used} sources | ~${result.token_estimate} tokens | format: ${result.format}${timingStr}`;
       const folderPathForRules = resolveFolderPath(void 0, sessionManager);
       const rulesNotice = getRulesNotice(folderPathForRules, detectedClientInfo?.name);
       let versionNotice = result.version_notice;
@@ -14900,11 +16589,69 @@ 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}` : "";
+      let contextPressureWarning = "";
+      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 allWarnings = [
         lessonsWarningLine,
         rulesWarningLine ? `
@@ -14913,16 +16660,19 @@ ${rulesWarningLine}` : "",
         versionWarningLine ? `
 
 ${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)
       };
     }
   );
@@ -15943,6 +17693,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       },
       async (input) => {
         const params = normalizeSearchParams(input);
+        const startTime = Date.now();
         let result;
         let toolType;
         switch (input.mode) {
@@ -15973,7 +17724,9 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           default:
             toolType = "search_hybrid";
         }
-        const outputText = formatContent(result);
+        const roundTripMs = Date.now() - startTime;
+        const timingSummary = formatTimingSummary(roundTripMs, getResultCount(result));
+        const outputText = timingSummary + formatContent(result);
         trackToolTokenSavings(client, toolType, outputText, {
           workspace_id: params.workspace_id,
           project_id: params.project_id
@@ -15988,7 +17741,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",
@@ -16006,7 +17759,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(),
@@ -16028,7 +17783,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(),
@@ -16078,7 +17834,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) => {
@@ -16384,6 +18143,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}`);
         }
@@ -18948,7 +20844,7 @@ function registerPrompts(server) {
 }
 
 // src/session-manager.ts
-var SessionManager = class {
+var SessionManager = class _SessionManager {
   constructor(server, client) {
     this.server = server;
     this.client = client;
@@ -18959,6 +20855,31 @@ var SessionManager = class {
     this.folderPath = null;
     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
@@ -19001,10 +20922,124 @@ 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).
+   */
+  getContextThreshold() {
+    return this.contextThreshold;
+  }
+  /**
+   * Set a custom context threshold (useful if client provides model info).
+   */
+  setContextThreshold(threshold) {
+    this.contextThreshold = threshold;
+  }
+  /**
+   * Add tokens to the session count.
+   * Call this after each tool response to track token accumulation.
+   *
+   * @param tokens - Exact token count or text to estimate
+   */
+  addTokens(tokens) {
+    if (typeof tokens === "number") {
+      this.sessionTokens += tokens;
+    } else {
+      this.sessionTokens += Math.ceil(tokens.length / 4);
+    }
+  }
+  /**
+   * Estimate tokens from a tool response.
+   * Uses a simple heuristic: ~4 characters per token.
+   */
+  estimateTokens(content) {
+    const text = typeof content === "string" ? content : JSON.stringify(content);
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Reset token count (e.g., after compaction or new session).
+   */
+  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.
@@ -19270,6 +21305,112 @@ var SessionManager = class {
     parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
     return parts.join("\n");
   }
+  // =========================================================================
+  // Continuous Checkpointing
+  // =========================================================================
+  /**
+   * Track a tool call for checkpointing purposes.
+   * Call this after each tool execution to track files and trigger periodic checkpoints.
+   */
+  trackToolCall(toolName, input) {
+    this.toolCallCount++;
+    this.recentToolCalls.push({ name: toolName, timestamp: Date.now() });
+    if (this.recentToolCalls.length > 50) {
+      this.recentToolCalls = this.recentToolCalls.slice(-50);
+    }
+    if (input) {
+      const filePath = input.file_path || input.notebook_path || input.path;
+      if (filePath && typeof filePath === "string") {
+        this.activeFiles.add(filePath);
+        if (this.activeFiles.size > 30) {
+          const arr = Array.from(this.activeFiles);
+          this.activeFiles = new Set(arr.slice(-30));
+        }
+      }
+    }
+    this.maybeCheckpoint();
+  }
+  /**
+   * Save a checkpoint if the interval has been reached.
+   */
+  async maybeCheckpoint() {
+    if (!this.checkpointEnabled || !this.initialized || !this.context) {
+      return;
+    }
+    const callsSinceLastCheckpoint = this.toolCallCount - this.lastCheckpointAt;
+    if (callsSinceLastCheckpoint < this.checkpointInterval) {
+      return;
+    }
+    this.lastCheckpointAt = this.toolCallCount;
+    await this.saveCheckpoint("periodic");
+  }
+  /**
+   * Get the list of active files being worked on.
+   */
+  getActiveFiles() {
+    return Array.from(this.activeFiles);
+  }
+  /**
+   * Get recent tool call names.
+   */
+  getRecentToolNames() {
+    return this.recentToolCalls.map((t) => t.name);
+  }
+  /**
+   * Get the current tool call count.
+   */
+  getToolCallCount() {
+    return this.toolCallCount;
+  }
+  /**
+   * Save a checkpoint snapshot to ContextStream.
+   */
+  async saveCheckpoint(trigger) {
+    if (!this.initialized || !this.context) {
+      return false;
+    }
+    const workspaceId = this.context.workspace_id;
+    if (!workspaceId) {
+      return false;
+    }
+    const checkpointData = {
+      trigger,
+      checkpoint_number: Math.floor(this.toolCallCount / this.checkpointInterval),
+      tool_call_count: this.toolCallCount,
+      session_tokens: this.sessionTokens,
+      active_files: this.getActiveFiles(),
+      recent_tools: this.getRecentToolNames().slice(-10),
+      captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+      auto_captured: true
+    };
+    try {
+      await this.client.captureContext({
+        workspace_id: workspaceId,
+        project_id: this.context.project_id,
+        event_type: "session_snapshot",
+        title: `Checkpoint #${checkpointData.checkpoint_number} (${trigger})`,
+        content: JSON.stringify(checkpointData),
+        importance: trigger === "periodic" ? "low" : "medium",
+        tags: ["session_snapshot", "checkpoint", trigger]
+      });
+      return true;
+    } catch (err) {
+      console.error("[ContextStream] Failed to save checkpoint:", err);
+      return false;
+    }
+  }
+  /**
+   * Enable or disable continuous checkpointing.
+   */
+  setCheckpointEnabled(enabled) {
+    this.checkpointEnabled = enabled;
+  }
+  /**
+   * Set the checkpoint interval (tool calls between checkpoints).
+   */
+  setCheckpointInterval(interval) {
+    this.checkpointInterval = Math.max(5, interval);
+  }
 };
 
 // src/http-gateway.ts
@@ -20025,6 +22166,12 @@ 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";
+  }
   if (IS_WINDOWS) {
     return {
       command: "cmd",
@@ -20047,6 +22194,12 @@ 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";
+  }
   if (IS_WINDOWS) {
     return {
       type: "stdio",
@@ -20147,6 +22300,10 @@ 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"
 args = ["/c", "npx", "-y", "@contextstream/mcp-server"]
 ` : `command = "npx"
@@ -20160,7 +22317,7 @@ args = ["-y", "@contextstream/mcp-server"]
 [mcp_servers.contextstream.env]
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
-` + toolsetLine + contextPackLine;
+` + toolsetLine + contextPackLine + restoreContextLine + showTimingLine;
   if (!exists) {
     await fs7.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
@@ -20517,6 +22674,17 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     console.log("  Uses more operations/credits; can be disabled in settings or via env.");
     const contextPackChoice = normalizeInput(await rl.question("Enable Context Pack? [Y/n]: "));
     const contextPackEnabled = !(contextPackChoice.toLowerCase() === "n" || contextPackChoice.toLowerCase() === "no");
+    console.log("\nResponse Timing:");
+    console.log("  Show response time for tool calls (e.g., '\u2713 3 results in 142ms').");
+    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",
@@ -20567,7 +22735,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     console.log("  1) Global");
     console.log("  2) Project");
     console.log("  3) Both");
-    const scopeChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 3): ")) || "3";
+    const scopeChoice = normalizeInput(await rl.question("Choose [1/2/3] (default 2): ")) || "2";
     const scope = scopeChoice === "1" ? "global" : scopeChoice === "2" ? "project" : "both";
     console.log("\nInstall MCP server config as:");
     if (hasCodex && !hasProjectMcpEditors) {
@@ -20591,18 +22759,22 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
       )
     ) || mcpChoiceDefault;
     const mcpScope = mcpChoice === "2" && hasCodex && !hasProjectMcpEditors ? "skip" : mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
-    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled });
+    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled, showTiming, restoreContextEnabled });
     const mcpServerClaude = buildContextStreamMcpServer({
       apiUrl,
       apiKey,
       toolset,
-      contextPackEnabled
+      contextPackEnabled,
+      showTiming,
+      restoreContextEnabled
     });
     const vsCodeServer = buildContextStreamVsCodeServer({
       apiUrl,
       apiKey,
       toolset,
-      contextPackEnabled
+      contextPackEnabled,
+      showTiming,
+      restoreContextEnabled
     });
     const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
     if (needsGlobalMcpConfig) {
@@ -20621,7 +22793,9 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
               apiUrl,
               apiKey,
               toolset,
-              contextPackEnabled
+              contextPackEnabled,
+              showTiming,
+              restoreContextEnabled
             });
             writeActions.push({ kind: "mcp-config", target: filePath, status });
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
@@ -20703,53 +22877,69 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         }
       }
     }
-    if (configuredEditors.includes("claude")) {
+    const HOOKS_SUPPORTED_EDITORS = {
+      claude: "claude",
+      cursor: "cursor",
+      windsurf: "windsurf",
+      cline: "cline",
+      roo: "roo",
+      kilo: "kilo",
+      codex: null,
+      // No hooks API
+      aider: null,
+      // No hooks API
+      antigravity: null
+      // No hooks API
+    };
+    const hookEligibleEditors = configuredEditors.filter(
+      (e) => HOOKS_SUPPORTED_EDITORS[e] !== null
+    );
+    if (hookEligibleEditors.length > 0) {
       console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-      console.log("\u2502  Claude Code Hooks (Recommended)                                \u2502");
+      console.log("\u2502  AI Editor Hooks (Recommended)                                  \u2502");
       console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
       console.log("");
-      console.log("  Problem: Claude Code often ignores CLAUDE.md instructions and uses");
-      console.log("  its default tools (Grep/Glob/Search) instead of ContextStream search.");
-      console.log("  This happens because instructions decay over long conversations.");
+      console.log("  Problem: AI editors often use their default tools (Grep/Glob/Search)");
+      console.log("  instead of ContextStream smart search. Instructions decay over long chats.");
       console.log("");
       console.log("  Solution: Install hooks that:");
-      console.log("  \u2713 Block default search tools (Grep/Glob/Search) \u2192 redirect to ContextStream");
-      console.log("  \u2713 Block built-in plan mode \u2192 redirect to ContextStream plans (persistent)");
-      console.log("  \u2713 Inject reminders on every message to keep rules in context");
-      console.log("  \u2713 Result: Faster searches, persistent plans across sessions");
+      console.log("  \u2713 Use ContextStream (indexed, faster) with default tool use");
+      console.log("  \u2713 Use ContextStream plans (persistent) with default tool use");
+      console.log("  \u2713 Inject reminders to keep rules in context");
+      console.log("");
+      console.log(`  Hooks available for: ${hookEligibleEditors.map((e) => EDITOR_LABELS[e]).join(", ")}`);
       console.log("");
       console.log("  You can disable hooks anytime with CONTEXTSTREAM_HOOK_ENABLED=false");
       console.log("");
       const installHooks = normalizeInput(
-        await rl.question("Install Claude Code hooks? [Y/n] (recommended): ")
+        await rl.question("Install editor hooks? [Y/n] (recommended): ")
       ).toLowerCase();
       if (installHooks !== "n" && installHooks !== "no") {
-        try {
-          if (dryRun) {
-            console.log("- Would install hooks to ~/.claude/hooks/");
-            console.log("- Would update ~/.claude/settings.json");
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "hooks", "contextstream-redirect.py"), status: "dry-run" });
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "hooks", "contextstream-reminder.py"), status: "dry-run" });
-            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "settings.json"), status: "dry-run" });
-          } else {
-            const result = await installClaudeCodeHooks({ scope: "user" });
-            result.scripts.forEach((script) => {
-              writeActions.push({ kind: "mcp-config", target: script, status: "created" });
-              console.log(`- Created hook: ${script}`);
-            });
-            result.settings.forEach((settings) => {
-              writeActions.push({ kind: "mcp-config", target: settings, status: "updated" });
-              console.log(`- Updated settings: ${settings}`);
+        for (const editor of hookEligibleEditors) {
+          const hookEditor = HOOKS_SUPPORTED_EDITORS[editor];
+          if (!hookEditor) continue;
+          try {
+            if (dryRun) {
+              console.log(`- ${EDITOR_LABELS[editor]}: would install hooks`);
+              continue;
+            }
+            const result = await installEditorHooks({
+              editor: hookEditor,
+              scope: "global"
             });
+            for (const script of result.installed) {
+              writeActions.push({ kind: "hooks", target: script, status: "created" });
+              console.log(`- ${EDITOR_LABELS[editor]}: installed ${path8.basename(script)}`);
+            }
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(`- ${EDITOR_LABELS[editor]}: failed to install hooks: ${message}`);
           }
-          console.log("  Hooks installed. Disable with CONTEXTSTREAM_HOOK_ENABLED=false");
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          console.log(`- Failed to install hooks: ${message}`);
         }
+        console.log("  Hooks installed. Disable with CONTEXTSTREAM_HOOK_ENABLED=false");
       } else {
         console.log("- Skipped hooks installation.");
-        console.log("  Note: Without hooks, Claude may still use default tools instead of ContextStream.");
+        console.log("  Note: Without hooks, AI may still use default tools instead of ContextStream.");
       }
     }
     console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
@@ -20936,7 +23126,12 @@ Applying to ${projects.length} project(s)...`);
             folder_path: projectPath,
             workspace_id: workspaceId,
             workspace_name: workspaceName,
-            create_parent_mapping: createParentMapping
+            create_parent_mapping: createParentMapping,
+            // Include version and config info for desktop app compatibility
+            version: VERSION,
+            configured_editors: configuredEditors,
+            context_pack: contextPackEnabled,
+            api_url: apiUrl
           });
           writeActions.push({
             kind: "workspace-config",
@@ -21053,6 +23248,7 @@ Applying to ${projects.length} project(s)...`);
       console.log(`Toolset: ${toolset} (${toolsetDesc})`);
       console.log(`Token reduction: ~75% compared to previous versions.`);
       console.log(`Context Pack: ${contextPackEnabled ? "enabled" : "disabled"}`);
+      console.log(`Response Timing: ${showTiming ? "enabled" : "disabled"}`);
     }
     console.log("\nNext steps:");
     console.log("- Restart your editor/CLI after changing MCP config or rules.");
@@ -21068,6 +23264,9 @@ Applying to ${projects.length} project(s)...`);
     console.log(
       "- Toggle Context Pack with CONTEXTSTREAM_CONTEXT_PACK=true|false (and in dashboard settings)."
     );
+    console.log(
+      "- 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"');