@contextstream/mcp-server 0.4.67 → 0.4.71

package/README.md

@@ -24,7 +24,7 @@
 <div align="center">
 
 ```bash
-npx @contextstream/mcp-server@latest setup
+npx --prefer-online -y @contextstream/mcp-server@latest setup
 ```
 
 </div>
@@ -35,6 +35,36 @@ npx @contextstream/mcp-server@latest setup
 
 ---
 
+## Get Started (VS Code + Copilot)
+
+### Option 1: Rust MCP (recommended)
+
+```bash
+curl -fsSL https://contextstream.io/scripts/mcp.sh | bash
+```
+
+```powershell
+irm https://contextstream.io/scripts/mcp.ps1 | iex
+```
+
+Then run:
+
+```bash
+contextstream-mcp setup
+```
+
+### Option 2: Node MCP
+
+```bash
+npx --prefer-online -y @contextstream/mcp-server@latest setup
+```
+
+After setup, restart VS Code/Copilot.
+
+**Works with:** Claude Code • Cursor • VS Code • Claude Desktop • Codex CLI • OpenCode • Antigravity
+
+---
+
 ## This Isn't Just Memory. This Is Intelligence.
 
 Other tools give your AI a notepad. **ContextStream gives it a brain.**
@@ -76,56 +106,6 @@ Long conversation? ContextStream tracks token usage, auto-saves critical state,
 
 ---
 
-## Choose Your Runtime (VS Code/Copilot)
-
-For VS Code + Copilot users, we recommend the Rust runtime because it gives the lowest-friction local install and startup path.
-
-### Recommended: Rust MCP
-
-```bash
-curl -fsSL https://contextstream.io/scripts/mcp.sh | bash
-```
-
-```powershell
-irm https://contextstream.io/scripts/mcp.ps1 | iex
-```
-
-### Alternative: Node MCP server
-
-```bash
-npx --prefer-online -y @contextstream/mcp-server@latest setup
-```
-
-### Marketplace install limitation
-
-MCP marketplace installs for npm packages can install and run the package entrypoint, but they do not run arbitrary shell bootstrap commands such as `curl ... | bash` or `irm ... | iex`. That means Rust bootstrap must currently be a separate explicit user step unless/ until the Rust runtime is distributed in a marketplace-compatible package format.
-
-## Quickest Post-Install Path (VS Code + Copilot)
-
-1. Install a runtime (Rust recommended).
-2. Run the setup wizard:
-
-```bash
-contextstream-mcp setup
-```
-
-3. In wizard prompts, keep Copilot selected and confirm canonical file writes.
-4. Restart VS Code/Copilot.
-
-This path is the default recommendation. Manual JSON config snippets below are backup options.
-
-## Setup Takes 30 Seconds (Node)
-
-```bash
-npx --prefer-online -y @contextstream/mcp-server@latest setup
-```
-
-The wizard handles authentication, configuration, editor integration, and optional hooks that supercharge your workflow.
-
-**Works with:** Claude Code • Cursor • VS Code • Claude Desktop • Codex CLI • OpenCode • Antigravity
-
----
-
 ## The Tools Your AI Gets
 
 ```
@@ -144,6 +124,18 @@ Your AI uses these automatically. You just code.
 
 ---
 
+## Global Fallback Workspace (Unmapped Folders)
+
+ContextStream now supports a catch-all mode for random folders (for example `~` or ad-hoc dirs) that are not associated with a project/workspace yet.
+
+- `init(...)` resolves normal folder mappings first (`.contextstream/config.json`, parent/global mappings).
+- If no mapping exists, it uses a single hidden global fallback workspace (`.contextstream-global`) in workspace-only mode.
+- Context/memory/session tools continue to work without hard setup errors.
+- Project-bound actions (for example `project(action="ingest_local")`) return guided remediation to create/select a project instead of failing with a raw `project_id required` error.
+- As soon as you enter a mapped project folder, that real workspace/project is prioritized and replaces fallback scope.
+
+---
+
 ## Manual Configuration
 
 > Skip this if you ran the setup wizard.
@@ -152,8 +144,8 @@ Your AI uses these automatically. You just code.
 <summary><b>Claude Code</b></summary>
 
 ```bash
