@contextstream/mcp-server 0.4.49 → 0.4.50

package/README.md

@@ -157,6 +157,33 @@ claude mcp update contextstream -e CONTEXTSTREAM_API_KEY=your_key
 
 </details>
 
+<details>
+<summary><b>GitHub Copilot CLI</b></summary>
+
+Use the Copilot CLI to interactively add the MCP server:
+
+```bash
+/mcp add
+```
+
+Or add to `~/.copilot/mcp-config.json`:
+
+```json
+{
+  "mcpServers": {
+    "contextstream": {
+      "command": "npx",
+      "args": ["-y", "@contextstream/mcp-server"],
+      "env": { "CONTEXTSTREAM_API_KEY": "your_key" }
+    }
+  }
+}
+```
+
+For more information, see the [GitHub Copilot CLI documentation](https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli).
+
+</details>
+
 ---
 
 ## Links

package/dist/hooks/pre-compact.js

@@ -68,6 +68,9 @@ function parseTranscript(transcriptPath) {
   const activeFiles = /* @__PURE__ */ new Set();
   const recentMessages = [];
   const toolCalls = [];
+  const messages = [];
+  let startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let firstTimestamp = true;
   try {
     const content = fs.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
@@ -76,6 +79,11 @@ function parseTranscript(transcriptPath) {
       try {
         const entry = JSON.parse(line);
         const msgType = entry.type || "";
+        const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+        if (firstTimestamp && entry.timestamp) {
+          startedAt = entry.timestamp;
+          firstTimestamp = false;
+        }
         if (msgType === "tool_use") {
           const toolName = entry.name || "";
           const toolInput = entry.input || {};
@@ -91,11 +99,40 @@ function parseTranscript(transcriptPath) {
               activeFiles.add(`[glob:${pattern}]`);
             }
           }
-        }
-        if (msgType === "assistant" && entry.content) {
-          const content2 = entry.content;
-          if (typeof content2 === "string" && content2.length > 50) {
-            recentMessages.push(content2.slice(0, 500));
+          messages.push({
+            role: "assistant",
+            content: `[Tool: ${toolName}]`,
+            timestamp,
+            tool_calls: { name: toolName, input: toolInput }
+          });
+        } else if (msgType === "tool_result") {
+          const resultContent = typeof entry.content === "string" ? entry.content.slice(0, 2e3) : JSON.stringify(entry.content || {}).slice(0, 2e3);
+          messages.push({
+            role: "tool",
+            content: resultContent,
+            timestamp,
+            tool_results: { name: entry.name }
+          });
+        } else if (msgType === "user" || entry.role === "user") {
+          const userContent = typeof entry.content === "string" ? entry.content : "";
+          if (userContent) {
+            messages.push({
+              role: "user",
+              content: userContent,
+              timestamp
+            });
+          }
+        } else if (msgType === "assistant" || entry.role === "assistant") {
+          const assistantContent = typeof entry.content === "string" ? entry.content : "";
+          if (assistantContent) {
+            messages.push({
+              role: "assistant",
+              content: assistantContent,
+              timestamp
+            });
+            if (assistantContent.length > 50) {
+              recentMessages.push(assistantContent.slice(0, 500));
+            }
           }
         }
       } catch {
@@ -108,11 +145,57 @@ function parseTranscript(transcriptPath) {
     activeFiles: Array.from(activeFiles).slice(-20),
     // Last 20 files
     toolCallCount: toolCalls.length,
-    messageCount: recentMessages.length,
-    lastTools: toolCalls.slice(-10).map((t) => t.name)
+    messageCount: messages.length,
+    lastTools: toolCalls.slice(-10).map((t) => t.name),
     // Last 10 tool names
+    messages,
+    startedAt
   };
 }
+async function saveFullTranscript(sessionId, transcriptData, trigger) {
+  if (!API_KEY) {
+    return { success: false, message: "No API key configured" };
+  }
+  if (transcriptData.messages.length === 0) {
+    return { success: false, message: "No messages to save" };
+  }
+  const payload = {
+    session_id: sessionId,
+    messages: transcriptData.messages,
+    started_at: transcriptData.startedAt,
+    source_type: "pre_compact",
+    title: `Pre-compaction save (${trigger})`,
+    metadata: {
+      trigger,
+      active_files: transcriptData.activeFiles,
+      tool_call_count: transcriptData.toolCallCount
+    },
+    tags: ["pre_compaction", trigger]
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    const response = await fetch(`${API_URL}/api/v1/transcripts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return { success: true, message: `Transcript saved (${transcriptData.messages.length} messages)` };
+    }
+    return { success: false, message: `API error: ${response.status}` };
+  } catch (error) {
+    return { success: false, message: String(error) };
+  }
+}
 async function saveSnapshot(sessionId, transcriptData, trigger) {
   if (!API_KEY) {
     return { success: false, message: "No API key configured" };
@@ -193,13 +276,19 @@ async function runPreCompactHook() {
   }
   let autoSaveStatus = "";
   if (AUTO_SAVE && API_KEY) {
-    const { success, message } = await saveSnapshot(sessionId, transcriptData, trigger);
-    if (success) {
+    const transcriptResult = await saveFullTranscript(sessionId, transcriptData, trigger);
+    if (transcriptResult.success) {
       autoSaveStatus = `
-[ContextStream: Auto-saved snapshot with ${transcriptData.activeFiles.length} active files]`;
+[ContextStream: ${transcriptResult.message}]`;
     } else {
-      autoSaveStatus = `
+      const { success, message } = await saveSnapshot(sessionId, transcriptData, trigger);
+      if (success) {
+        autoSaveStatus = `
+[ContextStream: Auto-saved snapshot with ${transcriptData.activeFiles.length} active files (transcript save failed: ${transcriptResult.message})]`;
+      } else {
+        autoSaveStatus = `
 [ContextStream: Auto-save failed - ${message}]`;
+      }
     }
   }
   const filesList = transcriptData.activeFiles.slice(0, 5).join(", ") || "none detected";

package/dist/index.js

@@ -2825,6 +2825,9 @@ function parseTranscript(transcriptPath) {
   const activeFiles = /* @__PURE__ */ new Set();
   const recentMessages = [];
   const toolCalls = [];
+  const messages = [];
+  let startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let firstTimestamp = true;
   try {
     const content = fs10.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
@@ -2833,6 +2836,11 @@ function parseTranscript(transcriptPath) {
       try {
         const entry = JSON.parse(line);
         const msgType = entry.type || "";
+        const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+        if (firstTimestamp && entry.timestamp) {
+          startedAt = entry.timestamp;
+          firstTimestamp = false;
+        }
         if (msgType === "tool_use") {
           const toolName = entry.name || "";
           const toolInput = entry.input || {};
@@ -2848,11 +2856,40 @@ function parseTranscript(transcriptPath) {
               activeFiles.add(`[glob:${pattern}]`);
             }
           }
-        }
-        if (msgType === "assistant" && entry.content) {
-          const content2 = entry.content;
-          if (typeof content2 === "string" && content2.length > 50) {
-            recentMessages.push(content2.slice(0, 500));
+          messages.push({
+            role: "assistant",
+            content: `[Tool: ${toolName}]`,
+            timestamp,
+            tool_calls: { name: toolName, input: toolInput }
+          });
+        } else if (msgType === "tool_result") {
+          const resultContent = typeof entry.content === "string" ? entry.content.slice(0, 2e3) : JSON.stringify(entry.content || {}).slice(0, 2e3);
+          messages.push({
+            role: "tool",
+            content: resultContent,
+            timestamp,
+            tool_results: { name: entry.name }
+          });
+        } else if (msgType === "user" || entry.role === "user") {
+          const userContent = typeof entry.content === "string" ? entry.content : "";
+          if (userContent) {
+            messages.push({
+              role: "user",
+              content: userContent,
+              timestamp
+            });
+          }
+        } else if (msgType === "assistant" || entry.role === "assistant") {
+          const assistantContent = typeof entry.content === "string" ? entry.content : "";
+          if (assistantContent) {
+            messages.push({
+              role: "assistant",
+              content: assistantContent,
+              timestamp
+            });
+            if (assistantContent.length > 50) {
+              recentMessages.push(assistantContent.slice(0, 500));
+            }
           }
         }
       } catch {
@@ -2865,11 +2902,57 @@ function parseTranscript(transcriptPath) {
     activeFiles: Array.from(activeFiles).slice(-20),
     // Last 20 files
     toolCallCount: toolCalls.length,
-    messageCount: recentMessages.length,
-    lastTools: toolCalls.slice(-10).map((t) => t.name)
+    messageCount: messages.length,
+    lastTools: toolCalls.slice(-10).map((t) => t.name),
     // Last 10 tool names
+    messages,
+    startedAt
   };
 }
+async function saveFullTranscript(sessionId, transcriptData, trigger) {
+  if (!API_KEY2) {
+    return { success: false, message: "No API key configured" };
+  }
+  if (transcriptData.messages.length === 0) {
+    return { success: false, message: "No messages to save" };
+  }
+  const payload = {
+    session_id: sessionId,
+    messages: transcriptData.messages,
+    started_at: transcriptData.startedAt,
+    source_type: "pre_compact",
+    title: `Pre-compaction save (${trigger})`,
+    metadata: {
+      trigger,
+      active_files: transcriptData.activeFiles,
+      tool_call_count: transcriptData.toolCallCount
+    },
+    tags: ["pre_compaction", trigger]
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    const response = await fetch(`${API_URL2}/api/v1/transcripts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY2
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return { success: true, message: `Transcript saved (${transcriptData.messages.length} messages)` };
+    }
+    return { success: false, message: `API error: ${response.status}` };
+  } catch (error) {
+    return { success: false, message: String(error) };
+  }
+}
 async function saveSnapshot(sessionId, transcriptData, trigger) {
   if (!API_KEY2) {
     return { success: false, message: "No API key configured" };
@@ -2950,13 +3033,19 @@ async function runPreCompactHook() {
   }
   let autoSaveStatus = "";
   if (AUTO_SAVE && API_KEY2) {
-    const { success, message } = await saveSnapshot(sessionId, transcriptData, trigger);
-    if (success) {
+    const transcriptResult = await saveFullTranscript(sessionId, transcriptData, trigger);
+    if (transcriptResult.success) {
       autoSaveStatus = `
-[ContextStream: Auto-saved snapshot with ${transcriptData.activeFiles.length} active files]`;
+[ContextStream: ${transcriptResult.message}]`;
     } else {
-      autoSaveStatus = `
+      const { success, message } = await saveSnapshot(sessionId, transcriptData, trigger);
+      if (success) {
+        autoSaveStatus = `
+[ContextStream: Auto-saved snapshot with ${transcriptData.activeFiles.length} active files (transcript save failed: ${transcriptResult.message})]`;
+      } else {
+        autoSaveStatus = `
 [ContextStream: Auto-save failed - ${message}]`;
+      }
     }
   }
   const filesList = transcriptData.activeFiles.slice(0, 5).join(", ") || "none detected";
@@ -9935,6 +10024,35 @@ var ContextStreamClient = class {
       }
     });
   }
+  /**
+   * Capture a memory event with a direct event_type.
+   * Used for auto-save session snapshots and other system events.
+   */
+  async captureMemoryEvent(params) {
+    const withDefaults = this.withDefaults(params);
+    const metadata = {
+      ...params.metadata || {}
+    };
+    if (params.tags && params.tags.length > 0) {
+      metadata.tags = params.tags;
+    }
+    if (!metadata.captured_at) {
+      metadata.captured_at = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (!metadata.source) {
+      metadata.source = "mcp_auto_capture";
+    }
+    return this.createMemoryEvent({
+      workspace_id: withDefaults.workspace_id,
+      project_id: withDefaults.project_id,
+      event_type: params.event_type,
+      title: params.title,
+      content: params.content,
+      provenance: params.provenance,
+      code_refs: params.code_refs,
+      metadata
+    });
+  }
   submitContextFeedback(body) {
     return request(this.config, "/context/smart/feedback", { body: this.withDefaults(body) });
   }
@@ -10502,7 +10620,11 @@ var ContextStreamClient = class {
           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 }
+          ...params.context_threshold !== void 0 && { context_threshold: params.context_threshold },
+          // Transcript save parameters
+          ...params.save_exchange !== void 0 && { save_exchange: params.save_exchange },
+          ...params.session_id !== void 0 && { session_id: params.session_id },
+          ...params.client_name !== void 0 && { client_name: params.client_name }
         }
       });
       const data = unwrapApiResponse(apiResult);
@@ -12064,6 +12186,95 @@ ${context}`;
     uuidSchema.parse(params.doc_id);
     return request(this.config, `/docs/${params.doc_id}`, { method: "DELETE" });
   }
+  // -------------------------------------------------------------------------
+  // Transcript methods (conversation session storage)
+  // -------------------------------------------------------------------------
+  /**
+   * List transcripts for a workspace/project
+   */
+  async listTranscripts(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const query = new URLSearchParams();
+    if (withDefaults.workspace_id) query.set("workspace_id", withDefaults.workspace_id);
+    if (withDefaults.project_id) query.set("project_id", withDefaults.project_id);
+    if (params?.session_id) query.set("session_id", params.session_id);
+    if (params?.client_name) query.set("client_name", params.client_name);
+    if (params?.started_after) query.set("started_after", params.started_after);
+    if (params?.started_before) query.set("started_before", params.started_before);
+    if (params?.limit) query.set("per_page", String(params.limit));
+    if (params?.page) query.set("page", String(params.page));
+    if (params?.per_page) query.set("per_page", String(params.per_page));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/transcripts${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get a specific transcript by ID
+   */
+  async getTranscript(transcript_id) {
+    uuidSchema.parse(transcript_id);
+    return request(this.config, `/transcripts/${transcript_id}`, { method: "GET" });
+  }
+  /**
+   * Search transcripts by content
+   */
+  async searchTranscripts(params) {
+    const withDefaults = this.withDefaults(params);
+    const queryParams = new URLSearchParams();
+    if (withDefaults.workspace_id) queryParams.set("workspace_id", withDefaults.workspace_id);
+    queryParams.set("query", params.query);
+    if (params.limit) queryParams.set("limit", String(params.limit));
+    return request(this.config, `/transcripts/search?${queryParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Delete a transcript
+   */
+  async deleteTranscript(transcript_id) {
+    uuidSchema.parse(transcript_id);
+    return request(this.config, `/transcripts/${transcript_id}`, { method: "DELETE" });
+  }
+  // -------------------------------------------------------------------------
+  // Suggested Rules methods (ML-generated rule suggestions)
+  // -------------------------------------------------------------------------
+  /**
+   * List suggested rules
+   */
+  async listSuggestedRules(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const queryParams = new URLSearchParams();
+    if (withDefaults.workspace_id) queryParams.set("workspace_id", withDefaults.workspace_id);
+    if (params?.status) queryParams.set("status", params.status);
+    if (params?.source_type) queryParams.set("source_type", params.source_type);
+    if (params?.min_confidence) queryParams.set("min_confidence", String(params.min_confidence));
+    if (params?.limit) queryParams.set("limit", String(params.limit));
+    if (params?.offset) queryParams.set("offset", String(params.offset));
+    return request(this.config, `/suggested-rules?${queryParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Get pending suggested rules count
+   */
+  async getSuggestedRulesPendingCount(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const queryParams = new URLSearchParams();
+    if (withDefaults.workspace_id) queryParams.set("workspace_id", withDefaults.workspace_id);
+    return request(this.config, `/suggested-rules/pending-count?${queryParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Get suggested rules feedback stats
+   */
+  async getSuggestedRulesStats(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const queryParams = new URLSearchParams();
+    if (withDefaults.workspace_id) queryParams.set("workspace_id", withDefaults.workspace_id);
+    return request(this.config, `/suggested-rules/stats?${queryParams.toString()}`, { method: "GET" });
+  }
+  /**
+   * Perform action on suggested rule (accept/reject/modify)
+   */
+  async suggestedRuleAction(params) {
+    uuidSchema.parse(params.rule_id);
+    const { rule_id, ...body } = params;
+    return request(this.config, `/suggested-rules/${rule_id}/action`, { method: "POST", body });
+  }
 };
 
 // src/tools.ts
@@ -13110,111 +13321,84 @@ function trackToolTokenSavings(client, tool, contextText, params, extraMetadata)
   }
 }
 
-// src/educational-microcopy.ts
-var SESSION_INIT_TIPS = [
-  "AI work that doesn't disappear.",
-  "Every conversation builds context. Every artifact persists.",
-  "Your AI remembers. Now you can see what it knows.",
-  "Context that survives sessions.",
-  "The bridge between AI conversations and human artifacts."
-];
+// src/microcopy.ts
 function getSessionInitTip(sessionId) {
-  const index = sessionId ? Math.abs(hashString(sessionId)) % SESSION_INIT_TIPS.length : Math.floor(Math.random() * SESSION_INIT_TIPS.length);
-  return SESSION_INIT_TIPS[index];
-}
-var CAPTURE_HINTS = {
-  // Core event types
-  decision: "Future you will thank present you.",
-  preference: "Noted. This will inform future suggestions.",
-  insight: "Captured for future reference.",
-  note: "Saved. Won't disappear when the chat does.",
-  implementation: "Implementation recorded.",
-  task: "Task tracked.",
-  bug: "Bug logged for tracking.",
-  feature: "Feature request captured.",
-  plan: "This plan will be here when you come back.",
-  correction: "Correction noted. Learning from this.",
-  lesson: "Learn once, remember forever.",
-  warning: "Warning logged.",
-  frustration: "Feedback captured. We're listening.",
-  conversation: "Conversation preserved.",
-  session_snapshot: "Session state saved. Ready to resume anytime."
-};
+  return `Session ${sessionId.slice(0, 8)}... initialized. Use context(user_message="...") to get relevant context.`;
+}
 function getCaptureHint(eventType) {
-  return CAPTURE_HINTS[eventType] || "Captured. This will survive when the chat disappears.";
-}
-var EMPTY_STATE_HINTS = {
-  // Plans
-  list_plans: "No plans yet. Plans live here, not in chat transcripts.",
-  get_plan: "Plan not found. Create one to track implementation across sessions.",
-  // Memory & Search
-  recall: "Nothing found yet. Context builds over time.",
-  search: "No matches. Try a different query or let context accumulate.",
-  list_events: "No events yet. Start capturing decisions and insights.",
-  decisions: "No decisions captured yet. Record the 'why' behind your choices.",
-  timeline: "Timeline empty. Events will appear as you work.",
-  // Lessons
-  get_lessons: "No lessons yet. Capture mistakes to learn from them.",
-  // Tasks
-  list_tasks: "No tasks yet. Break plans into trackable tasks.",
-  // Todos
-  list_todos: "No todos yet. Action items will appear here.",
-  // Diagrams
-  list_diagrams: "No diagrams yet. AI-generated diagrams persist here.",
-  // Docs
-  list_docs: "No docs yet. Turn AI explanations into shareable documentation.",
-  // Reminders
-  list_reminders: "No reminders set. Schedule follow-ups that won't be forgotten.",
-  // Generic
-  default: "Nothing yet. Start a conversation\u2014context builds over time."
-};
-function getEmptyStateHint(action) {
-  return EMPTY_STATE_HINTS[action] || EMPTY_STATE_HINTS.default;
+  switch (eventType) {
+    case "decision":
+      return "Decision captured. It will surface in future context() calls when relevant.";
+    case "preference":
+      return "Preference saved. Future sessions will respect this preference.";
+    case "insight":
+      return "Insight captured. Use recall() to retrieve it later.";
+    case "task":
+      return "Task captured. Use list_tasks() to view all tasks.";
+    case "lesson":
+      return "Lesson saved. It will warn you before similar mistakes.";
+    case "session_snapshot":
+      return "Session state saved. Use restore_context() after compaction.";
+    default:
+      return "Event captured. Use recall() to retrieve related events.";
+  }
+}
+function getEmptyStateHint(operation) {
+  switch (operation) {
+    case "get_lessons":
+      return "No lessons found. Lessons are captured when mistakes occur.";
+    case "recall":
+      return "No memories found. Use capture() or remember() to save context.";
+    case "list_plans":
+      return "No plans found. Use capture_plan() to create an implementation plan.";
+    case "list_events":
+      return "No events found. Events are captured as you work.";
+    case "list_tasks":
+      return "No tasks found. Use create_task() to add tasks.";
+    case "list_todos":
+      return "No todos found. Use create_todo() to add quick todos.";
+    case "list_diagrams":
+      return "No diagrams found. Use create_diagram() to save a Mermaid diagram.";
+    case "list_docs":
+      return "No docs found. Use create_doc() to save documentation.";
+    default:
+      return "No results found.";
+  }
 }
-var POST_COMPACT_HINTS = {
-  restored: "Picked up where you left off. Session ended, memory didn't.",
-  restored_with_session: (sessionId) => `Restored from session ${sessionId}. Session ended, memory didn't.`,
-  no_snapshot: "No prior session found. Fresh start\u2014context will build as you work.",
-  failed: "Couldn't restore previous session. Use context to retrieve what you need."
-};
-var PLAN_HINTS = {
-  created: "Plan saved. It will be here when you come back.",
-  activated: "Plan is now active. Track progress across sessions.",
-  completed: "Plan completed. The journey is preserved for future reference.",
-  abandoned: "Plan archived. Abandoned plans still teach.",
-  updated: "Plan updated. Changes are preserved."
-};
 function getPlanStatusHint(status) {
-  const statusMap = {
-    draft: PLAN_HINTS.created,
-    active: PLAN_HINTS.activated,
-    completed: PLAN_HINTS.completed,
-    abandoned: PLAN_HINTS.abandoned,
-    archived: PLAN_HINTS.abandoned
-  };
-  return statusMap[status] || PLAN_HINTS.updated;
+  switch (status) {
+    case "draft":
+      return "Plan saved as draft. Update status to 'active' when ready.";
+    case "active":
+      return "Plan is now active. Create tasks to track implementation.";
+    case "completed":
+      return "Plan completed. Great work!";
+    case "archived":
+      return "Plan archived. It will still appear in searches.";
+    case "abandoned":
+      return "Plan abandoned. Consider capturing lessons learned.";
+    default:
+      return "Plan updated. Changes are preserved.";
+  }
 }
-var TASK_HINTS = {
-  created: "Task tracked. It won't disappear when the chat does.",
-  completed: "Task done. Progress is preserved.",
-  blocked: "Task blocked. Capture what's blocking for future reference.",
-  cancelled: "Task cancelled. The history remains."
+var POST_COMPACT_HINTS = {
+  restored: "Context restored from pre-compaction snapshot.",
+  restored_with_session: (sessionId) => `Context restored from session ${sessionId.slice(0, 8)}... snapshot.`,
+  no_snapshot: "No snapshot found. Session state may be incomplete.",
+  failed: "Failed to restore context. Try recall() to find relevant memories."
 };
 var INTEGRATION_HINTS = {
-  not_connected: "Connect integrations to sync context where your team already works.",
-  slack: "Context from Slack conversations, connected.",
-  github: "Issues and PRs linked to the decisions behind them.",
-  notion: "Decisions synced to where your team documents."
+  connected: "Integration connected and syncing.",
+  not_connected: "Integration not connected. Connect at:",
+  sync_in_progress: "Sync in progress. Results may be incomplete.",
+  sync_complete: "Sync complete. All data is current."
+};
+var TASK_HINTS = {
+  created: "Task created. Use update_task() to change status.",
+  completed: "Task completed. Well done!",
+  blocked: "Task blocked. Add blocked_reason for context.",
+  linked_to_plan: "Task linked to plan. Progress will be tracked."
 };
-function hashString(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return hash;
-}
 
 // src/tools.ts
 var LOG_LEVEL = (process.env.CONTEXTSTREAM_LOG_LEVEL || "normal").toLowerCase();
@@ -14880,7 +15064,10 @@ function registerTools(server, client, sessionManager) {
     "notion_stats",
     "notion_activity",
     "notion_knowledge",
-    "notion_summary"
+    "notion_summary",
+    // Media operations (credit-metered)
+    "media_index",
+    "media_search"
   ]);
   const proTools = (() => {
     const raw = process.env.CONTEXTSTREAM_PRO_TOOLS;
@@ -18577,7 +18764,10 @@ This saves ~80% tokens compared to including full chat history.`,
         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)"),
         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)")
+        context_threshold: external_exports.number().optional().describe("Custom context window threshold (defaults to 70k)"),
+        save_exchange: external_exports.boolean().optional().describe("Save this exchange to the transcript for later search (background task)"),
+        session_id: external_exports.string().optional().describe("Session ID for transcript association (required if save_exchange is true)"),
+        client_name: external_exports.string().optional().describe("Client name for transcript metadata (e.g., 'claude', 'cursor')")
       })
     },
     async (input) => {
@@ -18653,6 +18843,14 @@ This saves ~80% tokens compared to including full chat history.`,
           logDebug(`Failed to restore post-compact context: ${err}`);
         }
       }
+      let sessionId = input.session_id;
+      if (!sessionId && sessionManager && input.save_exchange) {
+        sessionId = sessionManager.getSessionId();
+      }
+      let clientName = input.client_name;
+      if (!clientName && detectedClientInfo) {
+        clientName = detectedClientInfo.name;
+      }
       const result = await client.getSmartContext({
         user_message: input.user_message,
         workspace_id: workspaceId,
@@ -18662,7 +18860,10 @@ This saves ~80% tokens compared to including full chat history.`,
         mode: input.mode,
         distill: input.distill,
         session_tokens: sessionTokens,
-        context_threshold: contextThreshold
+        context_threshold: contextThreshold,
+        save_exchange: input.save_exchange,
+        session_id: sessionId,
+        client_name: clientName
       });
       if (sessionManager && result.token_estimate) {
         sessionManager.addTokens(result.token_estimate);
@@ -19959,7 +20160,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       "session",
       {
         title: "Session",
-        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance), restore_context (restore state after compaction). Plan actions: capture_plan (save implementation plan), get_plan (retrieve plan with tasks), update_plan (modify plan), list_plans (list all plans). Team actions (team plans only): team_decisions (team-wide decisions), team_lessons (team-wide lessons), team_plans (plans across team workspaces).`,
+        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). Suggested rules actions: list_suggested_rules (view ML-generated rule suggestions), suggested_rule_action (accept/reject/modify a suggestion), suggested_rules_stats (view ML accuracy stats). Team actions (team plans only): team_decisions (team-wide decisions), team_lessons (team-wide lessons), team_plans (plans across team workspaces).`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "capture",
@@ -19983,7 +20184,11 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             // Team actions (team plans only)
             "team_decisions",
             "team_lessons",
-            "team_plans"
+            "team_plans",
+            // Suggested rules actions (ML-generated)
+            "list_suggested_rules",
+            "suggested_rule_action",
+            "suggested_rules_stats"
           ]).describe("Action to perform"),
           workspace_id: external_exports.string().uuid().optional(),
           project_id: external_exports.string().uuid().optional(),
@@ -20060,7 +20265,13 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           is_personal: external_exports.boolean().optional().describe("Mark plan as personal (only visible to creator). For capture_plan/list_plans."),
           // 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)")
+          max_snapshots: external_exports.number().optional().default(1).describe("Number of recent snapshots to consider (default: 1)"),
+          // Suggested rules params
+          rule_id: external_exports.string().uuid().optional().describe("Suggested rule ID for actions"),
+          rule_action: external_exports.enum(["accept", "reject", "modify"]).optional().describe("Action to perform on suggested rule"),
+          modified_keywords: external_exports.array(external_exports.string()).optional().describe("Modified keywords when action is modify"),
+          modified_instruction: external_exports.string().optional().describe("Modified instruction when action is modify"),
+          min_confidence: external_exports.number().optional().describe("Minimum confidence threshold for listing rules")
         })
       },
       async (input) => {
@@ -20636,6 +20847,81 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               ]
             };
           }
+          case "list_suggested_rules": {
+            const result = await client.listSuggestedRules({
+              workspace_id: workspaceId,
+              status: input.status,
+              min_confidence: input.min_confidence,
+              limit: input.limit
+            });
+            const rules = result?.data?.items || result?.items || [];
+            if (rules.length === 0) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: formatContent({
+                      suggested_rules: [],
+                      hint: "No pending rule suggestions. The ML system learns from your lessons and will suggest rules when patterns are detected."
+                    })
+                  }
+                ]
+              };
+            }
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatContent({
+                    suggested_rules: rules,
+                    total: result?.data?.total || rules.length,
+                    hint: "Use suggested_rule_action to accept, reject, or modify these suggestions."
+                  })
+                }
+              ]
+            };
+          }
+          case "suggested_rule_action": {
+            if (!input.rule_id || !input.rule_action) {
+              return errorResult("suggested_rule_action requires: rule_id, rule_action (accept/reject/modify)");
+            }
+            const result = await client.suggestedRuleAction({
+              rule_id: input.rule_id,
+              action: input.rule_action,
+              modified_keywords: input.modified_keywords,
+              modified_instruction: input.modified_instruction
+            });
+            const actionVerb = input.rule_action === "accept" ? "accepted" : input.rule_action === "reject" ? "rejected" : "modified";
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatContent({
+                    success: true,
+                    message: `Rule ${actionVerb} successfully`,
+                    rule: result?.data || result,
+                    hint: input.rule_action === "accept" ? "This rule will now be applied to future context() calls." : input.rule_action === "reject" ? "This pattern will have reduced confidence for future suggestions." : "The modified rule will be applied to future context() calls."
+                  })
+                }
+              ]
+            };
+          }
+          case "suggested_rules_stats": {
+            const result = await client.getSuggestedRulesStats({
+              workspace_id: workspaceId
+            });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatContent({
+                    stats: result?.data || result,
+                    hint: "These stats show ML vs Grok accuracy. The blend weight auto-adjusts based on these metrics."
+                  })
+                }
+              ]
+            };
+          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }
@@ -20645,7 +20931,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       "memory",
       {
         title: "Memory",
-        description: `Memory operations for events and nodes. Event actions: create_event, get_event, update_event, delete_event, list_events, distill_event, import_batch (bulk import array of events). Node actions: create_node, get_node, update_node, delete_node, list_nodes, supersede_node. Query actions: search, decisions, timeline, summary. Task actions: create_task (create task, optionally linked to plan), get_task, update_task (can link/unlink task to plan via plan_id), delete_task, list_tasks, reorder_tasks. Todo actions: create_todo, list_todos, get_todo, update_todo, delete_todo, complete_todo. Diagram actions: create_diagram, list_diagrams, get_diagram, update_diagram, delete_diagram. Doc actions: create_doc, list_docs, get_doc, update_doc, delete_doc, create_roadmap. Team actions (team plans only): team_tasks, team_todos, team_diagrams, team_docs.`,
+        description: `Memory operations for events and nodes. Event actions: create_event, get_event, update_event, delete_event, list_events, distill_event, import_batch (bulk import array of events). Node actions: create_node, get_node, update_node, delete_node, list_nodes, supersede_node. Query actions: search, decisions, timeline, summary. Task actions: create_task (create task, optionally linked to plan), get_task, update_task (can link/unlink task to plan via plan_id), delete_task, list_tasks, reorder_tasks. Todo actions: create_todo, list_todos, get_todo, update_todo, delete_todo, complete_todo. Diagram actions: create_diagram, list_diagrams, get_diagram, update_diagram, delete_diagram. Doc actions: create_doc, list_docs, get_doc, update_doc, delete_doc, create_roadmap. Transcript actions: list_transcripts (list saved conversations), get_transcript (get full transcript by ID), search_transcripts (semantic search across conversations), delete_transcript. Team actions (team plans only): team_tasks, team_todos, team_diagrams, team_docs.`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "create_event",
@@ -20693,6 +20979,11 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "update_doc",
             "delete_doc",
             "create_roadmap",
+            // Transcript actions
+            "list_transcripts",
+            "get_transcript",
+            "search_transcripts",
+            "delete_transcript",
             // Team actions
             "team_tasks",
             "team_todos",
@@ -20798,7 +21089,13 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             })
           ).optional().describe("Milestones for create_roadmap action"),
           // Personal items param
-          is_personal: external_exports.boolean().optional().describe("Mark as personal (only visible to creator). For create/list actions on todos, diagrams, docs.")
+          is_personal: external_exports.boolean().optional().describe("Mark as personal (only visible to creator). For create/list actions on todos, diagrams, docs."),
+          // Transcript params
+          transcript_id: external_exports.string().uuid().optional().describe("Transcript ID for get_transcript/delete_transcript"),
+          session_id: external_exports.string().optional().describe("Session ID filter for list_transcripts"),
+          client_name: external_exports.string().optional().describe("Client name filter for list_transcripts (e.g., 'claude', 'cursor')"),
+          started_after: external_exports.string().optional().describe("ISO timestamp - filter transcripts started after this time"),
+          started_before: external_exports.string().optional().describe("ISO timestamp - filter transcripts started before this time")
         })
       },
       async (input) => {
@@ -21572,6 +21869,54 @@ ${formatContent(result)}`
               ]
             };
           }
