@contextstream/mcp-server 0.4.50 → 0.4.53

package/dist/hooks/session-end.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+// src/hooks/session-end.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_SESSION_END_ENABLED !== "false";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+function parseTranscriptStats(transcriptPath) {
+  const stats = {
+    messageCount: 0,
+    toolCallCount: 0,
+    duration: 0,
+    filesModified: []
+  };
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    return stats;
+  }
+  try {
+    const content = fs.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n");
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    const modifiedFiles = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user" || entry.type === "assistant") {
+          stats.messageCount++;
+        } else if (entry.type === "tool_use") {
+          stats.toolCallCount++;
+          if (["Write", "Edit", "NotebookEdit"].includes(entry.name || "")) {
+            const filePath = entry.input?.file_path;
+            if (filePath) {
+              modifiedFiles.add(filePath);
+            }
+          }
+        }
+        if (entry.timestamp) {
+          const ts = new Date(entry.timestamp);
+          if (!firstTimestamp || ts < firstTimestamp) {
+            firstTimestamp = ts;
+          }
+          if (!lastTimestamp || ts > lastTimestamp) {
+            lastTimestamp = ts;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (firstTimestamp && lastTimestamp) {
+      stats.duration = Math.round((lastTimestamp.getTime() - firstTimestamp.getTime()) / 1e3);
+    }
+    stats.filesModified = Array.from(modifiedFiles);
+  } catch {
+  }
+  return stats;
+}
+async function finalizeSession(sessionId, stats, reason) {
+  if (!API_KEY) return;
+  const payload = {
+    event_type: "session_end",
+    title: `Session Ended: ${reason}`,
+    content: JSON.stringify({
+      session_id: sessionId,
+      reason,
+      stats: {
+        messages: stats.messageCount,
+        tool_calls: stats.toolCallCount,
+        duration_seconds: stats.duration,
+        files_modified: stats.filesModified.length
+      },
+      files_modified: stats.filesModified.slice(0, 20),
+      ended_at: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "low",
+    tags: ["session", "end", reason],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    await fetch(`${API_URL}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runSessionEndHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const sessionId = input.session_id || "unknown";
+  const transcriptPath = input.transcript_path || "";
+  const reason = input.reason || "user_exit";
+  const stats = parseTranscriptStats(transcriptPath);
+  await finalizeSession(sessionId, stats, reason);
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("session-end") || process.argv[2] === "session-end";
+if (isDirectRun) {
+  runSessionEndHook().catch(() => process.exit(0));
+}
+export {
+  runSessionEndHook
+};

package/dist/hooks/session-init.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+// src/hooks/session-init.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_SESSION_INIT_ENABLED !== "false";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+var PROJECT_ID = null;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          }
+          if (csEnv?.CONTEXTSTREAM_WORKSPACE_ID) {
+            WORKSPACE_ID = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID || !PROJECT_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id && !WORKSPACE_ID) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+          if (csConfig.project_id && !PROJECT_ID) {
+            PROJECT_ID = csConfig.project_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function fetchSessionContext() {
+  if (!API_KEY) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const url = new URL(`${API_URL}/api/v1/context`);
+    if (WORKSPACE_ID) url.searchParams.set("workspace_id", WORKSPACE_ID);
+    if (PROJECT_ID) url.searchParams.set("project_id", PROJECT_ID);
+    url.searchParams.set("include_rules", "true");
+    url.searchParams.set("include_lessons", "true");
+    url.searchParams.set("include_decisions", "true");
+    url.searchParams.set("include_plans", "true");
+    url.searchParams.set("limit", "5");
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return await response.json();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatContext(ctx) {
+  if (!ctx) {
+    return `[ContextStream Session Start]
+
+No stored context found. Call \`mcp__contextstream__context(user_message="starting new session")\` to initialize.`;
+  }
+  const parts = ["[ContextStream Session Start]"];
+  if (ctx.lessons && ctx.lessons.length > 0) {
+    parts.push("\n## \u26A0\uFE0F Lessons from Past Mistakes");
+    for (const lesson of ctx.lessons.slice(0, 3)) {
+      parts.push(`- **${lesson.title}**: ${lesson.prevention}`);
+    }
+  }
+  if (ctx.active_plans && ctx.active_plans.length > 0) {
+    parts.push("\n## \u{1F4CB} Active Plans");
+    for (const plan of ctx.active_plans.slice(0, 3)) {
+      parts.push(`- ${plan.title} (${plan.status})`);
+    }
+  }
+  if (ctx.pending_tasks && ctx.pending_tasks.length > 0) {
+    parts.push("\n## \u2705 Pending Tasks");
+    for (const task of ctx.pending_tasks.slice(0, 5)) {
+      parts.push(`- ${task.title}`);
+    }
+  }
+  if (ctx.recent_decisions && ctx.recent_decisions.length > 0) {
+    parts.push("\n## \u{1F4DD} Recent Decisions");
+    for (const decision of ctx.recent_decisions.slice(0, 3)) {
+      parts.push(`- **${decision.title}**`);
+    }
+  }
+  parts.push("\n---");
+  parts.push('Call `mcp__contextstream__context(user_message="...")` for task-specific context.');
+  return parts.join("\n");
+}
+async function runSessionInitHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const context = await fetchSessionContext();
+  const formattedContext = formatContext(context);
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: formattedContext
+      }
+    })
+  );
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("session-init") || process.argv[2] === "session-init";
+if (isDirectRun) {
+  runSessionInitHook().catch(() => process.exit(0));
+}
+export {
+  runSessionInitHook
+};