-claude mcp add contextstream -- npx @contextstream/mcp-server
-claude mcp update contextstream -e CONTEXTSTREAM_API_KEY=your_key
+claude mcp add contextstream -- npx --prefer-online -y @contextstream/mcp-server@latest
+claude mcp update contextstream -e CONTEXTSTREAM_API_URL=https://api.contextstream.io -e CONTEXTSTREAM_API_KEY=your_key
 ```
 
 </details>
@@ -166,8 +158,11 @@ claude mcp update contextstream -e CONTEXTSTREAM_API_KEY=your_key
   "mcpServers": {
     "contextstream": {
       "command": "npx",
-      "args": ["-y", "@contextstream/mcp-server"],
-      "env": { "CONTEXTSTREAM_API_KEY": "your_key" }
+      "args": ["--prefer-online", "-y", "@contextstream/mcp-server@latest"],
+      "env": {
+        "CONTEXTSTREAM_API_URL": "https://api.contextstream.io",
+        "CONTEXTSTREAM_API_KEY": "your_key"
+      }
     }
   }
 }
@@ -222,7 +217,26 @@ For the local variant, export `CONTEXTSTREAM_API_KEY` before launching OpenCode.
 <details>
 <summary><b>VS Code</b></summary>
 
-For GitHub Copilot in VS Code, use project-level MCP at `.vscode/mcp.json`.
+For GitHub Copilot in VS Code, the easiest path is the hosted remote MCP with built-in OAuth. Marketplace installs should write this remote server definition automatically.
+
+**Hosted remote MCP (recommended)**
+
+```json
+{
+  "servers": {
+    "contextstream": {
+      "type": "http",
+      "url": "https://mcp.contextstream.io/mcp?default_context_mode=fast"
+    }
+  }
+}
+```
+
+On first use, VS Code should prompt you to authorize ContextStream in the browser and then complete setup without an API key in the config file.
+
+`npx @contextstream/mcp-server@latest setup` now defaults VS Code/Copilot to this hosted remote when you are using the production ContextStream cloud. To force a local runtime instead, run setup with `CONTEXTSTREAM_VSCODE_MCP_MODE=local`.
+
+For self-hosted or non-default API deployments, local runtime remains the default:
 
 **Rust MCP (recommended)**
 
@@ -233,7 +247,15 @@ For GitHub Copilot in VS Code, use project-level MCP at `.vscode/mcp.json`.
       "type": "stdio",
       "command": "contextstream-mcp",
       "args": [],
-      "env": { "CONTEXTSTREAM_API_KEY": "your_key" }
+      "env": {
+        "CONTEXTSTREAM_API_URL": "https://api.contextstream.io",
+        "CONTEXTSTREAM_API_KEY": "your_key",
+        "CONTEXTSTREAM_TOOLSET": "complete",
+        "CONTEXTSTREAM_TRANSCRIPTS_ENABLED": "true",
+        "CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED": "true",
+        "CONTEXTSTREAM_SEARCH_LIMIT": "15",
+        "CONTEXTSTREAM_SEARCH_MAX_CHARS": "2400"
+      }
     }
   }
 }
@@ -247,8 +269,16 @@ For GitHub Copilot in VS Code, use project-level MCP at `.vscode/mcp.json`.
     "contextstream": {
       "type": "stdio",
       "command": "npx",
-      "args": ["-y", "@contextstream/mcp-server"],
-      "env": { "CONTEXTSTREAM_API_KEY": "your_key" }
+      "args": ["--prefer-online", "-y", "@contextstream/mcp-server@latest"],
+      "env": {
+        "CONTEXTSTREAM_API_URL": "https://api.contextstream.io",
+        "CONTEXTSTREAM_API_KEY": "your_key",
+        "CONTEXTSTREAM_TOOLSET": "complete",
+        "CONTEXTSTREAM_TRANSCRIPTS_ENABLED": "true",
+        "CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED": "true",
+        "CONTEXTSTREAM_SEARCH_LIMIT": "15",
+        "CONTEXTSTREAM_SEARCH_MAX_CHARS": "2400"
+      }
     }
   }
 }
@@ -275,7 +305,15 @@ Or add to `~/.copilot/mcp-config.json` (pick one runtime):
     "contextstream": {
       "command": "contextstream-mcp",
       "args": [],
-      "env": { "CONTEXTSTREAM_API_KEY": "your_key" }
+      "env": {
+        "CONTEXTSTREAM_API_URL": "https://api.contextstream.io",
+        "CONTEXTSTREAM_API_KEY": "your_key",
+        "CONTEXTSTREAM_TOOLSET": "complete",
+        "CONTEXTSTREAM_TRANSCRIPTS_ENABLED": "true",
+        "CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED": "true",
+        "CONTEXTSTREAM_SEARCH_LIMIT": "15",
+        "CONTEXTSTREAM_SEARCH_MAX_CHARS": "2400"
+      }
     }
   }
 }
@@ -288,8 +326,16 @@ Or add to `~/.copilot/mcp-config.json` (pick one runtime):
   "mcpServers": {
     "contextstream": {
       "command": "npx",
-      "args": ["-y", "@contextstream/mcp-server"],
-      "env": { "CONTEXTSTREAM_API_KEY": "your_key" }
+      "args": ["--prefer-online", "-y", "@contextstream/mcp-server@latest"],
+      "env": {
+        "CONTEXTSTREAM_API_URL": "https://api.contextstream.io",
+        "CONTEXTSTREAM_API_KEY": "your_key",
+        "CONTEXTSTREAM_TOOLSET": "complete",
+        "CONTEXTSTREAM_TRANSCRIPTS_ENABLED": "true",
+        "CONTEXTSTREAM_HOOK_TRANSCRIPTS_ENABLED": "true",
+        "CONTEXTSTREAM_SEARCH_LIMIT": "15",
+        "CONTEXTSTREAM_SEARCH_MAX_CHARS": "2400"
+      }
     }
   }
 }
@@ -301,83 +347,54 @@ For more information, see the [GitHub Copilot CLI documentation](https://docs.gi
 
 ---
 
-## VS Code + Copilot Canonical Setup
-
-Select Copilot in setup; setup handles both configs automatically.
-
-For the most reliable Copilot behavior with ContextStream, configure all three artifacts:
-
-1. **Global Copilot CLI MCP config**: `~/.copilot/mcp-config.json`
-2. **Project VS Code MCP config**: `.vscode/mcp.json`
-3. **Project rules and skill files**:
-   - `.github/copilot-instructions.md`
-   - `.github/skills/contextstream-workflow/SKILL.md`
-
-This gives you MCP connectivity plus explicit no-hooks workflow guidance for Copilot sessions.
-
-If you installed Rust MCP, use `contextstream-mcp` as the command in both MCP files. If you installed via npm/marketplace, use `npx --prefer-online -y @contextstream/mcp-server@latest`.
-
-## Troubleshooting (Why Copilot/VS Code "isn't working")
-
-- **Wrong config location**: verify both `~/.copilot/mcp-config.json` and `.vscode/mcp.json` for project-specific VS Code usage.
-- **Malformed JSON**: remove comments/trailing commas in MCP JSON files.
-- **Stale config shape**: ensure root keys are correct (`mcpServers` for Copilot CLI, `servers` for VS Code).
-- **Rules missing**: ensure `.github/copilot-instructions.md` and the companion `SKILL.md` exist.
-- **Context discipline not followed**: first turn must call `init(...)` then `context(...)`; subsequent turns should call `context(...)` first.
-- **Indexing not ready**: after setup, allow indexing to complete; retry `search(mode="auto", ...)` before falling back to local scans.
-
-## Migration Notes
-
-- If you previously configured only one path, migrate to the canonical setup above.
-- If migrating from Node to Rust MCP, update both command fields (`~/.copilot/mcp-config.json` and `.vscode/mcp.json`) from `npx ... @contextstream/mcp-server@latest` to `contextstream-mcp`.
-- If older rules exist, regenerate rules and replace stale instructions with the current Copilot files.
-- Preserve other MCP servers in your JSON files; only update the `contextstream` entry.
-
-## Marketplace + Rust MCP Feasibility
-
-- Current `server.json` marketplace metadata for this package points to npm install, which is why one-click install resolves to Node MCP.
-- Marketplace clients do not execute external bootstrap scripts during package install, so they cannot trigger Rust install commands directly.
-- Once Rust MCP is published in a marketplace-supported package form (for example an additional registry package entry), `server.json` can expose both Node and Rust install targets for true one-click runtime choice.
-
-## Hook Coverage Matrix (Claude, Cursor, Antigravity)
-
-| Editor | Hook support | ContextStream strategy |
-|--------|--------------|------------------------|
-| Claude Code | Full lifecycle hooks | Hard enforcement + reminders + lifecycle persistence hooks |
-| Cursor | Lifecycle hooks (tool/MCP/shell/file/session) | Hard enforcement + reminder hooks + post-action indexing hooks |
-| Windsurf | Cascade hooks (pre/post tool and response events) | Hard enforcement via pre hooks + post-write/session hooks |
-| Antigravity | No documented lifecycle hooks | Strict rules-first flow + no-hooks operational guardrails |
-
-## Troubleshooting (ContextStream was skipped)
-
-- **Claude Code**
-  - Confirm hooks exist in `~/.claude/settings.json` or project `.claude/settings.json`.
-  - Verify ContextStream hook commands are present for `PreToolUse`, `UserPromptSubmit`, `SessionStart`, and `PreCompact`.
-  - Check `CONTEXTSTREAM_HOOK_ENABLED` is not set to `false`.
-- **Cursor**
-  - Confirm `.cursor/hooks.json` includes `preToolUse` and `beforeSubmitPrompt`.
-  - Verify `beforeMCPExecution` / `beforeShellExecution` / `beforeReadFile` hook entries exist after setup.
-  - If hooks are stale, rerun setup to regenerate ContextStream entries without deleting user hooks.
-- **Antigravity**
-  - Verify `~/.gemini/antigravity/mcp_config.json` has a healthy `contextstream` server block.
-  - Since hooks are unavailable, enforce manual discipline: `init(...)` then `context(...)`, and `search(mode="auto", ...)` before local scans.
-  - Re-index when search appears stale and retry ContextStream search before fallback.
-- **Windsurf**
-  - Confirm `~/.codeium/windsurf/mcp_config.json` includes `contextstream`.
-  - Confirm hooks in `~/.codeium/windsurf/hooks.json` include `pre_mcp_tool_use` and `pre_user_prompt`.
-  - If behavior is stale, rerun setup to regenerate ContextStream hook entries while preserving user hooks.
-- **All editors**
-  - Validate JSON shape (`mcpServers` vs `servers`) and remove trailing commas/comments.
-  - Keep first-call protocol strict: first turn `init(...)` then `context(...)`.
-  - Preserve non-ContextStream entries when regenerating configs.
-
-## Rust/Node Parity Checklist
-
-- Claude hook matrix includes current lifecycle events in both Rust and Node setup flows.
-- Cursor hook matrix includes tool/MCP/shell/file/session enforcement hooks in both implementations.
-- Windsurf hook matrix includes pre/post Cascade hook coverage in both implementations.
-- Antigravity remains explicit no-hooks with strengthened rules guidance in both implementations.
-- Hook/rules installers stay idempotent and avoid deleting non-ContextStream user entries.
+## VS Code + Copilot Tips
+
+- Run setup once and keep both config files:
+  - `~/.copilot/mcp-config.json`
+  - `.vscode/mcp.json`
+- Rust install: use `contextstream-mcp` as the command.
+- Node install: use `npx --prefer-online -y @contextstream/mcp-server@latest` as the command.
+- Force local VS Code/Copilot setup with `CONTEXTSTREAM_VSCODE_MCP_MODE=local`.
+- Force hosted remote VS Code/Copilot setup with `CONTEXTSTREAM_VSCODE_MCP_MODE=remote`.
+- Use `mcpServers` in Copilot CLI config and `servers` in VS Code config.
+
+## Quick Troubleshooting
+
+- Remove duplicate ContextStream entries across Workspace/User config scopes.
+- Check `CONTEXTSTREAM_API_URL` and `CONTEXTSTREAM_API_KEY` are set.
+- Remove stale version pins like `@contextstream/mcp-server@0.3.xx`.
+- Restart VS Code/Copilot after config changes.
+
+## Known Limitations
+
+### HTTP transport OAuth and vscode.dev dependency
+
+The hosted HTTP MCP transport (`https://mcp.contextstream.io/mcp`) uses OAuth authentication that routes through `vscode.dev` for the redirect flow. This can fail in environments where `vscode.dev` is blocked (corporate networks, regional restrictions, CDN-level blocks).
+
+**Workaround:** Use the stdio transport (Rust binary or Node.js) with API key authentication instead:
+
+```json
+{
+  "contextstream": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["-y", "@contextstream/mcp-server@latest"],
+    "env": {
+      "CONTEXTSTREAM_API_KEY": "your-api-key"
+    }
+  }
+}
+```
+
+### SDK version compatibility
+
+`@modelcontextprotocol/sdk` versions 1.28.0 and above introduce breaking changes. The `package.json` pins the SDK to `>=1.25.1 <1.28.0` to prevent incompatible resolutions. If you experience Zod schema errors on startup, ensure your SDK version is below 1.28.0.
+
+## Marketplace Note
+
+The MCP marketplace entry now targets the hosted remote MCP at `https://mcp.contextstream.io/mcp?default_context_mode=fast` so VS Code can use the native OAuth flow instead of writing a local npm-based stdio config.
+
+Use the Rust or Node local runtime configs above only when you explicitly want local execution, custom/self-hosted endpoints, or editor environments that do not support the hosted remote flow.
 
 ---
 

