npm - @contextstream/mcp-server - Versions diffs - 0.4.61 → 0.4.62 - Mend

@contextstream/mcp-server 0.4.61 → 0.4.62

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/hooks/auto-rules.js +1 -1
package/dist/hooks/post-write.js +1 -1
package/dist/hooks/pre-tool-use.js +308 -32
package/dist/hooks/runner.js +714 -380
package/dist/hooks/session-init.js +168 -48
package/dist/hooks/user-prompt-submit.js +127 -17
package/dist/index.js +1711 -412
package/package.json +1 -1

package/dist/hooks/runner.js CHANGED Viewed

@@ -38,14 +38,181 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
+// src/hooks/prompt-state.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+function defaultState() {
+  return { workspaces: {} };
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function ensureStateDir() {
+  try {
+    fs.mkdirSync(path.dirname(STATE_PATH), { recursive: true });
+  } catch {
+  }
+}
+function normalizePath(input) {
+  try {
+    return path.resolve(input);
+  } catch {
+    return input;
+  }
+}
+function workspacePathsMatch(a, b) {
+  const left = normalizePath(a);
+  const right = normalizePath(b);
+  return left === right || left.startsWith(`${right}${path.sep}`) || right.startsWith(`${left}${path.sep}`);
+}
+function readState() {
+  try {
+    const content = fs.readFileSync(STATE_PATH, "utf8");
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || !parsed.workspaces) {
+      return defaultState();
+    }
+    return parsed;
+  } catch {
+    return defaultState();
+  }
+}
+function writeState(state) {
+  try {
+    ensureStateDir();
+    fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+  } catch {
+  }
+}
+function getOrCreateEntry(state, cwd) {
+  if (!cwd.trim()) return null;
+  const exact = state.workspaces[cwd];
+  if (exact) return { key: cwd, entry: exact };
+  for (const [trackedCwd, trackedEntry] of Object.entries(state.workspaces)) {
+    if (workspacePathsMatch(trackedCwd, cwd)) {
+      return { key: trackedCwd, entry: trackedEntry };
+    }
+  }
+  const created = {
+    require_context: false,
+    require_init: false,
+    last_context_at: void 0,
+    last_state_change_at: void 0,
+    updated_at: nowIso()
+  };
+  state.workspaces[cwd] = created;
+  return { key: cwd, entry: created };
+}
+function cleanupStale(maxAgeSeconds) {
+  const state = readState();
+  const now = Date.now();
+  let changed = false;
+  for (const [cwd, entry] of Object.entries(state.workspaces)) {
+    const updated = new Date(entry.updated_at);
+    if (Number.isNaN(updated.getTime())) continue;
+    const ageSeconds = (now - updated.getTime()) / 1e3;
+    if (ageSeconds > maxAgeSeconds) {
+      delete state.workspaces[cwd];
+      changed = true;
+    }
+  }
+  if (changed) {
+    writeState(state);
+  }
+}
+function markContextRequired(cwd) {
+  if (!cwd.trim()) return;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  if (!target) return;
+  target.entry.require_context = true;
+  target.entry.updated_at = nowIso();
+  writeState(state);
+}
+function clearContextRequired(cwd) {
+  if (!cwd.trim()) return;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  if (!target) return;
+  target.entry.require_context = false;
+  target.entry.last_context_at = nowIso();
+  target.entry.updated_at = nowIso();
+  writeState(state);
+}
+function isContextRequired(cwd) {
+  if (!cwd.trim()) return false;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  return Boolean(target?.entry.require_context);
+}
+function markInitRequired(cwd) {
+  if (!cwd.trim()) return;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  if (!target) return;
+  target.entry.require_init = true;
+  target.entry.updated_at = nowIso();
+  writeState(state);
+}
+function clearInitRequired(cwd) {
+  if (!cwd.trim()) return;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  if (!target) return;
+  target.entry.require_init = false;
+  target.entry.updated_at = nowIso();
+  writeState(state);
+}
+function isInitRequired(cwd) {
+  if (!cwd.trim()) return false;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  return Boolean(target?.entry.require_init);
+}
+function markStateChanged(cwd) {
+  if (!cwd.trim()) return;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  if (!target) return;
+  target.entry.last_state_change_at = nowIso();
+  target.entry.updated_at = nowIso();
+  writeState(state);
+}
+function isContextFreshAndClean(cwd, maxAgeSeconds) {
+  if (!cwd.trim()) return false;
+  const state = readState();
+  const target = getOrCreateEntry(state, cwd);
+  const entry = target?.entry;
+  if (!entry?.last_context_at) return false;
+  const contextAt = new Date(entry.last_context_at);
+  if (Number.isNaN(contextAt.getTime())) return false;
+  const ageSeconds = (Date.now() - contextAt.getTime()) / 1e3;
+  if (ageSeconds < 0 || ageSeconds > maxAgeSeconds) return false;
+  if (entry.last_state_change_at) {
+    const changedAt = new Date(entry.last_state_change_at);
+    if (!Number.isNaN(changedAt.getTime()) && changedAt.getTime() > contextAt.getTime()) {
+      return false;
+    }
+  }
+  return true;
+}
+var STATE_PATH;
+var init_prompt_state = __esm({
+  "src/hooks/prompt-state.ts"() {
+    "use strict";
+    STATE_PATH = path.join(homedir(), ".contextstream", "prompt-state.json");
+  }
+});
 // src/hooks/pre-tool-use.ts
 var pre_tool_use_exports = {};
 __export(pre_tool_use_exports, {
   runPreToolUseHook: () => runPreToolUseHook
 });
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { homedir } from "node:os";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
 function isDiscoveryGlob(pattern) {
   const patternLower = pattern.toLowerCase();
   for (const p of DISCOVERY_PATTERNS) {
@@ -71,22 +238,22 @@ function isDiscoveryGrep(filePath) {
   return false;
 }
 function isProjectIndexed(cwd) {
-  if (!fs.existsSync(INDEX_STATUS_FILE)) {
+  if (!fs2.existsSync(INDEX_STATUS_FILE)) {
     return { isIndexed: false, isStale: false };
   }
   let data;
   try {
-    const content = fs.readFileSync(INDEX_STATUS_FILE, "utf-8");
+    const content = fs2.readFileSync(INDEX_STATUS_FILE, "utf-8");
     data = JSON.parse(content);
   } catch {
     return { isIndexed: false, isStale: false };
   }
   const projects = data.projects || {};
-  const cwdPath = path.resolve(cwd);
+  const cwdPath = path2.resolve(cwd);
   for (const [projectPath, info] of Object.entries(projects)) {
     try {
-      const indexedPath = path.resolve(projectPath);
-      if (cwdPath === indexedPath || cwdPath.startsWith(indexedPath + path.sep)) {
+      const indexedPath = path2.resolve(projectPath);
+      if (cwdPath === indexedPath || cwdPath.startsWith(indexedPath + path2.sep)) {
         const indexedAt = info.indexed_at;
         if (indexedAt) {
           try {
@@ -119,6 +286,97 @@ function extractToolName(input) {
 function extractToolInput(input) {
   return input.tool_input || input.parameters || input.toolParameters || {};
 }
+function normalizeContextstreamToolName(toolName) {
+  const trimmed = toolName.trim();
+  if (!trimmed) return null;
+  const lower = trimmed.toLowerCase();
+  const prefixed = "mcp__contextstream__";
+  if (lower.startsWith(prefixed)) {
+    return lower.slice(prefixed.length);
+  }
+  if (lower.startsWith("contextstream__")) {
+    return lower.slice("contextstream__".length);
+  }
+  if (lower === "init" || lower === "context") {
+    return lower;
+  }
+  return null;
+}
+function actionFromToolInput(toolInput) {
+  const maybeAction = toolInput?.action;
+  return typeof maybeAction === "string" ? maybeAction.trim().toLowerCase() : "";
+}
+function isContextstreamReadOnlyOperation(toolName, toolInput) {
+  const action = actionFromToolInput(toolInput);
+  switch (toolName) {
+    case "workspace":
+      return action === "list" || action === "get";
+    case "memory":
+      return action === "list_docs" || action === "list_events" || action === "list_todos" || action === "list_tasks" || action === "list_transcripts" || action === "list_nodes" || action === "decisions" || action === "get_doc" || action === "get_event" || action === "get_task" || action === "get_todo" || action === "get_transcript";
+    case "session":
+      return action === "get_lessons" || action === "get_plan" || action === "list_plans" || action === "recall";
+    case "help":
+      return action === "version" || action === "tools" || action === "auth";
+    case "project":
+      return action === "list" || action === "get" || action === "index_status";
+    case "reminder":
+      return action === "list" || action === "active";
+    case "context":
+    case "init":
+      return true;
+    default:
+      return false;
+  }
+}
+function isLikelyStateChangingTool(toolLower, toolInput, isContextstreamCall, normalizedContextstreamTool) {
+  if (isContextstreamCall && normalizedContextstreamTool) {
+    return !isContextstreamReadOnlyOperation(normalizedContextstreamTool, toolInput);
+  }
+  if ([
+    "read",
+    "read_file",
+    "grep",
+    "glob",
+    "search",
+    "grep_search",
+    "code_search",
+    "semanticsearch",
+    "codebase_search",
+    "list_files",
+    "search_files",
+    "search_files_content",
+    "find_files",
+    "find_by_name",
+    "ls",
+    "cat",
+    "view"
+  ].includes(toolLower)) {
+    return false;
+  }
+  const writeMarkers = [
+    "write",
+    "edit",
+    "create",
+    "delete",
+    "remove",
+    "rename",
+    "move",
+    "patch",
+    "apply",
+    "insert",
+    "append",
+    "replace",
+    "update",
+    "commit",
+    "push",
+    "install",
+    "exec",
+    "run",
+    "bash",
+    "shell"
+  ];
+  return writeMarkers.some((marker) => toolLower.includes(marker));
+}
 function blockClaudeCode(message) {
   const response = {
     hookSpecificOutput: {
@@ -127,7 +385,7 @@ function blockClaudeCode(message) {
       additionalContext: `[CONTEXTSTREAM] ${message}`
     }
   };
-  fs.appendFileSync(DEBUG_FILE, `[PreToolUse] REDIRECT (additionalContext): ${JSON.stringify(response)}
+  fs2.appendFileSync(DEBUG_FILE, `[PreToolUse] REDIRECT (additionalContext): ${JSON.stringify(response)}
 `);
   console.log(JSON.stringify(response));
   process.exit(0);
@@ -155,6 +413,25 @@ function outputCursorAllow() {
   console.log(JSON.stringify({ decision: "allow" }));
   process.exit(0);
 }
+function blockWithMessage(editorFormat, message) {
+  if (editorFormat === "cline") {
+    outputClineBlock(message, "[CONTEXTSTREAM] Follow ContextStream startup requirements.");
+  } else if (editorFormat === "cursor") {
+    outputCursorBlock(message);
+  }
+  blockClaudeCode(message);
+}
+function allowTool(editorFormat, cwd, recordStateChange) {
+  if (recordStateChange) {
+    markStateChanged(cwd);
+  }
+  if (editorFormat === "cline") {
+    outputClineAllow();
+  } else if (editorFormat === "cursor") {
+    outputCursorAllow();
+  }
+  process.exit(0);
+}
 function detectEditorFormat(input) {
   if (input.hookName !== void 0 || input.toolName !== void 0) {
     return "cline";
@@ -165,11 +442,11 @@ function detectEditorFormat(input) {
   return "claude";
 }
 async function runPreToolUseHook() {
-  fs.appendFileSync(DEBUG_FILE, `[PreToolUse] Hook invoked at ${(/* @__PURE__ */ new Date()).toISOString()}
+  fs2.appendFileSync(DEBUG_FILE, `[PreToolUse] Hook invoked at ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   console.error("[PreToolUse] Hook invoked at", (/* @__PURE__ */ new Date()).toISOString());
   if (!ENABLED) {
-    fs.appendFileSync(DEBUG_FILE, "[PreToolUse] Hook disabled, exiting\n");
+    fs2.appendFileSync(DEBUG_FILE, "[PreToolUse] Hook disabled, exiting\n");
     console.error("[PreToolUse] Hook disabled, exiting");
     process.exit(0);
   }
@@ -190,28 +467,52 @@ async function runPreToolUseHook() {
   const cwd = extractCwd(input);
   const tool = extractToolName(input);
   const toolInput = extractToolInput(input);
-  fs.appendFileSync(DEBUG_FILE, `[PreToolUse] tool=${tool}, cwd=${cwd}, editorFormat=${editorFormat}
+  const toolLower = tool.toLowerCase();
+  const normalizedContextstreamTool = normalizeContextstreamToolName(tool);
+  const isContextstreamCall = normalizedContextstreamTool !== null;
+  const recordStateChange = isLikelyStateChangingTool(
+    toolLower,
+    toolInput,
+    isContextstreamCall,
+    normalizedContextstreamTool
+  );
+  fs2.appendFileSync(DEBUG_FILE, `[PreToolUse] tool=${tool}, cwd=${cwd}, editorFormat=${editorFormat}
 `);
+  cleanupStale(180);
+  if (isInitRequired(cwd)) {
+    if (isContextstreamCall && normalizedContextstreamTool === "init") {
+      clearInitRequired(cwd);
+    } else {
+      const required = "mcp__contextstream__init(...)";
+      const msg = `First call required for this session: ${required}. Run it before any other MCP tool. Then call mcp__contextstream__context(user_message="...", save_exchange=true, session_id="<session-id>").`;
+      blockWithMessage(editorFormat, msg);
+    }
+  }
+  if (isContextRequired(cwd)) {
+    if (isContextstreamCall && normalizedContextstreamTool === "context") {
+      clearContextRequired(cwd);
+    } else if (isContextstreamCall && normalizedContextstreamTool === "init") {
+    } else if (isContextstreamCall && normalizedContextstreamTool && isContextstreamReadOnlyOperation(normalizedContextstreamTool, toolInput) && isContextFreshAndClean(cwd, CONTEXT_FRESHNESS_SECONDS)) {
+    } else {
+      const msg = 'First call required for this prompt: mcp__contextstream__context(user_message="...", save_exchange=true, session_id="<session-id>"). Run it before any other MCP tool.';
+      blockWithMessage(editorFormat, msg);
+    }
+  }
   const { isIndexed } = isProjectIndexed(cwd);
-  fs.appendFileSync(DEBUG_FILE, `[PreToolUse] isIndexed=${isIndexed}
+  fs2.appendFileSync(DEBUG_FILE, `[PreToolUse] isIndexed=${isIndexed}
 `);
   if (!isIndexed) {
-    fs.appendFileSync(DEBUG_FILE, `[PreToolUse] Project not indexed, allowing
+    fs2.appendFileSync(DEBUG_FILE, `[PreToolUse] Project not indexed, allowing
 `);
-    if (editorFormat === "cline") {
-      outputClineAllow();
-    } else if (editorFormat === "cursor") {
-      outputCursorAllow();
-    }
-    process.exit(0);
+    allowTool(editorFormat, cwd, recordStateChange);
   }
   if (tool === "Glob") {
     const pattern = toolInput?.pattern || "";
-    fs.appendFileSync(DEBUG_FILE, `[PreToolUse] Glob pattern=${pattern}, isDiscovery=${isDiscoveryGlob(pattern)}
+    fs2.appendFileSync(DEBUG_FILE, `[PreToolUse] Glob pattern=${pattern}, isDiscovery=${isDiscoveryGlob(pattern)}
 `);
     if (isDiscoveryGlob(pattern)) {
-      const msg = `STOP: Use mcp__contextstream__search(mode="auto", query="${pattern}") instead of Glob.`;
-      fs.appendFileSync(DEBUG_FILE, `[PreToolUse] Intercepting discovery glob: ${msg}
+      const msg = `This project index is current. Use mcp__contextstream__search(mode="auto", query="${pattern}") instead of Glob for faster, richer code results.`;
+      fs2.appendFileSync(DEBUG_FILE, `[PreToolUse] Intercepting discovery glob: ${msg}
 `);
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
@@ -233,7 +534,7 @@ async function runPreToolUseHook() {
         }
         blockClaudeCode(msg);
       } else {
-        const msg = `STOP: Use mcp__contextstream__search(mode="auto", query="${pattern}") instead of ${tool}.`;
+        const msg = `This project index is current. Use mcp__contextstream__search(mode="auto", query="${pattern}") instead of ${tool} for faster, richer code results.`;
         if (editorFormat === "cline") {
           outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
         } else if (editorFormat === "cursor") {
@@ -245,7 +546,7 @@ async function runPreToolUseHook() {
   } else if (tool === "Task") {
     const subagentType = toolInput?.subagent_type?.toLowerCase() || "";
     if (subagentType === "explore") {
-      const msg = 'STOP: Use mcp__contextstream__search(mode="auto") instead of Task(Explore).';
+      const msg = 'Project index is current. Use mcp__contextstream__search(mode="auto") instead of Task(Explore) for broad discovery.';
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
       } else if (editorFormat === "cursor") {
@@ -254,7 +555,7 @@ async function runPreToolUseHook() {
       blockClaudeCode(msg);
     }
     if (subagentType === "plan") {
-      const msg = 'STOP: Use mcp__contextstream__session(action="capture_plan") for planning. ContextStream plans persist across sessions.';
+      const msg = 'After your plan is ready, save it with mcp__contextstream__session(action="capture_plan"). Then create tasks with mcp__contextstream__memory(action="create_task", title="...", plan_id="...").';
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream plans for persistence.");
       } else if (editorFormat === "cursor") {
@@ -263,7 +564,7 @@ async function runPreToolUseHook() {
       blockClaudeCode(msg);
     }
   } else if (tool === "EnterPlanMode") {
-    const msg = 'STOP: Use mcp__contextstream__session(action="capture_plan", title="...", steps=[...]) instead of EnterPlanMode. ContextStream plans persist across sessions and are searchable.';
+    const msg = 'After finalizing your plan, save it to ContextStream (not a local markdown file): mcp__contextstream__session(action="capture_plan", title="...", steps=[...]). Then create tasks with mcp__contextstream__memory(action="create_task", title="...", plan_id="...").';
     if (editorFormat === "cline") {
       outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream plans for persistence.");
     } else if (editorFormat === "cursor") {
@@ -274,29 +575,27 @@ async function runPreToolUseHook() {
   if (tool === "list_files" || tool === "search_files") {
     const pattern = toolInput?.path || toolInput?.regex || "";
     if (isDiscoveryGlob(pattern) || isDiscoveryGrep(pattern)) {
-      const msg = `Use mcp__contextstream__search(mode="auto", query="${pattern}") instead of ${tool}. ContextStream search is indexed and faster.`;
+      const msg = `Project index is current. Use mcp__contextstream__search(mode="auto", query="${pattern}") instead of ${tool} for faster, richer code results.`;
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
       } else if (editorFormat === "cursor") {
         outputCursorBlock(msg);
       }
+      blockClaudeCode(msg);
     }
   }
-  if (editorFormat === "cline") {
-    outputClineAllow();
-  } else if (editorFormat === "cursor") {
-    outputCursorAllow();
-  }
-  process.exit(0);
+  allowTool(editorFormat, cwd, recordStateChange);
 }
-var ENABLED, INDEX_STATUS_FILE, DEBUG_FILE, STALE_THRESHOLD_DAYS, DISCOVERY_PATTERNS, isDirectRun;
+var ENABLED, INDEX_STATUS_FILE, DEBUG_FILE, STALE_THRESHOLD_DAYS, CONTEXT_FRESHNESS_SECONDS, DISCOVERY_PATTERNS, isDirectRun;
 var init_pre_tool_use = __esm({
   "src/hooks/pre-tool-use.ts"() {
     "use strict";
+    init_prompt_state();
     ENABLED = process.env.CONTEXTSTREAM_HOOK_ENABLED !== "false";
-    INDEX_STATUS_FILE = path.join(homedir(), ".contextstream", "indexed-projects.json");
+    INDEX_STATUS_FILE = path2.join(homedir2(), ".contextstream", "indexed-projects.json");
     DEBUG_FILE = "/tmp/pretooluse-hook-debug.log";
     STALE_THRESHOLD_DAYS = 7;
+    CONTEXT_FRESHNESS_SECONDS = 120;
     DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"];
     isDirectRun = process.argv[1]?.includes("pre-tool-use") || process.argv[2] === "pre-tool-use";
     if (isDirectRun) {
@@ -307,9 +606,9 @@ var init_pre_tool_use = __esm({
 // src/version.ts
 import { createRequire } from "module";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-import { homedir as homedir2, platform } from "os";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir3, platform } from "os";
+import { join as join3 } from "path";
 import { spawn } from "child_process";
 function getVersion() {
   if (typeof __CONTEXTSTREAM_VERSION__ !== "undefined" && __CONTEXTSTREAM_VERSION__) {
@@ -336,13 +635,13 @@ function compareVersions(v1, v2) {
   return 0;
 }
 function getCacheFilePath() {
-  return join2(homedir2(), ".contextstream", "version-cache.json");
+  return join3(homedir3(), ".contextstream", "version-cache.json");
 }
 function readCache() {
   try {
     const cacheFile = getCacheFilePath();
     if (!existsSync2(cacheFile)) return null;
-    const data = JSON.parse(readFileSync2(cacheFile, "utf-8"));
+    const data = JSON.parse(readFileSync3(cacheFile, "utf-8"));
     if (Date.now() - data.checkedAt > CACHE_TTL_MS) return null;
     return data;
   } catch {
@@ -351,12 +650,12 @@ function readCache() {
 }
 function writeCache(latestVersion) {
   try {
-    const configDir = join2(homedir2(), ".contextstream");
+    const configDir = join3(homedir3(), ".contextstream");
     if (!existsSync2(configDir)) {
-      mkdirSync(configDir, { recursive: true });
+      mkdirSync2(configDir, { recursive: true });
     }
     const cacheFile = getCacheFilePath();
-    writeFileSync(
+    writeFileSync2(
       cacheFile,
       JSON.stringify({
         latestVersion,
@@ -467,9 +766,9 @@ function isAutoUpdateEnabled() {
     return false;
   }
   try {
-    const configPath = join2(homedir2(), ".contextstream", "config.json");
+    const configPath = join3(homedir3(), ".contextstream", "config.json");
     if (existsSync2(configPath)) {
-      const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync3(configPath, "utf-8"));
       if (config.auto_update === false) {
         return false;
       }
@@ -530,7 +829,7 @@ function detectUpdateMethod() {
   return "curl";
 }
 async function runUpdate(method) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     let command;
     let args;
     let shell;
@@ -561,23 +860,23 @@ async function runUpdate(method) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve14();
+        resolve15();
       } else {
         reject(new Error(`Update process exited with code ${code}`));
       }
     });
     proc.unref();
-    setTimeout(() => resolve14(), 1e3);
+    setTimeout(() => resolve15(), 1e3);
   });
 }
 function writeUpdateMarker(previousVersion, newVersion) {
   try {
-    const markerPath = join2(homedir2(), ".contextstream", "update-pending.json");
-    const configDir = join2(homedir2(), ".contextstream");
+    const markerPath = join3(homedir3(), ".contextstream", "update-pending.json");
+    const configDir = join3(homedir3(), ".contextstream");
     if (!existsSync2(configDir)) {
-      mkdirSync(configDir, { recursive: true });
+      mkdirSync2(configDir, { recursive: true });
     }
-    writeFileSync(markerPath, JSON.stringify({
+    writeFileSync2(markerPath, JSON.stringify({
       previousVersion,
       newVersion,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -587,9 +886,9 @@ function writeUpdateMarker(previousVersion, newVersion) {
 }
 function checkUpdateMarker() {
   try {
-    const markerPath = join2(homedir2(), ".contextstream", "update-pending.json");
+    const markerPath = join3(homedir3(), ".contextstream", "update-pending.json");
     if (!existsSync2(markerPath)) return null;
-    const marker = JSON.parse(readFileSync2(markerPath, "utf-8"));
+    const marker = JSON.parse(readFileSync3(markerPath, "utf-8"));
     const updatedAt = new Date(marker.updatedAt);
     const hourAgo = new Date(Date.now() - 60 * 60 * 1e3);
     if (updatedAt < hourAgo) {
@@ -606,7 +905,7 @@ function checkUpdateMarker() {
 }
 function clearUpdateMarker() {
   try {
-    const markerPath = join2(homedir2(), ".contextstream", "update-pending.json");
+    const markerPath = join3(homedir3(), ".contextstream", "update-pending.json");
     if (existsSync2(markerPath)) {
       __require("fs").unlinkSync(markerPath);
     }
@@ -636,17 +935,17 @@ var user_prompt_submit_exports = {};
 __export(user_prompt_submit_exports, {
   runUserPromptSubmitHook: () => runUserPromptSubmitHook
 });
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import { homedir as homedir3 } from "node:os";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import { homedir as homedir4 } from "node:os";
 function loadConfigFromMcpJson(cwd) {
-  let searchDir = path2.resolve(cwd);
+  let searchDir = path3.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY) {
-      const mcpPath = path2.join(searchDir, ".mcp.json");
-      if (fs2.existsSync(mcpPath)) {
+      const mcpPath = path3.join(searchDir, ".mcp.json");
+      if (fs3.existsSync(mcpPath)) {
         try {
-          const content = fs2.readFileSync(mcpPath, "utf-8");
+          const content = fs3.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -663,10 +962,10 @@ function loadConfigFromMcpJson(cwd) {
       }
     }
     if (!WORKSPACE_ID || !PROJECT_ID) {
-      const csConfigPath = path2.join(searchDir, ".contextstream", "config.json");
-      if (fs2.existsSync(csConfigPath)) {
+      const csConfigPath = path3.join(searchDir, ".contextstream", "config.json");
+      if (fs3.existsSync(csConfigPath)) {
         try {
-          const content = fs2.readFileSync(csConfigPath, "utf-8");
+          const content = fs3.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id && !WORKSPACE_ID) {
             WORKSPACE_ID = csConfig.workspace_id;
@@ -678,15 +977,15 @@ function loadConfigFromMcpJson(cwd) {
         }
       }
     }
-    const parentDir = path2.dirname(searchDir);
+    const parentDir = path3.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY) {
-    const homeMcpPath = path2.join(homedir3(), ".mcp.json");
-    if (fs2.existsSync(homeMcpPath)) {
+    const homeMcpPath = path3.join(homedir4(), ".mcp.json");
+    if (fs3.existsSync(homeMcpPath)) {
       try {
-        const content = fs2.readFileSync(homeMcpPath, "utf-8");
+        const content = fs3.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -702,7 +1001,7 @@ function loadConfigFromMcpJson(cwd) {
 }
 function readTranscriptFile(transcriptPath) {
   try {
-    const content = fs2.readFileSync(transcriptPath, "utf-8");
+    const content = fs3.readFileSync(transcriptPath, "utf-8");
     const lines = content.trim().split("\n");
     const messages = [];
     for (const line of lines) {
@@ -1110,6 +1409,11 @@ async function runUserPromptSubmitHook() {
   }
   const editorFormat = detectEditorFormat2(input);
   const cwd = input.cwd || process.cwd();
+  cleanupStale(180);
+  markContextRequired(cwd);
+  if (isNewSession(input, editorFormat)) {
+    markInitRequired(cwd);
+  }
   if (editorFormat === "claude") {
     loadConfigFromMcpJson(cwd);
     let context = REMINDER;
@@ -1166,20 +1470,23 @@ var init_user_prompt_submit = __esm({
   "src/hooks/user-prompt-submit.ts"() {
     "use strict";
     init_version();
+    init_prompt_state();
     ENABLED2 = process.env.CONTEXTSTREAM_REMINDER_ENABLED !== "false";
     API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
     API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
     WORKSPACE_ID = null;
     PROJECT_ID = null;
-    REMINDER = `[CONTEXTSTREAM] Call mcp__contextstream__context(user_message="...", save_exchange=true, session_id="<session-id>") FIRST before any other tool. Response contains dynamic rules, lessons, preferences. For search: use search(mode="auto") if indexed, else local tools.
+    REMINDER = `[CONTEXTSTREAM] On the first message in every session call mcp__contextstream__init(...), then call mcp__contextstream__context(user_message="...", save_exchange=true, session_id="<session-id>") FIRST before any other tool. On subsequent messages, default to context first. Narrow bypass is allowed only for immediate read-only ContextStream calls when prior context is fresh and no state-changing tool has run. Response contains dynamic rules, lessons, preferences.
+COMMON MEMORY CALLS: list docs via memory(action="list_docs"), list lessons via session(action="get_lessons"), list plans via session(action="list_plans"), list tasks/todos via memory(action="list_tasks"|"list_todos").
 [END]`;
     FULL_REMINDER = `[CONTEXTSTREAM RULES - MANDATORY]
-1. FIRST: Call mcp__contextstream__context(user_message="...", save_exchange=true, session_id="<session-id>") before ANY other tool
+1. FIRST MESSAGE IN SESSION: Call mcp__contextstream__init(...) then mcp__contextstream__context(user_message="...", save_exchange=true, session_id="<session-id>")
    - Returns: dynamic rules, lessons from past mistakes, relevant context
    - Check response for: [LESSONS_WARNING], [RULES_NOTICE], preferences
    - save_exchange=true saves each conversation turn for later retrieval
    - Use a consistent session_id for the entire conversation (generate once on first message)
+   - On subsequent messages, default to context() first. Narrow bypass: immediate read-only ContextStream calls when context is fresh and no state-changing tool has run.
 2. FOR CODE SEARCH: Check index status, then search appropriately
    \u26A0\uFE0F BEFORE searching: mcp__contextstream__project(action="index_status")
@@ -1330,17 +1637,17 @@ var pre_compact_exports = {};
 __export(pre_compact_exports, {
   runPreCompactHook: () => runPreCompactHook
 });
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-import { homedir as homedir4 } from "node:os";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+import { homedir as homedir5 } from "node:os";
 function loadConfigFromMcpJson2(cwd) {
-  let searchDir = path3.resolve(cwd);
+  let searchDir = path4.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY2) {
-      const mcpPath = path3.join(searchDir, ".mcp.json");
-      if (fs3.existsSync(mcpPath)) {
+      const mcpPath = path4.join(searchDir, ".mcp.json");
+      if (fs4.existsSync(mcpPath)) {
         try {
-          const content = fs3.readFileSync(mcpPath, "utf-8");
+          const content = fs4.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -1354,10 +1661,10 @@ function loadConfigFromMcpJson2(cwd) {
       }
     }
     if (!WORKSPACE_ID2) {
-      const csConfigPath = path3.join(searchDir, ".contextstream", "config.json");
-      if (fs3.existsSync(csConfigPath)) {
+      const csConfigPath = path4.join(searchDir, ".contextstream", "config.json");
+      if (fs4.existsSync(csConfigPath)) {
         try {
-          const content = fs3.readFileSync(csConfigPath, "utf-8");
+          const content = fs4.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID2 = csConfig.workspace_id;
@@ -1366,15 +1673,15 @@ function loadConfigFromMcpJson2(cwd) {
         }
       }
     }
-    const parentDir = path3.dirname(searchDir);
+    const parentDir = path4.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY2) {
-    const homeMcpPath = path3.join(homedir4(), ".mcp.json");
-    if (fs3.existsSync(homeMcpPath)) {
+    const homeMcpPath = path4.join(homedir5(), ".mcp.json");
+    if (fs4.existsSync(homeMcpPath)) {
       try {
-        const content = fs3.readFileSync(homeMcpPath, "utf-8");
+        const content = fs4.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -1396,7 +1703,7 @@ function parseTranscript(transcriptPath) {
   let startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let firstTimestamp = true;
   try {
-    const content = fs3.readFileSync(transcriptPath, "utf-8");
+    const content = fs4.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       if (!line.trim()) continue;
@@ -1597,7 +1904,7 @@ async function runPreCompactHook() {
     messages: [],
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (transcriptPath && fs3.existsSync(transcriptPath)) {
+  if (transcriptPath && fs4.existsSync(transcriptPath)) {
     transcriptData = parseTranscript(transcriptPath);
   }
   let autoSaveStatus = "";
@@ -1656,17 +1963,17 @@ var post_compact_exports = {};
 __export(post_compact_exports, {
   runPostCompactHook: () => runPostCompactHook
 });
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
-import { homedir as homedir5 } from "node:os";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+import { homedir as homedir6 } from "node:os";
 function loadConfigFromMcpJson3(cwd) {
-  let searchDir = path4.resolve(cwd);
+  let searchDir = path5.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY3) {
-      const mcpPath = path4.join(searchDir, ".mcp.json");
-      if (fs4.existsSync(mcpPath)) {
+      const mcpPath = path5.join(searchDir, ".mcp.json");
+      if (fs5.existsSync(mcpPath)) {
         try {
-          const content = fs4.readFileSync(mcpPath, "utf-8");
+          const content = fs5.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -1680,10 +1987,10 @@ function loadConfigFromMcpJson3(cwd) {
       }
     }
     if (!WORKSPACE_ID3) {
-      const csConfigPath = path4.join(searchDir, ".contextstream", "config.json");
-      if (fs4.existsSync(csConfigPath)) {
+      const csConfigPath = path5.join(searchDir, ".contextstream", "config.json");
+      if (fs5.existsSync(csConfigPath)) {
         try {
-          const content = fs4.readFileSync(csConfigPath, "utf-8");
+          const content = fs5.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID3 = csConfig.workspace_id;
@@ -1692,15 +1999,15 @@ function loadConfigFromMcpJson3(cwd) {
         }
       }
     }
-    const parentDir = path4.dirname(searchDir);
+    const parentDir = path5.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY3) {
-    const homeMcpPath = path4.join(homedir5(), ".mcp.json");
-    if (fs4.existsSync(homeMcpPath)) {
+    const homeMcpPath = path5.join(homedir6(), ".mcp.json");
+    if (fs5.existsSync(homeMcpPath)) {
       try {
-        const content = fs4.readFileSync(homeMcpPath, "utf-8");
+        const content = fs5.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -1834,9 +2141,9 @@ var post_write_exports = {};
 __export(post_write_exports, {
   runPostWriteHook: () => runPostWriteHook
 });
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
-import { homedir as homedir6 } from "node:os";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import { homedir as homedir7 } from "node:os";
 function extractFilePath(input) {
   if (input.tool_input) {
     const filePath = input.tool_input.file_path || input.tool_input.notebook_path || input.tool_input.path;
@@ -1861,17 +2168,17 @@ function extractCwd2(input) {
   return process.cwd();
 }
 function findLocalConfig(startDir) {
-  let currentDir = path5.resolve(startDir);
+  let currentDir = path6.resolve(startDir);
   for (let i = 0; i < 10; i++) {
-    const configPath = path5.join(currentDir, ".contextstream", "config.json");
-    if (fs5.existsSync(configPath)) {
+    const configPath = path6.join(currentDir, ".contextstream", "config.json");
+    if (fs6.existsSync(configPath)) {
       try {
-        const content = fs5.readFileSync(configPath, "utf-8");
+        const content = fs6.readFileSync(configPath, "utf-8");
         return JSON.parse(content);
       } catch {
       }
     }
-    const parentDir = path5.dirname(currentDir);
+    const parentDir = path6.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -1883,12 +2190,12 @@ function loadApiConfig(startDir) {
   if (apiKey) {
     return { apiUrl, apiKey };
   }
-  let currentDir = path5.resolve(startDir);
+  let currentDir = path6.resolve(startDir);
   for (let i = 0; i < 10; i++) {
-    const mcpPath = path5.join(currentDir, ".mcp.json");
-    if (fs5.existsSync(mcpPath)) {
+    const mcpPath = path6.join(currentDir, ".mcp.json");
+    if (fs6.existsSync(mcpPath)) {
       try {
-        const content = fs5.readFileSync(mcpPath, "utf-8");
+        const content = fs6.readFileSync(mcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -1901,15 +2208,15 @@ function loadApiConfig(startDir) {
       } catch {
       }
     }
-    const parentDir = path5.dirname(currentDir);
+    const parentDir = path6.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
   if (!apiKey) {
-    const homeMcpPath = path5.join(homedir6(), ".mcp.json");
-    if (fs5.existsSync(homeMcpPath)) {
+    const homeMcpPath = path6.join(homedir7(), ".mcp.json");
+    if (fs6.existsSync(homeMcpPath)) {
       try {
-        const content = fs5.readFileSync(homeMcpPath, "utf-8");
+        const content = fs6.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -1925,15 +2232,15 @@ function loadApiConfig(startDir) {
   return { apiUrl, apiKey };
 }
 function shouldIndexFile(filePath) {
-  const ext = path5.extname(filePath).toLowerCase();
+  const ext = path6.extname(filePath).toLowerCase();
   if (!INDEXABLE_EXTENSIONS.has(ext)) {
-    const basename2 = path5.basename(filePath).toLowerCase();
+    const basename2 = path6.basename(filePath).toLowerCase();
     if (!["dockerfile", "makefile", "rakefile", "gemfile", "procfile"].includes(basename2)) {
       return false;
     }
   }
   try {
-    const stats = fs5.statSync(filePath);
+    const stats = fs6.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE) {
       return false;
     }
@@ -1943,7 +2250,7 @@ function shouldIndexFile(filePath) {
   return true;
 }
 function detectLanguage(filePath) {
-  const ext = path5.extname(filePath).toLowerCase();
+  const ext = path6.extname(filePath).toLowerCase();
   const langMap = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -2012,8 +2319,8 @@ function detectLanguage(filePath) {
   return langMap[ext] || "text";
 }
 async function indexFile(filePath, projectId, apiUrl, apiKey, projectRoot) {
-  const content = fs5.readFileSync(filePath, "utf-8");
-  const relativePath = path5.relative(projectRoot, filePath);
+  const content = fs6.readFileSync(filePath, "utf-8");
+  const relativePath = path6.relative(projectRoot, filePath);
   const payload = {
     files: [
       {
@@ -2045,13 +2352,13 @@ async function indexFile(filePath, projectId, apiUrl, apiKey, projectRoot) {
   }
 }
 function findProjectRoot(filePath) {
-  let currentDir = path5.dirname(path5.resolve(filePath));
+  let currentDir = path6.dirname(path6.resolve(filePath));
   for (let i = 0; i < 10; i++) {
-    const configPath = path5.join(currentDir, ".contextstream", "config.json");
-    if (fs5.existsSync(configPath)) {
+    const configPath = path6.join(currentDir, ".contextstream", "config.json");
+    if (fs6.existsSync(configPath)) {
       return currentDir;
     }
-    const parentDir = path5.dirname(currentDir);
+    const parentDir = path6.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -2079,8 +2386,8 @@ async function runPostWriteHook() {
     process.exit(0);
   }
   const cwd = extractCwd2(input);
-  const absolutePath = path5.isAbsolute(filePath) ? filePath : path5.resolve(cwd, filePath);
-  if (!fs5.existsSync(absolutePath) || !shouldIndexFile(absolutePath)) {
+  const absolutePath = path6.isAbsolute(filePath) ? filePath : path6.resolve(cwd, filePath);
+  if (!fs6.existsSync(absolutePath) || !shouldIndexFile(absolutePath)) {
     process.exit(0);
   }
   const projectRoot = findProjectRoot(absolutePath);
@@ -2175,7 +2482,7 @@ var init_post_write = __esm({
       ".prisma",
       ".proto"
     ]);
-    MAX_FILE_SIZE = 1024 * 1024;
+    MAX_FILE_SIZE = 5 * 1024 * 1024;
     isDirectRun6 = process.argv[1]?.includes("post-write") || process.argv[2] === "post-write";
     if (isDirectRun6) {
       runPostWriteHook().catch(() => process.exit(0));
@@ -2480,7 +2787,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path16, checkUnignored, mode) {
+      test(path17, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -2489,7 +2796,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path16);
+          const matched = rule[mode].test(path17);
           if (!matched) {
             return;
           }
@@ -2510,17 +2817,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path16, originalPath, doThrow) => {
-      if (!isString(path16)) {
+    var checkPath = (path17, originalPath, doThrow) => {
+      if (!isString(path17)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path16) {
+      if (!path17) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path16)) {
+      if (checkPath.isNotRelative(path17)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -2529,7 +2836,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path16) => REGEX_TEST_INVALID_PATH.test(path16);
+    var isNotRelative = (path17) => REGEX_TEST_INVALID_PATH.test(path17);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -2559,19 +2866,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path16 = originalPath && checkPath.convert(originalPath);
+        const path17 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path16,
+          path17,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path16, cache, checkUnignored, slices);
+        return this._t(path17, cache, checkUnignored, slices);
       }
-      checkIgnore(path16) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path16)) {
-          return this.test(path16);
+      checkIgnore(path17) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path17)) {
+          return this.test(path17);
         }
-        const slices = path16.split(SLASH).filter(Boolean);
+        const slices = path17.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -2584,18 +2891,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path16, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path17, false, MODE_CHECK_IGNORE);
       }
-      _t(path16, cache, checkUnignored, slices) {
-        if (path16 in cache) {
-          return cache[path16];
+      _t(path17, cache, checkUnignored, slices) {
+        if (path17 in cache) {
+          return cache[path17];
         }
         if (!slices) {
-          slices = path16.split(SLASH).filter(Boolean);
+          slices = path17.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path16] = this._rules.test(path16, checkUnignored, MODE_IGNORE);
+          return cache[path17] = this._rules.test(path17, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -2603,29 +2910,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path16] = parent.ignored ? parent : this._rules.test(path16, checkUnignored, MODE_IGNORE);
+        return cache[path17] = parent.ignored ? parent : this._rules.test(path17, checkUnignored, MODE_IGNORE);
       }
-      ignores(path16) {
-        return this._test(path16, this._ignoreCache, false).ignored;
+      ignores(path17) {
+        return this._test(path17, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path16) => !this.ignores(path16);
+        return (path17) => !this.ignores(path17);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path16) {
-        return this._test(path16, this._testCache, true);
+      test(path17) {
+        return this._test(path17, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path16) => checkPath(path16 && checkPath.convert(path16), path16, RETURN_FALSE);
+    var isPathValid = (path17) => checkPath(path17 && checkPath.convert(path17), path17, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path16) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path16) || isNotRelative(path16);
+      checkPath.isNotRelative = (path17) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path17) || isNotRelative(path17);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -2641,16 +2948,16 @@ var require_ignore = __commonJS({
 });
 // src/ignore.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 async function loadIgnorePatterns(projectRoot) {
   const ig = (0, import_ignore.default)();
   const patterns = [...DEFAULT_IGNORE_PATTERNS];
   ig.add(DEFAULT_IGNORE_PATTERNS);
-  const ignoreFilePath = path6.join(projectRoot, IGNORE_FILENAME);
+  const ignoreFilePath = path7.join(projectRoot, IGNORE_FILENAME);
   let hasUserPatterns = false;
   try {
-    const content = await fs6.promises.readFile(ignoreFilePath, "utf-8");
+    const content = await fs7.promises.readFile(ignoreFilePath, "utf-8");
     const userPatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     if (userPatterns.length > 0) {
       ig.add(userPatterns);
@@ -2731,8 +3038,8 @@ __export(files_exports, {
   sha256Hex: () => sha256Hex,
   writeHashManifest: () => writeHashManifest
 });
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 import * as os from "os";
@@ -2852,14 +3159,14 @@ async function readFilesFromDirectory(rootPath, options = {}) {
     if (files.length >= maxFiles) return;
     let entries;
     try {
-      entries = await fs7.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs8.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (files.length >= maxFiles) break;
-      const fullPath = path7.join(dir, entry.name);
-      const relPath = path7.join(relativePath, entry.name);
+      const fullPath = path8.join(dir, entry.name);
+      const relPath = path8.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
         if (ig.ignores(relPath + "/")) continue;
@@ -2870,9 +3177,9 @@ async function readFilesFromDirectory(rootPath, options = {}) {
         const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (!CODE_EXTENSIONS.has(ext)) continue;
         try {
-          const stat = await fs7.promises.stat(fullPath);
+          const stat = await fs8.promises.stat(fullPath);
           if (stat.size > maxFileSize) continue;
-          const content = await fs7.promises.readFile(fullPath, "utf-8");
+          const content = await fs8.promises.readFile(fullPath, "utf-8");
           const file = {
             path: relPath,
             content,
@@ -2911,13 +3218,13 @@ async function* readAllFilesInBatches(rootPath, options = {}) {
   async function* walkDir(dir, relativePath = "") {
     let entries;
     try {
-      entries = await fs7.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs8.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path7.join(dir, entry.name);
-      const relPath = path7.join(relativePath, entry.name);
+      const fullPath = path8.join(dir, entry.name);
+      const relPath = path8.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
         if (ig.ignores(relPath + "/")) continue;
@@ -2928,9 +3235,9 @@ async function* readAllFilesInBatches(rootPath, options = {}) {
         const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (!CODE_EXTENSIONS.has(ext)) continue;
         try {
-          const stat = await fs7.promises.stat(fullPath);
+          const stat = await fs8.promises.stat(fullPath);
           if (stat.size > maxFileSize) continue;
-          const content = await fs7.promises.readFile(fullPath, "utf-8");
+          const content = await fs8.promises.readFile(fullPath, "utf-8");
           const file = {
             path: relPath,
             content,
@@ -2997,13 +3304,13 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
   async function* walkDir(dir, relativePath = "") {
     let entries;
     try {
-      entries = await fs7.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs8.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path7.join(dir, entry.name);
-      const relPath = path7.join(relativePath, entry.name);
+      const fullPath = path8.join(dir, entry.name);
+      const relPath = path8.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
         if (ig.ignores(relPath + "/")) continue;
@@ -3014,11 +3321,11 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
         const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (!CODE_EXTENSIONS.has(ext)) continue;
         try {
-          const stat = await fs7.promises.stat(fullPath);
+          const stat = await fs8.promises.stat(fullPath);
           filesScanned++;
           if (stat.mtimeMs <= sinceMs) continue;
           if (stat.size > maxFileSize) continue;
-          const content = await fs7.promises.readFile(fullPath, "utf-8");
+          const content = await fs8.promises.readFile(fullPath, "utf-8");
           filesChanged++;
           const file = {
             path: relPath,
@@ -3087,7 +3394,7 @@ async function countIndexableFiles(rootPath, options = {}) {
     }
     let entries;
     try {
-      entries = await fs7.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs8.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -3096,8 +3403,8 @@ async function countIndexableFiles(rootPath, options = {}) {
         stopped = true;
         return;
       }
-      const fullPath = path7.join(dir, entry.name);
-      const relPath = path7.join(relativePath, entry.name);
+      const fullPath = path8.join(dir, entry.name);
+      const relPath = path8.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
         if (ig.ignores(relPath + "/")) continue;
@@ -3108,7 +3415,7 @@ async function countIndexableFiles(rootPath, options = {}) {
         const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (!CODE_EXTENSIONS.has(ext)) continue;
         try {
-          const stat = await fs7.promises.stat(fullPath);
+          const stat = await fs8.promises.stat(fullPath);
           if (stat.size > maxFileSize) continue;
           count++;
           if (count >= maxFiles) {
@@ -3160,11 +3467,11 @@ function sha256Hex(content) {
   return crypto.createHash("sha256").update(content).digest("hex");
 }
 function hashManifestPath(projectId) {
-  return path7.join(os.homedir(), ".contextstream", "file-hashes", `${projectId}.json`);
+  return path8.join(os.homedir(), ".contextstream", "file-hashes", `${projectId}.json`);
 }
 function readHashManifest(projectId) {
   try {
-    const content = fs7.readFileSync(hashManifestPath(projectId), "utf-8");
+    const content = fs8.readFileSync(hashManifestPath(projectId), "utf-8");
     const parsed = JSON.parse(content);
     return new Map(Object.entries(parsed));
   } catch {
@@ -3174,16 +3481,16 @@ function readHashManifest(projectId) {
 function writeHashManifest(projectId, hashes) {
   const filePath = hashManifestPath(projectId);
   try {
-    const dir = path7.dirname(filePath);
-    fs7.mkdirSync(dir, { recursive: true });
+    const dir = path8.dirname(filePath);
+    fs8.mkdirSync(dir, { recursive: true });
     const obj = Object.fromEntries(hashes);
-    fs7.writeFileSync(filePath, JSON.stringify(obj, null, 2));
+    fs8.writeFileSync(filePath, JSON.stringify(obj, null, 2));
   } catch {
   }
 }
 function deleteHashManifest(projectId) {
   try {
-    fs7.unlinkSync(hashManifestPath(projectId));
+    fs8.unlinkSync(hashManifestPath(projectId));
   } catch {
   }
 }
@@ -3296,7 +3603,7 @@ var init_files = __esm({
       "Gemfile.lock",
       "composer.lock"
     ]);
-    MAX_FILE_SIZE2 = 1024 * 1024;
+    MAX_FILE_SIZE2 = 5 * 1024 * 1024;
     MAX_BATCH_BYTES = 10 * 1024 * 1024;
     LARGE_FILE_THRESHOLD = 2 * 1024 * 1024;
     MAX_FILES_PER_BATCH = 200;
@@ -3347,17 +3654,17 @@ __export(hooks_config_exports, {
   writeCursorHooksConfig: () => writeCursorHooksConfig,
   writeIndexStatus: () => writeIndexStatus
 });
-import * as fs8 from "node:fs/promises";
+import * as fs9 from "node:fs/promises";
 import * as fsSync from "node:fs";
-import * as path8 from "node:path";
-import { homedir as homedir8 } from "node:os";
+import * as path9 from "node:path";
+import { homedir as homedir9 } from "node:os";
 import { fileURLToPath } from "node:url";
 function getHookCommand(hookName2) {
   const isWindows = process.platform === "win32";
   if (isWindows) {
     const localAppData = process.env.LOCALAPPDATA;
     if (localAppData) {
-      const windowsBinaryPath = path8.join(localAppData, "ContextStream", "contextstream-mcp.exe");
+      const windowsBinaryPath = path9.join(localAppData, "ContextStream", "contextstream-mcp.exe");
       if (fsSync.existsSync(windowsBinaryPath)) {
         return `"${windowsBinaryPath}" hook ${hookName2}`;
       }
@@ -3369,8 +3676,8 @@ function getHookCommand(hookName2) {
     }
   }
   try {
-    const __dirname = path8.dirname(fileURLToPath(import.meta.url));
-    const indexPath = path8.join(__dirname, "index.js");
+    const __dirname = path9.dirname(fileURLToPath(import.meta.url));
+    const indexPath = path9.join(__dirname, "index.js");
     if (fsSync.existsSync(indexPath)) {
       return `node "${indexPath}" hook ${hookName2}`;
     }
@@ -3380,15 +3687,15 @@ function getHookCommand(hookName2) {
 }
 function getClaudeSettingsPath(scope, projectPath) {
   if (scope === "user") {
-    return path8.join(homedir8(), ".claude", "settings.json");
+    return path9.join(homedir9(), ".claude", "settings.json");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path8.join(projectPath, ".claude", "settings.json");
+  return path9.join(projectPath, ".claude", "settings.json");
 }
 function getHooksDir() {
-  return path8.join(homedir8(), ".claude", "hooks");
+  return path9.join(homedir9(), ".claude", "hooks");
 }
 function buildHooksConfig(options) {
   const userPromptHooks = [
@@ -3564,7 +3871,7 @@ function buildHooksConfig(options) {
 }
 async function installHookScripts(options) {
   const hooksDir = getHooksDir();
-  await fs8.mkdir(hooksDir, { recursive: true });
+  await fs9.mkdir(hooksDir, { recursive: true });
   const result = {
     preToolUse: getHookCommand("pre-tool-use"),
     userPrompt: getHookCommand("user-prompt-submit")
@@ -3583,7 +3890,7 @@ async function installHookScripts(options) {
 async function readClaudeSettings(scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
   try {
-    const content = await fs8.readFile(settingsPath, "utf-8");
+    const content = await fs9.readFile(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -3591,9 +3898,9 @@ async function readClaudeSettings(scope, projectPath) {
 }
 async function writeClaudeSettings(settings, scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
-  const dir = path8.dirname(settingsPath);
-  await fs8.mkdir(dir, { recursive: true });
-  await fs8.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  const dir = path9.dirname(settingsPath);
+  await fs9.mkdir(dir, { recursive: true });
+  await fs9.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 function mergeHooksIntoSettings(existingSettings, newHooks) {
   const settings = { ...existingSettings };
@@ -3743,12 +4050,12 @@ If you prefer to configure manually, add to \`~/.claude/settings.json\`:
 `.trim();
 }
 function getIndexStatusPath() {
-  return path8.join(homedir8(), ".contextstream", "indexed-projects.json");
+  return path9.join(homedir9(), ".contextstream", "indexed-projects.json");
 }
 async function readIndexStatus() {
   const statusPath = getIndexStatusPath();
   try {
-    const content = await fs8.readFile(statusPath, "utf-8");
+    const content = await fs9.readFile(statusPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, projects: {} };
@@ -3756,13 +4063,13 @@ async function readIndexStatus() {
 }
 async function writeIndexStatus(status) {
   const statusPath = getIndexStatusPath();
-  const dir = path8.dirname(statusPath);
-  await fs8.mkdir(dir, { recursive: true });
-  await fs8.writeFile(statusPath, JSON.stringify(status, null, 2));
+  const dir = path9.dirname(statusPath);
+  await fs9.mkdir(dir, { recursive: true });
+  await fs9.writeFile(statusPath, JSON.stringify(status, null, 2));
 }
 async function markProjectIndexed(projectPath, options) {
   const status = await readIndexStatus();
-  const resolvedPath = path8.resolve(projectPath);
+  const resolvedPath = path9.resolve(projectPath);
   status.projects[resolvedPath] = {
     indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_id: options?.project_id,
@@ -3772,7 +4079,7 @@ async function markProjectIndexed(projectPath, options) {
 }
 async function unmarkProjectIndexed(projectPath) {
   const status = await readIndexStatus();
-  const resolvedPath = path8.resolve(projectPath);
+  const resolvedPath = path9.resolve(projectPath);
   delete status.projects[resolvedPath];
   await writeIndexStatus(status);
 }
@@ -3785,12 +4092,12 @@ async function clearProjectIndex(projectPath, projectId) {
 }
 function getClineHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path8.join(homedir8(), "Documents", "Cline", "Rules", "Hooks");
+    return path9.join(homedir9(), "Documents", "Cline", "Rules", "Hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path8.join(projectPath, ".clinerules", "hooks");
+  return path9.join(projectPath, ".clinerules", "hooks");
 }
 function getHookWrapperScript(hookName2) {
   const isWindows = process.platform === "win32";
@@ -3814,107 +4121,107 @@ exec ${command}
 }
 async function installClineHookScripts(options) {
   const hooksDir = getClineHooksDir(options.scope, options.projectPath);
-  await fs8.mkdir(hooksDir, { recursive: true });
+  await fs9.mkdir(hooksDir, { recursive: true });
   const preToolUseWrapper = getHookWrapperScript("pre-tool-use");
   const userPromptWrapper = getHookWrapperScript("user-prompt-submit");
   const postWriteWrapper = getHookWrapperScript("post-write");
-  const preToolUsePath = path8.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path8.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path8.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs8.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs8.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
+  const preToolUsePath = path9.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
+  const userPromptPath = path9.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
+  const postToolUsePath = path9.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
+  await fs9.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
+  await fs9.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
   const result = {
     preToolUse: preToolUsePath,
     userPromptSubmit: userPromptPath
   };
   if (options.includePostWrite !== false) {
-    await fs8.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
+    await fs9.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getRooCodeHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path8.join(homedir8(), ".roo", "hooks");
+    return path9.join(homedir9(), ".roo", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path8.join(projectPath, ".roo", "hooks");
+  return path9.join(projectPath, ".roo", "hooks");
 }
 async function installRooCodeHookScripts(options) {
   const hooksDir = getRooCodeHooksDir(options.scope, options.projectPath);
-  await fs8.mkdir(hooksDir, { recursive: true });
+  await fs9.mkdir(hooksDir, { recursive: true });
   const preToolUseWrapper = getHookWrapperScript("pre-tool-use");
   const userPromptWrapper = getHookWrapperScript("user-prompt-submit");
   const postWriteWrapper = getHookWrapperScript("post-write");
-  const preToolUsePath = path8.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path8.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path8.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs8.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs8.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
+  const preToolUsePath = path9.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
+  const userPromptPath = path9.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
+  const postToolUsePath = path9.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
+  await fs9.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
+  await fs9.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
   const result = {
     preToolUse: preToolUsePath,
     userPromptSubmit: userPromptPath
   };
   if (options.includePostWrite !== false) {
-    await fs8.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
+    await fs9.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getKiloCodeHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path8.join(homedir8(), ".kilocode", "hooks");
+    return path9.join(homedir9(), ".kilocode", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path8.join(projectPath, ".kilocode", "hooks");
+  return path9.join(projectPath, ".kilocode", "hooks");
 }
 async function installKiloCodeHookScripts(options) {
   const hooksDir = getKiloCodeHooksDir(options.scope, options.projectPath);
-  await fs8.mkdir(hooksDir, { recursive: true });
+  await fs9.mkdir(hooksDir, { recursive: true });
   const preToolUseWrapper = getHookWrapperScript("pre-tool-use");
   const userPromptWrapper = getHookWrapperScript("user-prompt-submit");
   const postWriteWrapper = getHookWrapperScript("post-write");
-  const preToolUsePath = path8.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path8.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path8.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs8.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs8.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
+  const preToolUsePath = path9.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
+  const userPromptPath = path9.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
+  const postToolUsePath = path9.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
+  await fs9.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
+  await fs9.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
   const result = {
     preToolUse: preToolUsePath,
     userPromptSubmit: userPromptPath
   };
   if (options.includePostWrite !== false) {
-    await fs8.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
+    await fs9.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getCursorHooksConfigPath(scope, projectPath) {
   if (scope === "global") {
-    return path8.join(homedir8(), ".cursor", "hooks.json");
+    return path9.join(homedir9(), ".cursor", "hooks.json");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path8.join(projectPath, ".cursor", "hooks.json");
+  return path9.join(projectPath, ".cursor", "hooks.json");
 }
 function getCursorHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path8.join(homedir8(), ".cursor", "hooks");
+    return path9.join(homedir9(), ".cursor", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path8.join(projectPath, ".cursor", "hooks");
+  return path9.join(projectPath, ".cursor", "hooks");
 }
 async function readCursorHooksConfig(scope, projectPath) {
   const configPath = getCursorHooksConfigPath(scope, projectPath);
   try {
-    const content = await fs8.readFile(configPath, "utf-8");
+    const content = await fs9.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, hooks: {} };
@@ -3922,13 +4229,13 @@ async function readCursorHooksConfig(scope, projectPath) {
 }
 async function writeCursorHooksConfig(config, scope, projectPath) {
   const configPath = getCursorHooksConfigPath(scope, projectPath);
-  const dir = path8.dirname(configPath);
-  await fs8.mkdir(dir, { recursive: true });
-  await fs8.writeFile(configPath, JSON.stringify(config, null, 2));
+  const dir = path9.dirname(configPath);
+  await fs9.mkdir(dir, { recursive: true });
+  await fs9.writeFile(configPath, JSON.stringify(config, null, 2));
 }
 async function installCursorHookScripts(options) {
   const hooksDir = getCursorHooksDir(options.scope, options.projectPath);
-  await fs8.mkdir(hooksDir, { recursive: true });
+  await fs9.mkdir(hooksDir, { recursive: true });
   const existingConfig = await readCursorHooksConfig(options.scope, options.projectPath);
   const filterContextStreamHooks = (hooks2) => {
     if (!hooks2) return [];
@@ -4944,13 +5251,13 @@ var auto_rules_exports = {};
 __export(auto_rules_exports, {
   runAutoRulesHook: () => runAutoRulesHook
 });
-import * as fs9 from "node:fs";
-import * as path9 from "node:path";
-import { homedir as homedir9 } from "node:os";
+import * as fs10 from "node:fs";
+import * as path10 from "node:path";
+import { homedir as homedir10 } from "node:os";
 function hasRunRecently() {
   try {
-    if (!fs9.existsSync(MARKER_FILE)) return false;
-    const stat = fs9.statSync(MARKER_FILE);
+    if (!fs10.existsSync(MARKER_FILE)) return false;
+    const stat = fs10.statSync(MARKER_FILE);
     const age = Date.now() - stat.mtimeMs;
     return age < COOLDOWN_MS;
   } catch {
@@ -4959,11 +5266,11 @@ function hasRunRecently() {
 }
 function markAsRan() {
   try {
-    const dir = path9.dirname(MARKER_FILE);
-    if (!fs9.existsSync(dir)) {
-      fs9.mkdirSync(dir, { recursive: true });
+    const dir = path10.dirname(MARKER_FILE);
+    if (!fs10.existsSync(dir)) {
+      fs10.mkdirSync(dir, { recursive: true });
     }
-    fs9.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
+    fs10.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
 }
@@ -4992,8 +5299,8 @@ function extractCwd3(input) {
 }
 function hasPythonHooks(settingsPath) {
   try {
-    if (!fs9.existsSync(settingsPath)) return false;
-    const content = fs9.readFileSync(settingsPath, "utf-8");
+    if (!fs10.existsSync(settingsPath)) return false;
+    const content = fs10.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(content);
     const hooks2 = settings.hooks;
     if (!hooks2) return false;
@@ -5017,8 +5324,8 @@ function hasPythonHooks(settingsPath) {
   }
 }
 function detectPythonHooks(cwd) {
-  const globalSettingsPath = path9.join(homedir9(), ".claude", "settings.json");
-  const projectSettingsPath = path9.join(cwd, ".claude", "settings.json");
+  const globalSettingsPath = path10.join(homedir10(), ".claude", "settings.json");
+  const projectSettingsPath = path10.join(cwd, ".claude", "settings.json");
   return {
     global: hasPythonHooks(globalSettingsPath),
     project: hasPythonHooks(projectSettingsPath)
@@ -5083,7 +5390,7 @@ var init_auto_rules = __esm({
     API_URL5 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
     API_KEY5 = process.env.CONTEXTSTREAM_API_KEY || "";
     ENABLED7 = process.env.CONTEXTSTREAM_AUTO_RULES !== "false";
-    MARKER_FILE = path9.join(homedir9(), ".contextstream", ".auto-rules-ran");
+    MARKER_FILE = path10.join(homedir10(), ".contextstream", ".auto-rules-ran");
     COOLDOWN_MS = 4 * 60 * 60 * 1e3;
     isDirectRun7 = process.argv[1]?.includes("auto-rules") || process.argv[2] === "auto-rules";
     if (isDirectRun7) {
@@ -5097,17 +5404,17 @@ var on_bash_exports = {};
 __export(on_bash_exports, {
   runOnBashHook: () => runOnBashHook
 });
-import * as fs10 from "node:fs";
-import * as path10 from "node:path";
-import { homedir as homedir10 } from "node:os";
+import * as fs11 from "node:fs";
+import * as path11 from "node:path";
+import { homedir as homedir11 } from "node:os";
 function loadConfigFromMcpJson4(cwd) {
-  let searchDir = path10.resolve(cwd);
+  let searchDir = path11.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY6) {
-      const mcpPath = path10.join(searchDir, ".mcp.json");
-      if (fs10.existsSync(mcpPath)) {
+      const mcpPath = path11.join(searchDir, ".mcp.json");
+      if (fs11.existsSync(mcpPath)) {
         try {
-          const content = fs10.readFileSync(mcpPath, "utf-8");
+          const content = fs11.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -5121,10 +5428,10 @@ function loadConfigFromMcpJson4(cwd) {
       }
     }
     if (!WORKSPACE_ID4) {
-      const csConfigPath = path10.join(searchDir, ".contextstream", "config.json");
-      if (fs10.existsSync(csConfigPath)) {
+      const csConfigPath = path11.join(searchDir, ".contextstream", "config.json");
+      if (fs11.existsSync(csConfigPath)) {
         try {
-          const content = fs10.readFileSync(csConfigPath, "utf-8");
+          const content = fs11.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID4 = csConfig.workspace_id;
@@ -5133,15 +5440,15 @@ function loadConfigFromMcpJson4(cwd) {
         }
       }
     }
-    const parentDir = path10.dirname(searchDir);
+    const parentDir = path11.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY6) {
-    const homeMcpPath = path10.join(homedir10(), ".mcp.json");
-    if (fs10.existsSync(homeMcpPath)) {
+    const homeMcpPath = path11.join(homedir11(), ".mcp.json");
+    if (fs11.existsSync(homeMcpPath)) {
       try {
-        const content = fs10.readFileSync(homeMcpPath, "utf-8");
+        const content = fs11.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -5293,17 +5600,17 @@ var on_task_exports = {};
 __export(on_task_exports, {
   runOnTaskHook: () => runOnTaskHook
 });
-import * as fs11 from "node:fs";
-import * as path11 from "node:path";
-import { homedir as homedir11 } from "node:os";
+import * as fs12 from "node:fs";
+import * as path12 from "node:path";
+import { homedir as homedir12 } from "node:os";
 function loadConfigFromMcpJson5(cwd) {
-  let searchDir = path11.resolve(cwd);
+  let searchDir = path12.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY7) {
-      const mcpPath = path11.join(searchDir, ".mcp.json");
-      if (fs11.existsSync(mcpPath)) {
+      const mcpPath = path12.join(searchDir, ".mcp.json");
+      if (fs12.existsSync(mcpPath)) {
         try {
-          const content = fs11.readFileSync(mcpPath, "utf-8");
+          const content = fs12.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -5317,10 +5624,10 @@ function loadConfigFromMcpJson5(cwd) {
       }
     }
     if (!WORKSPACE_ID5) {
-      const csConfigPath = path11.join(searchDir, ".contextstream", "config.json");
-      if (fs11.existsSync(csConfigPath)) {
+      const csConfigPath = path12.join(searchDir, ".contextstream", "config.json");
+      if (fs12.existsSync(csConfigPath)) {
         try {
-          const content = fs11.readFileSync(csConfigPath, "utf-8");
+          const content = fs12.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID5 = csConfig.workspace_id;
@@ -5329,15 +5636,15 @@ function loadConfigFromMcpJson5(cwd) {
         }
       }
     }
-    const parentDir = path11.dirname(searchDir);
+    const parentDir = path12.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY7) {
-    const homeMcpPath = path11.join(homedir11(), ".mcp.json");
-    if (fs11.existsSync(homeMcpPath)) {
+    const homeMcpPath = path12.join(homedir12(), ".mcp.json");
+    if (fs12.existsSync(homeMcpPath)) {
       try {
-        const content = fs11.readFileSync(homeMcpPath, "utf-8");
+        const content = fs12.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -5438,17 +5745,17 @@ var on_read_exports = {};
 __export(on_read_exports, {
   runOnReadHook: () => runOnReadHook
 });
-import * as fs12 from "node:fs";
-import * as path12 from "node:path";
-import { homedir as homedir12 } from "node:os";
+import * as fs13 from "node:fs";
+import * as path13 from "node:path";
+import { homedir as homedir13 } from "node:os";
 function loadConfigFromMcpJson6(cwd) {
-  let searchDir = path12.resolve(cwd);
+  let searchDir = path13.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY8) {
-      const mcpPath = path12.join(searchDir, ".mcp.json");
-      if (fs12.existsSync(mcpPath)) {
+      const mcpPath = path13.join(searchDir, ".mcp.json");
+      if (fs13.existsSync(mcpPath)) {
         try {
-          const content = fs12.readFileSync(mcpPath, "utf-8");
+          const content = fs13.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -5462,10 +5769,10 @@ function loadConfigFromMcpJson6(cwd) {
       }
     }
     if (!WORKSPACE_ID6) {
-      const csConfigPath = path12.join(searchDir, ".contextstream", "config.json");
-      if (fs12.existsSync(csConfigPath)) {
+      const csConfigPath = path13.join(searchDir, ".contextstream", "config.json");
+      if (fs13.existsSync(csConfigPath)) {
         try {
-          const content = fs12.readFileSync(csConfigPath, "utf-8");
+          const content = fs13.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID6 = csConfig.workspace_id;
@@ -5474,15 +5781,15 @@ function loadConfigFromMcpJson6(cwd) {
         }
       }
     }
-    const parentDir = path12.dirname(searchDir);
+    const parentDir = path13.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY8) {
-    const homeMcpPath = path12.join(homedir12(), ".mcp.json");
-    if (fs12.existsSync(homeMcpPath)) {
+    const homeMcpPath = path13.join(homedir13(), ".mcp.json");
+    if (fs13.existsSync(homeMcpPath)) {
       try {
-        const content = fs12.readFileSync(homeMcpPath, "utf-8");
+        const content = fs13.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -5607,17 +5914,17 @@ var on_web_exports = {};
 __export(on_web_exports, {
   runOnWebHook: () => runOnWebHook
 });
-import * as fs13 from "node:fs";
-import * as path13 from "node:path";
-import { homedir as homedir13 } from "node:os";
+import * as fs14 from "node:fs";
+import * as path14 from "node:path";
+import { homedir as homedir14 } from "node:os";
 function loadConfigFromMcpJson7(cwd) {
-  let searchDir = path13.resolve(cwd);
+  let searchDir = path14.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY9) {
-      const mcpPath = path13.join(searchDir, ".mcp.json");
-      if (fs13.existsSync(mcpPath)) {
+      const mcpPath = path14.join(searchDir, ".mcp.json");
+      if (fs14.existsSync(mcpPath)) {
         try {
-          const content = fs13.readFileSync(mcpPath, "utf-8");
+          const content = fs14.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -5631,10 +5938,10 @@ function loadConfigFromMcpJson7(cwd) {
       }
     }
     if (!WORKSPACE_ID7) {
-      const csConfigPath = path13.join(searchDir, ".contextstream", "config.json");
-      if (fs13.existsSync(csConfigPath)) {
+      const csConfigPath = path14.join(searchDir, ".contextstream", "config.json");
+      if (fs14.existsSync(csConfigPath)) {
         try {
-          const content = fs13.readFileSync(csConfigPath, "utf-8");
+          const content = fs14.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID7 = csConfig.workspace_id;
@@ -5643,15 +5950,15 @@ function loadConfigFromMcpJson7(cwd) {
         }
       }
     }
-    const parentDir = path13.dirname(searchDir);
+    const parentDir = path14.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY9) {
-    const homeMcpPath = path13.join(homedir13(), ".mcp.json");
-    if (fs13.existsSync(homeMcpPath)) {
+    const homeMcpPath = path14.join(homedir14(), ".mcp.json");
+    if (fs14.existsSync(homeMcpPath)) {
       try {
-        const content = fs13.readFileSync(homeMcpPath, "utf-8");
+        const content = fs14.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -5844,7 +6151,7 @@ var init_rules_templates = __esm({
 | Message | Required |
 |---------|----------|
 | **1st message** | \`init()\` \u2192 \`context(user_message="...")\` |
-| **Every message** | \`context(user_message="...")\` FIRST |
+| **Subsequent messages (default)** | \`context(user_message="...")\` FIRST (narrow read-only bypass when context is fresh and no state-changing tool has run) |
 | **Before file search** | \`search(mode="auto")\` BEFORE Glob/Grep/Read |
 </contextstream_rules>
@@ -5858,27 +6165,25 @@ v${RULES_VERSION}
 `.trim();
     CONTEXTSTREAM_RULES_DYNAMIC = CONTEXTSTREAM_RULES_BOOTSTRAP;
     CONTEXTSTREAM_RULES_FULL = `
-## \u{1F6A8} MANDATORY: CALL CONTEXT EVERY MESSAGE \u{1F6A8}
+## \u{1F6A8} MANDATORY STARTUP: CONTEXT-FIRST FLOW \u{1F6A8}
 <contextstream_rules>
-**EVERY response MUST start with \`context(user_message="...")\`**
 | Message | What to Call |
 |---------|--------------|
-| 1st message | \`init()\` \u2192 \`context(user_message="<msg>")\` |
-| **EVERY message after** | \`context(user_message="<msg>")\` **FIRST** |
-**BEFORE Glob/Grep/Read/Search:** \u2192 \`search(mode="auto")\` FIRST
+| **First message in session** | \`init()\` \u2192 \`context(user_message="<msg>")\` BEFORE any other tool |
+| **Subsequent messages (default)** | \`context(user_message="<msg>")\` FIRST, then other tools |
+| **Narrow bypass** | Immediate read-only ContextStream calls are allowed only when prior context is fresh and no state-changing tool has run |
+| **Before Glob/Grep/Read/Search** | \`search(mode="auto", query="...")\` FIRST |
 </contextstream_rules>
-**This block MUST appear at the start of EVERY response.** Failing to call \`context()\` means missing rules, lessons, and relevant context.
+Use \`context()\` by default to get task-specific rules, lessons from past mistakes, and relevant decisions.
 ---
-## Why \`context()\` is MANDATORY Every Message
+## Why Default Context-First
-\u274C **WRONG:** "I already called init, I don't need context"
-\u2705 **CORRECT:** \`context()\` is required EVERY message, not just the first
+\u274C **Wrong:** "I already called init, so I can skip context for everything"
+\u2705 **Correct:** \`context()\` is the default first call for subsequent messages, with a narrow read-only bypass when context is still fresh and state is unchanged
 **What you lose without \`context()\`:**
 - Dynamic rules matched to your current task
@@ -5886,7 +6191,7 @@ v${RULES_VERSION}
 - Semantically relevant decisions and context
 - Warnings about risky operations
-**\`init()\` gives recent items by TIME. \`context()\` finds items RELEVANT to THIS message.**
+**\`init()\` returns recent items by time. \`context()\` finds items semantically relevant to this message.**
 ---
@@ -6392,9 +6697,10 @@ See full documentation: https://contextstream.io/docs/mcp/tools
 ## \u{1F6A8} CRITICAL: These Rules Are Non-Negotiable \u{1F6A8}
 <contextstream_protocol>
-**EVERY coding response MUST start with:**
-1. \`init()\` (1st message only) \u2192 then \`context(user_message="<msg>")\`
-2. \`context(user_message="<msg>")\` (EVERY subsequent message)
+**MANDATORY STARTUP:**
+1. First message in session: \`init()\` \u2192 then \`context(user_message="<msg>")\`
+2. Subsequent messages (default): \`context(user_message="<msg>")\` FIRST
+3. Narrow bypass: immediate read-only ContextStream calls are allowed only when prior context is fresh and no state-changing tool has run
 **BEFORE Glob/Grep/Read/Search/Explore:**
 \u2192 \`search(mode="auto", query="...")\` FIRST \u2014 local tools ONLY if 0 results
@@ -6424,8 +6730,9 @@ Rules Version: ${RULES_VERSION}
 | When | Call |
 |------|------|
-| 1st message | \`init()\` \u2192 \`context(user_message="...")\` |
-| Every message after | \`context(user_message="...")\` |
+| 1st message in session | \`init()\` \u2192 \`context(user_message="...")\` |
+| Subsequent messages (default) | \`context(user_message="...")\` first |
+| Narrow bypass | Immediate read-only ContextStream calls when context is fresh and no state-changing tool has run |
 | Before ANY file discovery | \`search(mode="auto", query="...")\` |
 | On \`<system-reminder>\` | **Follow instructions inside** |
 | Save important decisions | \`session(action="capture", event_type="decision", ...)\` |
@@ -6448,12 +6755,10 @@ Rules Version: ${RULES_VERSION}
 - **[RULES_NOTICE]** \u2192 Run \`generate_rules()\`
 - **[VERSION_NOTICE]** \u2192 Tell user to update MCP
-## Fast Path (Simple Utilities Only)
-Skip init/context ONLY for: "list workspaces", "show version", "list reminders"
-\u2192 Just call: \`workspace(action="list")\`, \`help(action="version")\`, etc.
+## Read-Only Examples
-Everything else = full protocol (init \u2192 context \u2192 search \u2192 work)
+Default behavior is context-first. Narrow bypass applies only for immediate read-only ContextStream calls when context is fresh and state is unchanged.
+Examples: \`workspace(action="list"|"get")\`, \`help(action="version"|"tools"|"auth")\`, \`project(action="index_status")\`.
 ### Lessons (Past Mistakes)
@@ -6542,7 +6847,7 @@ You MUST follow these rules manually - there is no automatic enforcement.
    - Check for [RULES_NOTICE] - update rules if needed
    - **save_exchange=true** saves each conversation turn for later retrieval
-4. **NEVER skip init/context** - you will miss critical context
+4. **Default behavior:** call \`context(...)\` first on each message. Narrow bypass is allowed only for immediate read-only ContextStream calls when previous context is still fresh and no state-changing tool has run.
 ---
@@ -6551,7 +6856,7 @@ You MUST follow these rules manually - there is no automatic enforcement.
 **This editor does NOT have hooks to auto-save transcripts.**
 You MUST save each conversation turn manually:
-### On EVERY message (including the first):
+### On MOST messages (including the first):
 \`\`\`
 context(user_message="<user's message>", save_exchange=true, session_id="<session-id>")
 \`\`\`
@@ -6626,6 +6931,28 @@ search(mode="auto", query="what you're looking for")
 **IF ContextStream search returns 0 results or errors:**
 \u2192 Use local tools (Glob/Grep/Read) as fallback
+### Choose Search Mode Intelligently:
+- \`auto\` (recommended): query-aware mode selection
+- \`hybrid\`: mixed semantic + keyword retrieval for broad discovery
+- \`semantic\`: conceptual questions ("how does X work?")
+- \`keyword\`: exact text / quoted string
+- \`pattern\`: glob or regex (\`*.ts\`, \`foo\\s+bar\`)
+- \`refactor\`: symbol usage / rename-safe lookup
+- \`exhaustive\`: all occurrences / complete match coverage
+- \`team\`: cross-project team search
+### Output Format Hints:
+- Use \`output_format="paths"\` for file listings and rename targets
+- Use \`output_format="count"\` for "how many" queries
+### Two-Phase Search Pattern (for precision):
+- Pass 1 (discovery): \`search(mode="auto", query="<concept + module>", output_format="paths", limit=10)\`
+- Pass 2 (precision): use one of:
+  - exact text/symbol: \`search(mode="keyword", query="\\"exact_text\\"", include_content=true)\`
+  - symbol usage: \`search(mode="refactor", query="SymbolName", output_format="paths")\`
+  - all occurrences: \`search(mode="exhaustive", query="symbol_or_text")\`
+- Then use local Read/Grep only on paths returned by ContextStream.
 ### When Local Tools Are OK:
 \u2705 Project is not indexed
 \u2705 Index is stale/outdated (>7 days old)
@@ -6782,17 +7109,17 @@ var session_init_exports = {};
 __export(session_init_exports, {
   runSessionInitHook: () => runSessionInitHook
 });
-import * as fs14 from "node:fs";
-import * as path14 from "node:path";
-import { homedir as homedir14 } from "node:os";
+import * as fs15 from "node:fs";
+import * as path15 from "node:path";
+import { homedir as homedir15 } from "node:os";
 function loadConfigFromMcpJson8(cwd) {
-  let searchDir = path14.resolve(cwd);
+  let searchDir = path15.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY10) {
-      const mcpPath = path14.join(searchDir, ".mcp.json");
-      if (fs14.existsSync(mcpPath)) {
+      const mcpPath = path15.join(searchDir, ".mcp.json");
+      if (fs15.existsSync(mcpPath)) {
         try {
-          const content = fs14.readFileSync(mcpPath, "utf-8");
+          const content = fs15.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -6809,10 +7136,10 @@ function loadConfigFromMcpJson8(cwd) {
       }
     }
     if (!WORKSPACE_ID8 || !PROJECT_ID2) {
-      const csConfigPath = path14.join(searchDir, ".contextstream", "config.json");
-      if (fs14.existsSync(csConfigPath)) {
+      const csConfigPath = path15.join(searchDir, ".contextstream", "config.json");
+      if (fs15.existsSync(csConfigPath)) {
         try {
-          const content = fs14.readFileSync(csConfigPath, "utf-8");
+          const content = fs15.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id && !WORKSPACE_ID8) {
             WORKSPACE_ID8 = csConfig.workspace_id;
@@ -6824,15 +7151,15 @@ function loadConfigFromMcpJson8(cwd) {
         }
       }
     }
-    const parentDir = path14.dirname(searchDir);
+    const parentDir = path15.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY10) {
-    const homeMcpPath = path14.join(homedir14(), ".mcp.json");
-    if (fs14.existsSync(homeMcpPath)) {
+    const homeMcpPath = path15.join(homedir15(), ".mcp.json");
+    if (fs15.existsSync(homeMcpPath)) {
       try {
-        const content = fs14.readFileSync(homeMcpPath, "utf-8");
+        const content = fs15.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -6910,7 +7237,9 @@ function formatContext(ctx, options = {}) {
     }
   }
   if (!ctx) {
-    parts.push('\nNo stored context found. Call `mcp__contextstream__context(user_message="starting new session")` to initialize.');
+    parts.push(
+      '\nNo saved context found yet. On the first message in this session call `mcp__contextstream__init(...)` then `mcp__contextstream__context(user_message="starting new session")`.'
+    );
     return parts.join("\n");
   }
   if (ctx.lessons && ctx.lessons.length > 0) {
@@ -6938,7 +7267,9 @@ function formatContext(ctx, options = {}) {
     }
   }
   parts.push("\n---");
-  parts.push('Call `mcp__contextstream__context(user_message="...")` for task-specific context.');
+  parts.push(
+    'On the first message in a new session call `mcp__contextstream__init(...)` then `mcp__contextstream__context(user_message="...")`. After that, call `mcp__contextstream__context(user_message="...")` on every message.'
+  );
   return parts.join("\n");
 }
 function regenerateRuleFiles(folderPath) {
@@ -6947,10 +7278,10 @@ function regenerateRuleFiles(folderPath) {
   for (const editor of editors) {
     const rule = generateRuleContent(editor, { mode: "bootstrap" });
     if (!rule) continue;
-    const filePath = path14.join(folderPath, rule.filename);
-    if (!fs14.existsSync(filePath)) continue;
+    const filePath = path15.join(folderPath, rule.filename);
+    if (!fs15.existsSync(filePath)) continue;
     try {
-      const existing = fs14.readFileSync(filePath, "utf8");
+      const existing = fs15.readFileSync(filePath, "utf8");
       const startIdx = existing.indexOf(CONTEXTSTREAM_START_MARKER);
       const endIdx = existing.indexOf(CONTEXTSTREAM_END_MARKER);
       if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) continue;
@@ -6960,7 +7291,7 @@ function regenerateRuleFiles(folderPath) {
 ${rule.content.trim()}
 ${CONTEXTSTREAM_END_MARKER}`;
       const merged = [before, newBlock, after].filter((p) => p.length > 0).join("\n\n");
-      fs14.writeFileSync(filePath, merged.trim() + "\n", "utf8");
+      fs15.writeFileSync(filePath, merged.trim() + "\n", "utf8");
       updated++;
     } catch {
     }
@@ -6985,6 +7316,8 @@ async function runSessionInitHook() {
     process.exit(0);
   }
   const cwd = input.cwd || process.cwd();
+  cleanupStale(360);
+  markInitRequired(cwd);
   loadConfigFromMcpJson8(cwd);
   const updateMarker = checkUpdateMarker();
   if (updateMarker) {
@@ -7018,6 +7351,7 @@ var init_session_init = __esm({
     "use strict";
     init_version();
     init_rules_templates();
+    init_prompt_state();
     ENABLED12 = process.env.CONTEXTSTREAM_SESSION_INIT_ENABLED !== "false";
     API_URL10 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
     API_KEY10 = process.env.CONTEXTSTREAM_API_KEY || "";
@@ -7037,17 +7371,17 @@ var session_end_exports = {};
 __export(session_end_exports, {
   runSessionEndHook: () => runSessionEndHook
 });
-import * as fs15 from "node:fs";
-import * as path15 from "node:path";
-import { homedir as homedir15 } from "node:os";
+import * as fs16 from "node:fs";
+import * as path16 from "node:path";
+import { homedir as homedir16 } from "node:os";
 function loadConfigFromMcpJson9(cwd) {
-  let searchDir = path15.resolve(cwd);
+  let searchDir = path16.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY11) {
-      const mcpPath = path15.join(searchDir, ".mcp.json");
-      if (fs15.existsSync(mcpPath)) {
+      const mcpPath = path16.join(searchDir, ".mcp.json");
+      if (fs16.existsSync(mcpPath)) {
         try {
-          const content = fs15.readFileSync(mcpPath, "utf-8");
+          const content = fs16.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -7061,10 +7395,10 @@ function loadConfigFromMcpJson9(cwd) {
       }
     }
     if (!WORKSPACE_ID9 || !PROJECT_ID3) {
-      const csConfigPath = path15.join(searchDir, ".contextstream", "config.json");
-      if (fs15.existsSync(csConfigPath)) {
+      const csConfigPath = path16.join(searchDir, ".contextstream", "config.json");
+      if (fs16.existsSync(csConfigPath)) {
         try {
-          const content = fs15.readFileSync(csConfigPath, "utf-8");
+          const content = fs16.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id && !WORKSPACE_ID9) {
             WORKSPACE_ID9 = csConfig.workspace_id;
@@ -7076,15 +7410,15 @@ function loadConfigFromMcpJson9(cwd) {
         }
       }
     }
-    const parentDir = path15.dirname(searchDir);
+    const parentDir = path16.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY11) {
-    const homeMcpPath = path15.join(homedir15(), ".mcp.json");
-    if (fs15.existsSync(homeMcpPath)) {
+    const homeMcpPath = path16.join(homedir16(), ".mcp.json");
+    if (fs16.existsSync(homeMcpPath)) {
       try {
-        const content = fs15.readFileSync(homeMcpPath, "utf-8");
+        const content = fs16.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -7107,11 +7441,11 @@ function parseTranscriptStats(transcriptPath) {
     messages: [],
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (!transcriptPath || !fs15.existsSync(transcriptPath)) {
+  if (!transcriptPath || !fs16.existsSync(transcriptPath)) {
     return stats;
   }
   try {
-    const content = fs15.readFileSync(transcriptPath, "utf-8");
+    const content = fs16.readFileSync(transcriptPath, "utf-8");
     const lines = content.split("\n");
     let firstTimestamp = null;
     let lastTimestamp = null;