package/dist/hooks/user-prompt-submit.js

@@ -1,17 +1,223 @@
 #!/usr/bin/env node
 
 // src/hooks/user-prompt-submit.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
 var ENABLED = process.env.CONTEXTSTREAM_REMINDER_ENABLED !== "false";
-var REMINDER = `[CONTEXTSTREAM - DO THIS FIRST]
-mcp__contextstream__context(user_message="<user's message>") - CALL THIS BEFORE ANY OTHER TOOL
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+var PROJECT_ID = null;
+var REMINDER = `[CONTEXTSTREAM RULES - MANDATORY]
 
-Why: Delivers task-specific rules, lessons from past mistakes, and relevant context.
-Skip it = repeat past mistakes, miss relevant decisions, fly blind.
+1. FIRST: Call mcp__contextstream__context(user_message="...") before ANY other tool
+   - Returns: dynamic rules, lessons from past mistakes, relevant context
+   - Check response for: [LESSONS_WARNING], [RULES_NOTICE], preferences
 
-BEFORE Glob/Grep/Read/Search/Explore:
-mcp__contextstream__search(mode="hybrid", query="...") FIRST
-Local tools ONLY if search returns 0 results.
+2. FOR CODE SEARCH: Check index status, then search appropriately
+   \u26A0\uFE0F BEFORE searching: mcp__contextstream__project(action="index_status")
+   \u2705 IF indexed & fresh: Use mcp__contextstream__search(mode="hybrid", query="...")
+   \u2705 IF NOT indexed OR stale: Use local tools (Glob/Grep/Read) directly
+   \u2705 IF search returns 0 results: Fallback to local tools (Glob/Grep/Read)
+
+3. WHEN LOCAL TOOLS (Glob/Grep/Read) ARE OK:
+   \u2705 Project is NOT indexed (index_status.indexed=false)
+   \u2705 Index is stale/outdated (>7 days old)
+   \u2705 ContextStream search returns 0 results or errors
+   \u2705 User explicitly requests local tools
+
+4. FOR PLANS & TASKS: Use ContextStream, not file-based plans
+   \u2705 Plans: mcp__contextstream__session(action="capture_plan", ...)
+   \u2705 Tasks: mcp__contextstream__memory(action="create_task", ...)
+   \u274C DO NOT use EnterPlanMode or write plans to markdown files
+
+5. CHECK THESE from context() response:
+   - Lessons: Past mistakes to avoid (shown as warnings)
+   - Reminders: Active reminders for this project
+   - Preferences: User's coding style and preferences
+   - Rules: Dynamic rules matched to current task
+
+6. SKIP CONTEXTSTREAM: If user preference says "skip contextstream", use local tools instead
 [END]`;
+var ENHANCED_REMINDER_HEADER = `[CONTEXTSTREAM - ENHANCED CONTEXT]
+
+`;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          }
+          if (csEnv?.CONTEXTSTREAM_WORKSPACE_ID) {
+            WORKSPACE_ID = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID || !PROJECT_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id && !WORKSPACE_ID) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+          if (csConfig.project_id && !PROJECT_ID) {
+            PROJECT_ID = csConfig.project_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function fetchSessionContext() {
+  if (!API_KEY) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    const url = new URL(`${API_URL}/api/v1/context`);
+    if (WORKSPACE_ID) url.searchParams.set("workspace_id", WORKSPACE_ID);
+    if (PROJECT_ID) url.searchParams.set("project_id", PROJECT_ID);
+    url.searchParams.set("include_lessons", "true");
+    url.searchParams.set("include_decisions", "true");
+    url.searchParams.set("include_plans", "true");
+    url.searchParams.set("include_reminders", "true");
+    url.searchParams.set("limit", "3");
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return await response.json();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function buildEnhancedReminder(ctx, isNewSession2) {
+  const parts = [ENHANCED_REMINDER_HEADER];
+  if (isNewSession2) {
+    parts.push(`## \u{1F680} NEW SESSION DETECTED
+1. Call \`init(folder_path="...")\` - this triggers project indexing
+2. Wait for indexing: if \`init\` returns \`indexing_status: "started"\`, files are being indexed
+3. Then call \`context(user_message="...")\` for task-specific context
+4. Use \`search(mode="hybrid")\` for code discovery (not Glob/Grep/Read)
+
+`);
+  }
+  if (ctx?.lessons && ctx.lessons.length > 0) {
+    parts.push(`## \u26A0\uFE0F LESSONS FROM PAST MISTAKES`);
+    for (const lesson of ctx.lessons.slice(0, 3)) {
+      parts.push(`- **${lesson.title}**: ${lesson.prevention}`);
+    }
+    parts.push("");
+  }
+  if (ctx?.active_plans && ctx.active_plans.length > 0) {
+    parts.push(`## \u{1F4CB} Active Plans`);
+    for (const plan of ctx.active_plans.slice(0, 3)) {
+      parts.push(`- ${plan.title} (${plan.status})`);
+    }
+    parts.push("");
+  }
+  if (ctx?.pending_tasks && ctx.pending_tasks.length > 0) {
+    parts.push(`## \u2705 Pending Tasks`);
+    for (const task of ctx.pending_tasks.slice(0, 5)) {
+      parts.push(`- ${task.title}`);
+    }
+    parts.push("");
+  }
+  if (ctx?.reminders && ctx.reminders.length > 0) {
+    parts.push(`## \u{1F514} Reminders`);
+    for (const reminder of ctx.reminders.slice(0, 3)) {
+      parts.push(`- ${reminder.title}`);
+    }
+    parts.push("");
+  }
+  parts.push("---\n");
+  parts.push(REMINDER);
+  parts.push(`
+
+---
+## \u{1F6A8} FILE INDEXING & SEARCH - CRITICAL (No PostToolUse Hook) \u{1F6A8}
+
+**This editor does NOT have automatic file indexing after Edit/Write.**
+
+### \u26A0\uFE0F BEFORE ANY SEARCH - Check Index Status:
+\`\`\`
+project(action="index_status")
+\`\`\`
+Returns: \`indexed\` (true/false), \`last_indexed_at\`, \`file_count\`
+
+### \u{1F50D} Search Decision Tree:
+
+**IF indexed=true AND last_indexed_at is recent:**
+\u2192 Use \`search(mode="hybrid", query="...")\`
+
+**IF indexed=false OR last_indexed_at is stale (>7 days):**
+\u2192 Use local tools (Glob/Grep/Read) directly
+\u2192 OR run \`project(action="index")\` first, then search
+
+**IF search returns 0 results or errors:**
+\u2192 Fallback to local tools (Glob/Grep/Read)
+
+### \u2705 When Local Tools (Glob/Grep/Read) Are OK:
+- Project is NOT indexed
+- Index is stale/outdated (>7 days)
+- ContextStream search returns 0 results
+- ContextStream returns errors
+- User explicitly requests local tools
+
+### On Session Start:
+1. Call \`init(folder_path="...")\` - triggers initial indexing
+2. Check \`project(action="index_status")\` before searching
+3. If not indexed: use local tools OR wait for indexing
+
+### After File Changes (Edit/Write/Create):
+Files are NOT auto-indexed. You MUST:
+1. After significant edits: \`project(action="index")\`
+2. For single file: \`project(action="ingest_local", path="<file>")\`
+3. Then search will find your changes`);
+  return parts.join("\n");
+}
 function detectEditorFormat(input) {
   if (input.hookName !== void 0) {
     return "cline";
@@ -19,8 +225,23 @@ function detectEditorFormat(input) {
   if (input.hook_event_name === "beforeSubmitPrompt") {
     return "cursor";
   }
+  if (input.hook_event_name === "beforeAgentAction" || input.hook_event_name === "onPromptSubmit") {
+    return "antigravity";
+  }
   return "claude";
 }
+function isNewSession(input, editorFormat) {
+  if (editorFormat === "claude" && input.session?.messages) {
+    return input.session.messages.length <= 1;
+  }
+  if (editorFormat === "cursor" && input.history !== void 0) {
+    return input.history.length === 0;
+  }
+  if (editorFormat === "antigravity" && input.history !== void 0) {
+    return input.history.length === 0;
+  }
+  return false;
+}
 async function runUserPromptSubmitHook() {
   if (!ENABLED) {
     process.exit(0);
@@ -39,6 +260,7 @@ async function runUserPromptSubmitHook() {
     process.exit(0);
   }
   const editorFormat = detectEditorFormat(input);
+  const cwd = input.cwd || process.cwd();
   if (editorFormat === "claude") {
     console.log(
       JSON.stringify({
@@ -49,17 +271,36 @@ async function runUserPromptSubmitHook() {
       })
     );
   } else if (editorFormat === "cline") {
+    loadConfigFromMcpJson(cwd);
+    const newSession = isNewSession(input, editorFormat);
+    const ctx = await fetchSessionContext();
+    const enhancedReminder = buildEnhancedReminder(ctx, newSession);
     console.log(
       JSON.stringify({
         cancel: false,
-        contextModification: REMINDER
+        contextModification: enhancedReminder
       })
     );
   } else if (editorFormat === "cursor") {
+    loadConfigFromMcpJson(cwd);
+    const newSession = isNewSession(input, editorFormat);
+    const ctx = await fetchSessionContext();
+    const cursorReminder = ctx?.lessons?.length ? `[CONTEXTSTREAM] \u26A0\uFE0F ${ctx.lessons.length} lessons from past mistakes. Use search(mode="hybrid") before Glob/Grep. Call context() first. After file edits: project(action="index") to re-index.` : `[CONTEXTSTREAM] Use search(mode="hybrid") before Glob/Grep/Read. Call context() first. After file edits: project(action="index") to re-index.`;
     console.log(
       JSON.stringify({
         continue: true,
-        user_message: "[CONTEXTSTREAM] Search with mcp__contextstream__search before using Glob/Grep/Read"
+        user_message: cursorReminder
+      })
+    );
+  } else if (editorFormat === "antigravity") {
+    loadConfigFromMcpJson(cwd);
+    const newSession = isNewSession(input, editorFormat);
+    const ctx = await fetchSessionContext();
+    const enhancedReminder = buildEnhancedReminder(ctx, newSession);
+    console.log(
+      JSON.stringify({
+        cancel: false,
+        contextModification: enhancedReminder
       })
     );
   }