+          // Transcript actions
+          case "list_transcripts": {
+            const result = await client.listTranscripts({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              session_id: input.session_id,
+              client_name: input.client_name,
+              started_after: input.started_after,
+              started_before: input.started_before,
+              limit: input.limit
+            });
+            const transcripts = result?.data?.items || result?.items || result?.data || [];
+            const resultWithHint = Array.isArray(transcripts) && transcripts.length === 0 ? { ...result, hint: "No transcripts found. Enable save_exchange in context() calls to save conversations." } : result;
+            return {
+              content: [{ type: "text", text: formatContent(resultWithHint) }]
+            };
+          }
+          case "get_transcript": {
+            if (!input.transcript_id) {
+              return errorResult("get_transcript requires: transcript_id");
+            }
+            const result = await client.getTranscript(input.transcript_id);
+            return {
+              content: [{ type: "text", text: formatContent(result) }]
+            };
+          }
+          case "search_transcripts": {
+            if (!input.query) {
+              return errorResult("search_transcripts requires: query");
+            }
+            const result = await client.searchTranscripts({
+              workspace_id: workspaceId,
+              query: input.query,
+              limit: input.limit
+            });
+            return {
+              content: [{ type: "text", text: formatContent(result) }]
+            };
+          }
+          case "delete_transcript": {
+            if (!input.transcript_id) {
+              return errorResult("delete_transcript requires: transcript_id");
+            }
+            const result = await client.deleteTranscript(input.transcript_id);
+            return {
+              content: [{ type: "text", text: formatContent(result) }]
+            };
+          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }
@@ -22860,6 +23205,8 @@ Example workflow:
         const projectId = resolveProjectId(input.project_id);
         switch (input.action) {
           case "index": {
+            const indexGate = await gateIfProTool("media_index");
+            if (indexGate) return indexGate;
             if (!input.file_path && !input.external_url) {
               return errorResult("index requires: file_path or external_url");
             }
@@ -23024,6 +23371,8 @@ Created: ${content.created_at}`
             }
           }
           case "search": {
+            const searchGate = await gateIfProTool("media_search");
+            if (searchGate) return searchGate;
             if (!input.query) {
               return errorResult("search requires: query");
             }
@@ -24244,6 +24593,7 @@ function registerPrompts(server) {
 }
 
 // src/session-manager.ts
+import { randomUUID as randomUUID2 } from "crypto";
 var SessionManager = class _SessionManager {
   constructor(server, client) {
     this.server = server;
@@ -24275,12 +24625,20 @@ var SessionManager = class _SessionManager {
     this.lastHighPressureAt = null;
     this.lastHighPressureTokens = 0;
     this.postCompactRestoreCompleted = false;
+    this.sessionId = `mcp-${randomUUID2()}`;
   }
   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;
   }
+  /**
+   * Get the unique session ID for this MCP connection.
+   * Used for transcript saving and session association.
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
   /**
    * Check if session has been auto-initialized
    */
@@ -24815,7 +25173,7 @@ var SessionManager = class _SessionManager {
 
 // src/http-gateway.ts
 import { createServer } from "node:http";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 var HOST = process.env.MCP_HTTP_HOST || "0.0.0.0";
@@ -24992,7 +25350,7 @@ async function createSession() {
     registerPrompts(server);
   }
   const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: () => randomUUID2(),
+    sessionIdGenerator: () => randomUUID3(),
     enableJsonResponse: ENABLE_JSON_RESPONSE,
     onsessionclosed: (sessionId) => {
       sessions.delete(sessionId);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.4.49",
+  "version": "0.4.50",
   "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",