@contextstream/mcp-server 0.4.37 → 0.4.38

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);
@@ -8981,6 +9058,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.
@@ -9214,12 +9324,27 @@ ContextStream search is **indexed** and returns semantic matches + context in ON
 - 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_capture_smart(...)\` to save state
+- After compaction (context lost): call \`session_init(..., is_post_compact=true)\` or \`session_restore_context()\`
+
 ### 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 +9797,81 @@ 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).
+Injects a reminder for the AI to save conversation state using session_capture_smart.
+
+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": "... instructions for AI ..."
+  }
+}
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_PRECOMPACT_ENABLED", "true").lower() == "true"
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    trigger = data.get("trigger", "unknown")
+    custom_instructions = data.get("custom_instructions", "")
+
+    # Build context injection for the AI
+    context = f"""[CONTEXT COMPACTION IMMINENT - {trigger.upper()}]
+CRITICAL: Before context is compacted, you MUST save conversation state:
+
+1. IMMEDIATELY call: mcp__contextstream__session(action="capture", event_type="session_snapshot", title="Pre-compaction snapshot", content="<JSON with: conversation_summary, active_goals, recent_decisions, active_files, unfinished_work>")
+
+2. Include in the snapshot:
+   - conversation_summary: Brief summary of what was discussed
+   - active_goals: List of goals/tasks in progress
+   - recent_decisions: Key decisions made in this session
+   - active_files: Files currently being worked on
+   - unfinished_work: Any incomplete tasks
+
+3. After compaction, call session_init(is_post_compact=true) to restore context.
+
+{f"User instructions: {custom_instructions}" if custom_instructions else ""}
+[END COMPACTION WARNING]"""
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreCompact",
+            "additionalContext": context
+        }
+    }
+
+    print(json.dumps(output))
+    sys.exit(0)
+
 if __name__ == "__main__":
     main()
 `;