package/dist/hooks/on-read.js

@@ -1,9 +1,153 @@
 #!/usr/bin/env node
 
 // src/hooks/on-read.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+// src/hot-paths.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { homedir } from "node:os";
+var STORE_VERSION = 1;
+var STORE_DIR = path.join(homedir(), ".contextstream");
+var STORE_FILE = path.join(STORE_DIR, "hot-paths.json");
+var MAX_PATHS_PER_SCOPE = 400;
+var HALF_LIFE_MS = 3 * 24 * 60 * 60 * 1e3;
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function normalizePathKey(input) {
+  return input.replace(/\\/g, "/").trim();
+}
+function toScopeKey(input) {
+  const workspace = input.workspace_id || "none";
+  const project = input.project_id || "none";
+  return `${workspace}:${project}`;
+}
+function signalWeight(signal) {
+  switch (signal) {
+    case "search_result":
+      return 1.8;
+    case "activity_edit":
+      return 1.4;
+    case "activity_focus":
+      return 1.2;
+    case "activity_read":
+    default:
+      return 1;
+  }
+}
+function looksBroadQuery(query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  if (q.length <= 2) return true;
+  if (/^\*+$/.test(q) || q === "all files" || q === "everything") return true;
+  const tokens = q.split(/\s+/).filter(Boolean);
+  return tokens.length > 12;
+}
+var HotPathStore = class {
+  constructor() {
+    this.data = { version: STORE_VERSION, scopes: {} };
+    this.load();
+  }
+  recordPaths(scope, paths, signal) {
+    if (paths.length === 0) return;
+    const now = Date.now();
+    const scopeKey = toScopeKey(scope);
+    const profile = this.ensureScope(scopeKey);
+    const weight = signalWeight(signal);
+    for (const raw of paths) {
+      const pathKey = normalizePathKey(raw);
+      if (!pathKey) continue;
+      const current = profile.paths[pathKey] || { score: 0, last_seen: now, hits: 0 };
+      const decayed = this.decayedScore(current.score, current.last_seen, now);
+      profile.paths[pathKey] = {
+        score: decayed + weight,
+        last_seen: now,
+        hits: current.hits + 1
+      };
+    }
+    profile.updated_at = now;
+    this.pruneScope(profile);
+    this.persist();
+  }
+  buildHint(input) {
+    const scopeKey = toScopeKey(input);
+    const profile = this.data.scopes[scopeKey];
+    if (!profile) return void 0;
+    const now = Date.now();
+    const baseEntries = Object.entries(profile.paths).map(([filePath, entry]) => ({
+      path: filePath,
+      score: this.decayedScore(entry.score, entry.last_seen, now)
+    })).filter((entry) => entry.score > 0.05).sort((a, b) => b.score - a.score);
+    const active = (input.active_paths || []).map(normalizePathKey).filter(Boolean);
+    const merged = /* @__PURE__ */ new Map();
+    for (const entry of baseEntries.slice(0, Math.max(12, input.limit || 8))) {
+      merged.set(entry.path, {
+        path: entry.path,
+        score: Number(entry.score.toFixed(4)),
+        source: "history"
+      });
+    }
+    for (const activePath of active) {
+      const existing = merged.get(activePath);
+      if (existing) {
+        existing.score = Number((existing.score + 0.9).toFixed(4));
+      } else {
+        merged.set(activePath, { path: activePath, score: 0.9, source: "active" });
+      }
+    }
+    const limit = clamp(input.limit ?? 8, 1, 12);
+    const entries = [...merged.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+    if (entries.length === 0) return void 0;
+    const scoreSum = entries.reduce((sum, item) => sum + item.score, 0);
+    const normalized = clamp(scoreSum / (limit * 2.5), 0, 1);
+    const confidencePenalty = looksBroadQuery(input.query) ? 0.55 : 1;
+    const confidence = Number((normalized * confidencePenalty).toFixed(3));
+    return {
+      entries,
+      confidence,
+      generated_at: new Date(now).toISOString(),
+      profile_version: STORE_VERSION
+    };
+  }
+  decayedScore(score, lastSeenMs, nowMs) {
+    const elapsed = Math.max(0, nowMs - lastSeenMs);
+    const decay = Math.pow(0.5, elapsed / HALF_LIFE_MS);
+    return score * decay;
+  }
+  ensureScope(scopeKey) {
+    if (!this.data.scopes[scopeKey]) {
+      this.data.scopes[scopeKey] = { paths: {}, updated_at: Date.now() };
+    }
+    return this.data.scopes[scopeKey];
+  }
+  pruneScope(profile) {
+    const entries = Object.entries(profile.paths);
+    if (entries.length <= MAX_PATHS_PER_SCOPE) return;
+    entries.sort((a, b) => b[1].score - a[1].score).slice(MAX_PATHS_PER_SCOPE).forEach(([key]) => delete profile.paths[key]);
+  }
+  load() {
+    try {
+      if (!fs.existsSync(STORE_FILE)) return;
+      const parsed = JSON.parse(fs.readFileSync(STORE_FILE, "utf-8"));
+      if (parsed?.version !== STORE_VERSION || !parsed.scopes) return;
+      this.data = parsed;
+    } catch {
+    }
+  }
+  persist() {
+    try {
+      fs.mkdirSync(STORE_DIR, { recursive: true });
+      fs.writeFileSync(STORE_FILE, JSON.stringify(this.data));
+    } catch {
+    }
+  }
+};
+var globalHotPathStore = new HotPathStore();
+
+// src/hooks/on-read.ts
 var ENABLED = process.env.CONTEXTSTREAM_READ_HOOK_ENABLED !== "false";
 var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
 var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
@@ -11,13 +155,13 @@ var WORKSPACE_ID = null;
 var recentCaptures = /* @__PURE__ */ new Set();
 var CAPTURE_WINDOW_MS = 6e4;
 function loadConfigFromMcpJson(cwd) {
-  let searchDir = path.resolve(cwd);
+  let searchDir = path2.resolve(cwd);
   for (let i = 0; i < 5; i++) {
     if (!API_KEY) {
-      const mcpPath = path.join(searchDir, ".mcp.json");
-      if (fs.existsSync(mcpPath)) {
+      const mcpPath = path2.join(searchDir, ".mcp.json");
+      if (fs2.existsSync(mcpPath)) {
         try {
-          const content = fs.readFileSync(mcpPath, "utf-8");
+          const content = fs2.readFileSync(mcpPath, "utf-8");
           const config = JSON.parse(content);
           const csEnv = config.mcpServers?.contextstream?.env;
           if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -31,10 +175,10 @@ function loadConfigFromMcpJson(cwd) {
       }
     }
     if (!WORKSPACE_ID) {
-      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
-      if (fs.existsSync(csConfigPath)) {
+      const csConfigPath = path2.join(searchDir, ".contextstream", "config.json");
+      if (fs2.existsSync(csConfigPath)) {
         try {
-          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const content = fs2.readFileSync(csConfigPath, "utf-8");
           const csConfig = JSON.parse(content);
           if (csConfig.workspace_id) {
             WORKSPACE_ID = csConfig.workspace_id;
@@ -43,15 +187,15 @@ function loadConfigFromMcpJson(cwd) {
         }
       }
     }
-    const parentDir = path.dirname(searchDir);
+    const parentDir = path2.dirname(searchDir);
     if (parentDir === searchDir) break;
     searchDir = parentDir;
   }
   if (!API_KEY) {
-    const homeMcpPath = path.join(homedir(), ".mcp.json");
-    if (fs.existsSync(homeMcpPath)) {
+    const homeMcpPath = path2.join(homedir2(), ".mcp.json");
+    if (fs2.existsSync(homeMcpPath)) {
       try {
-        const content = fs.readFileSync(homeMcpPath, "utf-8");
+        const content = fs2.readFileSync(homeMcpPath, "utf-8");
         const config = JSON.parse(content);
         const csEnv = config.mcpServers?.contextstream?.env;
         if (csEnv?.CONTEXTSTREAM_API_KEY) {
@@ -136,11 +280,25 @@ async function runOnReadHook() {
     case "Read":
       target = input.tool_input?.file_path || "";
       resultSummary = `Read file: ${target}`;
+      if (target) {
+        globalHotPathStore.recordPaths(
+          { workspace_id: WORKSPACE_ID || void 0, project_id: void 0 },
+          [target],
+          "activity_read"
+        );
+      }
       break;
     case "Glob":
       target = input.tool_input?.pattern || "";
       const globFiles = input.tool_result?.files || [];
       resultSummary = `Found ${globFiles.length} files matching ${target}`;
+      if (globFiles.length > 0) {
+        globalHotPathStore.recordPaths(
+          { workspace_id: WORKSPACE_ID || void 0, project_id: void 0 },
+          globFiles.slice(0, 30),
+          "activity_focus"
+        );
+      }
       break;
     case "Grep":
       target = input.tool_input?.pattern || "";