@@ -9687,11 +9887,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 +9918,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);
@@ -9759,16 +9985,22 @@ function mergeHooksIntoSettings(existingSettings, newHooks) {
 async function installClaudeCodeHooks(options) {
   const result = { scripts: [], settings: [] };
   if (!options.dryRun) {
-    const scripts = await installHookScripts();
+    const scripts = await installHookScripts({ includePreCompact: options.includePreCompact });
     result.scripts.push(scripts.preToolUse, scripts.userPrompt);
+    if (scripts.preCompact) {
+      result.scripts.push(scripts.preCompact);
+    }
   } else {
     const hooksDir = getHooksDir();
     result.scripts.push(
       path5.join(hooksDir, "contextstream-redirect.py"),
       path5.join(hooksDir, "contextstream-reminder.py")
     );
+    if (options.includePreCompact) {
+      result.scripts.push(path5.join(hooksDir, "contextstream-precompact.py"));
+    }
   }
-  const hooksConfig = buildHooksConfig();
+  const hooksConfig = buildHooksConfig({ includePreCompact: options.includePreCompact });
   if (options.scope === "user" || options.scope === "both") {
     const settingsPath = getClaudeSettingsPath("user");
     if (!options.dryRun) {
@@ -10618,13 +10850,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 +10900,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",
@@ -11121,6 +11361,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 +11474,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 +13819,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(
+          "Set to true when resuming after conversation compaction. This prioritizes session_snapshot restoration and recent decisions."
         )
       })
     },
     async (input) => {
+      const startTime = Date.now();
       let ideRoots = [];
       try {
         const rootsResponse = await server.server.listRoots();
@@ -13572,8 +13845,48 @@ This does semantic search on the first message. You only need context_smart on s
       }
       const result = await client.initSession(input, ideRoots);
       result.tools_hint = getCoreToolsHint();
+      if (input.is_post_compact) {
+        const workspaceIdForRestore = typeof result.workspace_id === "string" ? result.workspace_id : void 0;
+        const projectIdForRestore = typeof result.project_id === "string" ? result.project_id : void 0;
+        if (workspaceIdForRestore) {
+          try {
+            const snapshotSearch = await client.searchEvents({
+              workspace_id: workspaceIdForRestore,
+              project_id: projectIdForRestore,
+              query: "session_snapshot",
+              event_types: ["session_snapshot"],
+              limit: 1
+            });
+            const snapshots = snapshotSearch?.data?.results || snapshotSearch?.results || snapshotSearch?.data || [];
+            if (snapshots && snapshots.length > 0) {
+              const latestSnapshot = snapshots[0];
+              let snapshotData;
+              try {
+                snapshotData = JSON.parse(latestSnapshot.content);
+              } catch {
+                snapshotData = { conversation_summary: latestSnapshot.content };
+              }
+              result.restored_context = {
+                snapshot_id: latestSnapshot.id,
+                captured_at: snapshotData.captured_at || latestSnapshot.created_at,
+                ...snapshotData
+              };
+              result.is_post_compact = true;
+              result.post_compact_hint = "Session restored from pre-compaction snapshot. Review the 'restored_context' to continue where you left off.";
+            } 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 +14033,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 +14316,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"),
@@ -14053,6 +14375,224 @@ Use this to persist decisions, insights, preferences, or important information.`
       };
     }
   );
+  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: formatContent(response) }],
+          structuredContent: toStructured(response)
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResult(`Failed to restore context: ${message}`);
+      }
+    }
+  );
   registerTool(
     "session_capture_lesson",
     {
@@ -14411,6 +14951,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")
       })
     },
@@ -14491,8 +15032,14 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
               { file: "~/.claude/hooks/contextstream-reminder.py", status: "dry run - would create" },
               { file: "~/.claude/settings.json", status: "dry run - would update" }
             ];
+            if (input.include_pre_compact) {
+              hooksResults.push({ file: "~/.claude/hooks/contextstream-precompact.py", status: "dry run - would create" });
+            }
           } else {
-            const hookResult = await installClaudeCodeHooks({ scope: "user" });
+            const hookResult = await installClaudeCodeHooks({
+              scope: "user",
+              includePreCompact: input.include_pre_compact
+            });
             hooksResults = [
               ...hookResult.scripts.map((f) => ({ file: f, status: "created" })),
               ...hookResult.settings.map((f) => ({ file: f, status: "updated" }))
@@ -14851,10 +15398,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 +15417,17 @@ 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);
+      }
       const result = await client.getSmartContext({
         user_message: input.user_message,
         workspace_id: workspaceId,
@@ -14874,11 +15435,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;
@@ -14905,6 +15473,22 @@ This saves ~80% tokens compared to including full chat history.`,
       const searchRulesLine = SEARCH_RULES_REMINDER_ENABLED ? `
 
 ${SEARCH_RULES_REMINDER}` : "";
+      let contextPressureWarning = "";
+      if (result.context_pressure) {
+        const cp = result.context_pressure;
+        if (cp.level === "critical") {
+          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") {
+          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,6 +15497,7 @@ ${rulesWarningLine}` : "",
         versionWarningLine ? `
 
 ${versionWarningLine}` : "",
+        contextPressureWarning,
         searchRulesLine
       ].filter(Boolean).join("");
       return {
@@ -15943,6 +16528,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 +16559,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 +16576,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 +16594,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 +16618,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 +16669,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 +16978,87 @@ 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 response2 = {
+                restored: true,
+                snapshot_id: event.id,
+                captured_at: snapshotData.captured_at || event.created_at,
+                ...snapshotData,
+                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 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,
+                ...snapshotData
+              };
+            });
+            const response = {
+              restored: true,
+              snapshots_found: snapshots.length,
+              latest: snapshots[0],
+              all_snapshots: snapshots.length > 1 ? snapshots : void 0,
+              hint: "Context restored. Continue the conversation with awareness of the above state."
+            };
+            return {
+              content: [{ type: "text", text: formatContent(response) }],
+              structuredContent: toStructured(response)
+            };
+          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }
@@ -18949,6 +19624,7 @@ function registerPrompts(server) {
 
 // src/session-manager.ts
 var SessionManager = class {
+  // Conservative default for 100k context window
   constructor(server, client) {
     this.server = server;
     this.client = client;
@@ -18959,6 +19635,9 @@ var SessionManager = class {
     this.folderPath = null;
     this.contextSmartCalled = false;
     this.warningShown = false;
+    // Token tracking for context pressure calculation
+    this.sessionTokens = 0;
+    this.contextThreshold = 7e4;
   }
   /**
    * Check if session has been auto-initialized
@@ -19006,6 +19685,51 @@ var SessionManager = class {
   markContextSmartCalled() {
     this.contextSmartCalled = true;
   }
+  /**
+   * Get current session token count for context pressure calculation.
+   */
+  getSessionTokens() {
+    return this.sessionTokens;
+  }
+  /**
+   * 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;
+  }
   /**
    * Check if context_smart has been called and warn if not.
    * Returns true if a warning was shown, false otherwise.
@@ -20025,6 +20749,9 @@ function buildContextStreamMcpServer(params) {
     env.CONTEXTSTREAM_PROGRESSIVE_MODE = "true";
   }
   env.CONTEXTSTREAM_CONTEXT_PACK = params.contextPackEnabled === false ? "false" : "true";
+  if (params.showTiming) {
+    env.CONTEXTSTREAM_SHOW_TIMING = "true";
+  }
   if (IS_WINDOWS) {
     return {
       command: "cmd",
@@ -20047,6 +20774,9 @@ function buildContextStreamVsCodeServer(params) {
     env.CONTEXTSTREAM_PROGRESSIVE_MODE = "true";
   }
   env.CONTEXTSTREAM_CONTEXT_PACK = params.contextPackEnabled === false ? "false" : "true";
+  if (params.showTiming) {
+    env.CONTEXTSTREAM_SHOW_TIMING = "true";
+  }
   if (IS_WINDOWS) {
     return {
       type: "stdio",
@@ -20147,6 +20877,8 @@ async function upsertCodexTomlConfig(filePath, params) {
 ` : "";
   const contextPackLine = `CONTEXTSTREAM_CONTEXT_PACK = "${params.contextPackEnabled === false ? "false" : "true"}"
 `;
+  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 +20892,7 @@ args = ["-y", "@contextstream/mcp-server"]
 [mcp_servers.contextstream.env]
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
-` + toolsetLine + contextPackLine;
+` + toolsetLine + contextPackLine + showTimingLine;
   if (!exists) {
     await fs7.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
@@ -20517,6 +21249,11 @@ 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";
     const editors = [
       "codex",
       "claude",
@@ -20591,18 +21328,20 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
       )
     ) || mcpChoiceDefault;
     const mcpScope = mcpChoice === "2" && hasCodex && !hasProjectMcpEditors ? "skip" : mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
-    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled });
+    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled, showTiming });
     const mcpServerClaude = buildContextStreamMcpServer({
       apiUrl,
       apiKey,
       toolset,
-      contextPackEnabled
+      contextPackEnabled,
+      showTiming
     });
     const vsCodeServer = buildContextStreamVsCodeServer({
       apiUrl,
       apiKey,
       toolset,
-      contextPackEnabled
+      contextPackEnabled,
+      showTiming
     });
     const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
     if (needsGlobalMcpConfig) {
@@ -20621,7 +21360,8 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
               apiUrl,
               apiKey,
               toolset,
-              contextPackEnabled
+              contextPackEnabled,
+              showTiming
             });
             writeActions.push({ kind: "mcp-config", target: filePath, status });
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
@@ -20936,7 +21676,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 +21798,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 +21814,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"');

package/dist/test-server.js

@@ -4082,7 +4082,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 loadConfig() {
@@ -4090,6 +4091,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,
@@ -4098,7 +4100,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(", ");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.4.37",
+  "version": "0.4.38",
   "description": "ContextStream MCP server - v0.4.x with consolidated domain tools (~11 tools, ~75% token reduction). Code context, memory, search, and AI tools.",
   "type": "module",
   "license": "MIT",