context-mode 1.0.64 → 1.0.66

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.64"
+    "version": "1.0.66"
   },
   "plugins": [
     {
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "1.0.64",
+      "version": "1.0.66",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/.openclaw-plugin/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
   "author": {
     "name": "Mert Koseoğlu",

package/README.md

@@ -685,6 +685,7 @@ npm install -g context-mode
 | `ctx_stats` | Show context savings, call counts, and session statistics. | — |
 | `ctx_doctor` | Diagnose installation: runtimes, hooks, FTS5, versions. | — |
 | `ctx_upgrade` | Upgrade to latest version from GitHub, rebuild, reconfigure hooks. | — |
+| `ctx_purge` | Permanently deletes all indexed content from the knowledge base. | — |
 
 ## How the Sandbox Works
 
@@ -913,6 +914,7 @@ See [`docs/platform-support.md`](docs/platform-support.md) for the full capabili
 ctx stats       → context savings, call counts, session report
 ctx doctor      → diagnose runtimes, hooks, FTS5, versions
 ctx upgrade     → update from GitHub, rebuild, reconfigure hooks
+ctx purge       → permanently delete all indexed content from the knowledge base
 ```
 
 **From your terminal** — run directly without an AI session:
@@ -925,7 +927,7 @@ bash scripts/ctx-debug.sh    # full diagnostic report for bug reports
 
 The debug script collects OS info, runtime versions, better-sqlite3 status, adapter detection, config files (redacted), hook validation, FTS5/SQLite test, executor test, process check, session databases, and environment variables into a single pasteable markdown report.
 
-Works on **all platforms**. On Claude Code, slash commands (`/ctx-stats`, `/ctx-doctor`, `/ctx-upgrade`) are also available.
+Works on **all platforms**. On Claude Code, slash commands (`/ctx-stats`, `/ctx-doctor`, `/ctx-upgrade`, `/ctx-purge`) are also available.
 
 ## Benchmarks
 

package/build/server.js

@@ -16,6 +16,7 @@ import { classifyNonZeroExit } from "./exit-classify.js";
 import { startLifecycleGuard } from "./lifecycle.js";
 import { getWorktreeSuffix } from "./session/db.js";
 import { loadDatabase } from "./db-base.js";
+import { AnalyticsEngine, formatReport } from "./session/analytics.js";
 const __pkg_dir = dirname(fileURLToPath(import.meta.url));
 const VERSION = (() => {
     for (const rel of ["../package.json", "./package.json"]) {
@@ -66,7 +67,7 @@ let _store = null;
  */
 function maybeIndexSessionEvents(store) {
     try {
-        const sessionsDir = join(homedir(), ".claude", "context-mode", "sessions");
+        const sessionsDir = getSessionDir();
         if (!existsSync(sessionsDir))
             return;
         const files = readdirSync(sessionsDir).filter(f => f.endsWith("-events.md"));
@@ -81,18 +82,66 @@ function maybeIndexSessionEvents(store) {
     }
     catch { /* best-effort — session continuity never blocks tools */ }
 }
+// ── Platform-aware paths ──────────────────────────────────────────────────
+// The adapter (stored after MCP handshake) is the canonical source for
+// platform-specific paths. All session DB paths go through it — no
+// hardcoded configDir detection in tool handlers.
+let _detectedAdapter = null;
 /**
- * Compute a per-project persistent path for the ContentStore.
- * Uses SHA256 of the project dir (normalized for Windows) to avoid collisions.
+ * Get the platform-specific sessions directory from the detected adapter.
+ * Falls back to ~/.claude/context-mode/sessions/ before adapter detection.
  */
-function getStorePath() {
-    const projectDir = process.env.CLAUDE_PROJECT_DIR
+function getSessionDir() {
+    if (_detectedAdapter)
+        return _detectedAdapter.getSessionDir();
+    const dir = join(homedir(), ".claude", "context-mode", "sessions");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+/**
+ * Project directory detection across supported platforms.
+ *
+ * Priority:
+ *   1. Platform-specific env var (set by host IDE before MCP server spawn)
+ *   2. CONTEXT_MODE_PROJECT_DIR (set by start.mjs for ALL platforms — universal)
+ *   3. process.cwd() (last resort)
+ *
+ * CONTEXT_MODE_PROJECT_DIR guarantees correct projectDir even for platforms
+ * that don't set their own env var (Cursor, OpenClaw, Codex, Kiro, Zed).
+ */
+function getProjectDir() {
+    return process.env.CLAUDE_PROJECT_DIR
         || process.env.GEMINI_PROJECT_DIR
-        || process.env.OPENCLAW_HOME
+        || process.env.VSCODE_CWD
+        || process.env.OPENCODE_PROJECT_DIR
+        || process.env.PI_PROJECT_DIR
+        || process.env.CONTEXT_MODE_PROJECT_DIR
         || process.cwd();
+}
+/**
+ * Consistent project dir hashing across all DB paths.
+ * Normalizes Windows backslashes before hashing so the same project
+ * always produces the same hash regardless of path separator.
+ */
+function hashProjectDir() {
+    const projectDir = getProjectDir();
     const normalized = projectDir.replace(/\\/g, "/");
-    const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-    const dir = join(homedir(), ".context-mode", "content");
+    return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+/**
+ * Compute a per-project, per-platform persistent path for the ContentStore.
+ * Derives content dir from the adapter's session dir so each platform
+ * has its own isolated FTS5 DB — no cross-platform data sharing.
+ *
+ * Layout: ~/<configDir>/context-mode/content/<hash>.db
+ *   e.g.  ~/.claude/context-mode/content/87c28c41ddb64d38.db
+ *         ~/.cursor/context-mode/content/87c28c41ddb64d38.db
+ */
+function getStorePath() {
+    const hash = hashProjectDir();
+    // Derive content dir from session dir: .../sessions/ → .../content/
+    const sessDir = getSessionDir();
+    const dir = join(dirname(sessDir), "content");
     mkdirSync(dir, { recursive: true });
     return join(dir, `${hash}.db`);
 }
@@ -104,9 +153,13 @@ function getStore() {
         _store = new ContentStore(dbPath);
         // One-time startup cleanup: remove stale content DBs (>14 days)
         try {
-            const contentDir = join(homedir(), ".context-mode", "content");
+            const contentDir = dirname(getStorePath());
             cleanupStaleContentDBs(contentDir, 14);
             _store.cleanupStaleSources(14);
+            // Also clean legacy shared dir from before platform isolation
+            const legacyDir = join(homedir(), ".context-mode", "content");
+            if (existsSync(legacyDir))
+                cleanupStaleContentDBs(legacyDir, 0);
         }
         catch { /* best-effort */ }
         // Also clean old PID-based DBs from migration
@@ -127,43 +180,7 @@ const sessionStats = {
     cacheBytesSaved: 0, // bytes avoided by TTL cache hits
     sessionStart: Date.now(),
 };
-/**
- * Reset session stats to zero. Called when /clear flag is detected.
- * The SessionStart hook writes a .clear-stats flag file on /clear,
- * and the server checks for it before each tool call.
- */
-function resetSessionStats() {
-    sessionStats.calls = {};
-    sessionStats.bytesReturned = {};
-    sessionStats.bytesIndexed = 0;
-    sessionStats.bytesSandboxed = 0;
-    sessionStats.cacheHits = 0;
-    sessionStats.cacheBytesSaved = 0;
-    sessionStats.sessionStart = Date.now();
-    // Also reset FTS5 content store — drop and recreate on next getStore() call
-    if (_store) {
-        try {
-            _store.cleanup();
-        }
-        catch { /* best effort */ }
-        _store = null;
-    }
-}
-/** Check for .clear-stats flag and reset stats if found. */
-function checkClearStatsFlag() {
-    const sessDir = join(homedir(), ".claude", "context-mode", "sessions");
-    try {
-        const flags = readdirSync(sessDir).filter((f) => f.endsWith(".clear-stats"));
-        for (const f of flags) {
-            unlinkSync(join(sessDir, f));
-        }
-        if (flags.length > 0)
-            resetSessionStats();
-    }
-    catch { /* best effort */ }
-}
 function trackResponse(toolName, response) {
-    checkClearStatsFlag();
     const bytes = response.content.reduce((sum, c) => sum + Buffer.byteLength(c.text), 0);
     sessionStats.calls[toolName] = (sessionStats.calls[toolName] || 0) + 1;
     sessionStats.bytesReturned[toolName] =
@@ -1402,178 +1419,57 @@ server.registerTool("ctx_batch_execute", {
 // ─────────────────────────────────────────────────────────
 // Tool: stats
 // ─────────────────────────────────────────────────────────
+/**
+ * Create a minimal in-memory DB adapter for when the session DB is unavailable.
+ * All queries return empty results so AnalyticsEngine.queryAll() still works.
+ */
+function createMinimalDb() {
+    return {
+        prepare: () => ({
+            run: () => undefined,
+            get: (..._args) => ({ cnt: 0, compact_count: 0, minutes: null, rate: 0, avg: 0, outcome: "exploratory" }),
+            all: () => [],
+        }),
+    };
+}
 server.registerTool("ctx_stats", {
     title: "Session Statistics",
     description: "Returns context consumption statistics for the current session. " +
         "Shows total bytes returned to context, breakdown by tool, call counts, " +
         "estimated token usage, and context savings ratio.",
-    inputSchema: z.object({
-        reset: z.boolean().optional().describe("Reset all stats and FTS5 store to zero. Use after /clear."),
-    }),
-}, async ({ reset }) => {
-    // Check for clear flag BEFORE reading stats
-    checkClearStatsFlag();
-    if (reset) {
-        resetSessionStats();
-        return trackResponse("ctx_stats", {
-            content: [{ type: "text", text: "Session stats and search index reset." }],
-        });
-    }
-    const totalBytesReturned = Object.values(sessionStats.bytesReturned).reduce((sum, b) => sum + b, 0);
-    const totalCalls = Object.values(sessionStats.calls).reduce((sum, c) => sum + c, 0);
-    const uptimeMs = Date.now() - sessionStats.sessionStart;
-    const uptimeMin = (uptimeMs / 60_000).toFixed(1);
-    // Total data kept out of context = indexed (FTS5) + sandboxed (network I/O inside sandbox)
-    const keptOut = sessionStats.bytesIndexed + sessionStats.bytesSandboxed;
-    const totalProcessed = keptOut + totalBytesReturned;
-    const savingsRatio = totalProcessed / Math.max(totalBytesReturned, 1);
-    const reductionPct = totalProcessed > 0
-        ? ((1 - totalBytesReturned / totalProcessed) * 100).toFixed(0)
-        : "0";
-    const kb = (b) => {
-        if (b >= 1024 * 1024)
-            return `${(b / 1024 / 1024).toFixed(1)}MB`;
-        return `${(b / 1024).toFixed(1)}KB`;
-    };
-    // ── Header ──
-    const lines = [
-        `## context-mode — Session Report (${uptimeMin} min)`,
-    ];
-    // ── Feature 1: Context Window Protection ──
-    lines.push("", `### Context Window Protection`, "");
-    if (totalCalls === 0) {
-        lines.push(`No context-mode tool calls yet. Use \`batch_execute\`, \`execute\`, or \`fetch_and_index\` to keep raw output out of your context window.`);
-    }
-    else {
-        lines.push(`| Metric | Value |`, `|--------|------:|`, `| Total data processed | **${kb(totalProcessed)}** |`, `| Kept in sandbox (never entered context) | **${kb(keptOut)}** |`, `| Entered context | ${kb(totalBytesReturned)} |`, `| Estimated tokens saved | ~${Math.round(keptOut / 4).toLocaleString()} |`, `| **Context savings** | **${savingsRatio.toFixed(1)}x (${reductionPct}% reduction)** |`);
-        // Per-tool breakdown
-        const toolNames = new Set([
-            ...Object.keys(sessionStats.calls),
-            ...Object.keys(sessionStats.bytesReturned),
-        ]);
-        if (toolNames.size > 0) {
-            lines.push("", `| Tool | Calls | Context | Tokens |`, `|------|------:|--------:|-------:|`);
-            for (const tool of Array.from(toolNames).sort()) {
-                const calls = sessionStats.calls[tool] || 0;
-                const bytes = sessionStats.bytesReturned[tool] || 0;
-                const tokens = Math.round(bytes / 4);
-                lines.push(`| ${tool} | ${calls} | ${kb(bytes)} | ~${tokens.toLocaleString()} |`);
-            }
-            lines.push(`| **Total** | **${totalCalls}** | **${kb(totalBytesReturned)}** | **~${Math.round(totalBytesReturned / 4).toLocaleString()}** |`);
-        }
-        if (keptOut > 0) {
-            lines.push("", `Without context-mode, **${kb(totalProcessed)}** of raw output would flood your context window. Instead, **${reductionPct}%** stayed in sandbox.`);
-        }
-        // Cache savings section
-        if (sessionStats.cacheHits > 0 || sessionStats.cacheBytesSaved > 0) {
-            const totalWithCache = totalProcessed + sessionStats.cacheBytesSaved;
-            const totalSavingsRatio = totalWithCache / Math.max(totalBytesReturned, 1);
-            const ttlHoursLeft = Math.max(0, 24 - Math.floor((Date.now() - sessionStats.sessionStart) / (60 * 60 * 1000)));
-            lines.push("", `### TTL Cache`, "", `| Metric | Value |`, `|--------|------:|`, `| Cache hits | **${sessionStats.cacheHits}** |`, `| Data avoided by cache | **${kb(sessionStats.cacheBytesSaved)}** |`, `| Network requests saved | **${sessionStats.cacheHits}** |`, `| TTL remaining | **~${ttlHoursLeft}h** |`, "", `Content was already indexed in the knowledge base — ${sessionStats.cacheHits} fetch${sessionStats.cacheHits > 1 ? "es" : ""} skipped entirely. **${kb(sessionStats.cacheBytesSaved)}** of network I/O avoided. Search results served directly from local FTS5 index.`);
-            // Update total savings to include cache
-            if (totalSavingsRatio > savingsRatio) {
-                lines.push("", `**Total context savings (sandbox + cache): ${totalSavingsRatio.toFixed(1)}x** — ${kb(totalWithCache)} processed, only ${kb(totalBytesReturned)} entered context.`);
-            }
-        }
-    }
-    // ── Session Continuity ──
+    inputSchema: z.object({}),
+}, async () => {
+    // ONE call, ONE source — AnalyticsEngine.queryAll()
+    let text;
     try {
-        const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-        const dbHash = createHash("sha256").update(projectDir).digest("hex").slice(0, 16);
+        const dbHash = hashProjectDir();
         const worktreeSuffix = getWorktreeSuffix();
-        const sessionDbPath = join(homedir(), ".claude", "context-mode", "sessions", `${dbHash}${worktreeSuffix}.db`);
+        const sessionDbPath = join(getSessionDir(), `${dbHash}${worktreeSuffix}.db`);
         if (existsSync(sessionDbPath)) {
             const Database = loadDatabase();
             const sdb = new Database(sessionDbPath, { readonly: true });
-            const eventTotal = sdb.prepare("SELECT COUNT(*) as cnt FROM session_events").get();
-            const byCategory = sdb.prepare("SELECT category, COUNT(*) as cnt FROM session_events GROUP BY category ORDER BY cnt DESC").all();
-            const meta = sdb.prepare("SELECT compact_count FROM session_meta ORDER BY started_at DESC LIMIT 1").get();
-            const resume = sdb.prepare("SELECT event_count, consumed FROM session_resume ORDER BY created_at DESC LIMIT 1").get();
-            if (eventTotal.cnt > 0) {
-                const compacts = meta?.compact_count ?? 0;
-                // Query actual data per category for preview
-                const previewRows = sdb.prepare(`SELECT category, type, data FROM session_events ORDER BY id DESC`).all();
-                // Build previews: unique values per category
-                const previews = new Map();
-                for (const row of previewRows) {
-                    if (!previews.has(row.category))
-                        previews.set(row.category, new Set());
-                    const set = previews.get(row.category);
-                    if (set.size < 5) {
-                        let display = row.data;
-                        if (row.category === "file") {
-                            display = row.data.split("/").pop() || row.data;
-                        }
-                        else if (row.category === "prompt") {
-                            display = display.length > 50 ? display.slice(0, 47) + "..." : display;
-                        }
-                        if (display.length > 40)
-                            display = display.slice(0, 37) + "...";
-                        set.add(display);
-                    }
-                }
-                const categoryLabels = {
-                    file: "Files tracked",
-                    rule: "Project rules (CLAUDE.md)",
-                    prompt: "Your requests saved",
-                    mcp: "Plugin tools used",
-                    git: "Git operations",
-                    env: "Environment setup",
-                    error: "Errors caught",
-                    task: "Tasks in progress",
-                    decision: "Your decisions",
-                    cwd: "Working directory",
-                    skill: "Skills used",
-                    subagent: "Delegated work",
-                    intent: "Session mode",
-                    data: "Data references",
-                    role: "Behavioral directives",
-                };
-                const categoryHints = {
-                    file: "Restored after compact — no need to re-read",
-                    rule: "Your project instructions survive context resets",
-                    prompt: "Continues exactly where you left off",
-                    decision: "Applied automatically — won't ask again",
-                    task: "Picks up from where it stopped",
-                    error: "Tracked and monitored across compacts",
-                    git: "Branch, commit, and repo state preserved",
-                    env: "Runtime config carried forward",
-                    mcp: "Tool usage patterns remembered",
-                    subagent: "Delegation history preserved",
-                    skill: "Skill invocations tracked",
-                };
-                lines.push("", "### Session Continuity", "", "| What's preserved | Count | I remember... | Why it matters |", "|------------------|------:|---------------|----------------|");
-                for (const row of byCategory) {
-                    const label = categoryLabels[row.category] || row.category;
-                    const preview = previews.get(row.category);
-                    const previewStr = preview ? Array.from(preview).join(", ") : "";
-                    const hint = categoryHints[row.category] || "Survives context resets";
-                    lines.push(`| ${label} | ${row.cnt} | ${previewStr} | ${hint} |`);
-                }
-                lines.push(`| **Total** | **${eventTotal.cnt}** | | **Zero knowledge lost on compact** |`);
-                lines.push("");
-                if (compacts > 0) {
-                    lines.push(`Context has been compacted **${compacts} time(s)** — session knowledge was preserved each time.`);
-                }
-                else {
-                    lines.push(`When your context compacts, all of this will restore Claude's awareness — no starting from scratch.`);
-                }
-                if (resume && !resume.consumed) {
-                    lines.push(`Resume snapshot ready (${resume.event_count} events) for the next compaction.`);
-                }
-                lines.push("");
-                lines.push(`> **Note:** Previous session data is loaded when you start a new session. Without \`--continue\`, old session history is cleaned up to keep the database lean.`);
+            try {
+                const engine = new AnalyticsEngine(sdb);
+                const report = engine.queryAll(sessionStats);
+                text = formatReport(report);
             }
-            sdb.close();
+            finally {
+                sdb.close();
+            }
+        }
+        else {
+            // No session DB — build a minimal report from runtime stats only
+            const engine = new AnalyticsEngine(createMinimalDb());
+            const report = engine.queryAll(sessionStats);
+            text = formatReport(report);
         }
     }
     catch {
-        // Session DB not available or incompatible — skip silently
+        // Session DB not available or incompatible — build minimal report from runtime stats
+        const engine = new AnalyticsEngine(createMinimalDb());
+        const report = engine.queryAll(sessionStats);
+        text = formatReport(report);
     }
-    // No separate DevRel summary — integrated into feature sections above
-    // Formatting directive — ensures all LLMs display the report verbatim
-    lines.push("", "---", "_Display this entire report as-is in your response. Do NOT summarize, collapse, or paraphrase any section._");
-    const text = lines.join("\n");
     return trackResponse("ctx_stats", {
         content: [{ type: "text", text }],
     });
@@ -1733,6 +1629,110 @@ server.registerTool("ctx_upgrade", {
         content: [{ type: "text", text }],
     });
 });
+// ── ctx-purge: explicit knowledge base wipe ─────────────────────────────────
+server.registerTool("ctx_purge", {
+    title: "Purge Knowledge Base",
+    description: "Permanently deletes ALL session data for this project: " +
+        "FTS5 knowledge base (indexed content), session events DB (analytics, metadata, " +
+        "resume snapshots), and session events markdown. Resets in-memory stats. " +
+        "This is irreversible.",
+    inputSchema: z.object({
+        confirm: z.boolean().describe("Must be true to confirm the destructive operation."),
+    }),
+}, async ({ confirm }) => {
+    if (!confirm) {
+        return trackResponse("ctx_purge", {
+            content: [{
+                    type: "text",
+                    text: "Purge cancelled. Pass confirm: true to proceed.",
+                }],
+        });
+    }
+    const deleted = [];
+    // 1. Wipe the persistent FTS5 content store
+    if (_store) {
+        let storeFound = false;
+        try {
+            _store.cleanup();
+            storeFound = true;
+        }
+        catch { /* best effort */ }
+        _store = null;
+        if (storeFound)
+            deleted.push("knowledge base (FTS5)");
+    }
+    else {
+        const dbPath = getStorePath();
+        let found = false;
+        for (const suffix of ["", "-wal", "-shm"]) {
+            try {
+                unlinkSync(dbPath + suffix);
+                found = true;
+            }
+            catch { /* file may not exist */ }
+        }
+        if (found)
+            deleted.push("knowledge base (FTS5)");
+    }
+    // 2. Wipe legacy shared content DB (~/.context-mode/content/<hash>.db)
+    try {
+        const legacyPath = join(homedir(), ".context-mode", "content", `${hashProjectDir()}.db`);
+        for (const suffix of ["", "-wal", "-shm"]) {
+            try {
+                unlinkSync(legacyPath + suffix);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* best effort */ }
+    // 3. Wipe session events DB (analytics, metadata, resume snapshots)
+    try {
+        const dbHash = hashProjectDir();
+        const worktreeSuffix = getWorktreeSuffix();
+        const sessDir = getSessionDir();
+        const sessDbPath = join(sessDir, `${dbHash}${worktreeSuffix}.db`);
+        const eventsPath = join(sessDir, `${dbHash}${worktreeSuffix}-events.md`);
+        const cleanupFlag = join(sessDir, `${dbHash}${worktreeSuffix}.cleanup`);
+        let sessDbFound = false;
+        for (const suffix of ["", "-wal", "-shm"]) {
+            try {
+                unlinkSync(sessDbPath + suffix);
+                sessDbFound = true;
+            }
+            catch { /* ignore */ }
+        }
+        if (sessDbFound)
+            deleted.push("session events DB");
+        let eventsFound = false;
+        try {
+            unlinkSync(eventsPath);
+            eventsFound = true;
+        }
+        catch { /* ignore */ }
+        if (eventsFound)
+            deleted.push("session events markdown");
+        try {
+            unlinkSync(cleanupFlag);
+        }
+        catch { /* ignore */ }
+    }
+    catch { /* best effort */ }
+    // 3. Reset in-memory session stats
+    sessionStats.calls = {};
+    sessionStats.bytesReturned = {};
+    sessionStats.bytesIndexed = 0;
+    sessionStats.bytesSandboxed = 0;
+    sessionStats.cacheHits = 0;
+    sessionStats.cacheBytesSaved = 0;
+    sessionStats.sessionStart = Date.now();
+    deleted.push("session stats");
+    return trackResponse("ctx_purge", {
+        content: [{
+                type: "text",
+                text: `Purged: ${deleted.join(", ")}. All session data for this project has been permanently deleted.`,
+            }],
+    });
+});
 // ─────────────────────────────────────────────────────────
 // Server startup
 // ─────────────────────────────────────────────────────────
@@ -1759,17 +1759,17 @@ async function main() {
     startLifecycleGuard({ onShutdown: () => gracefulShutdown() });
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    // Log detected MCP client for diagnostics
+    // Detect platform adapter — stored for platform-aware session paths
     try {
         const { detectPlatform, getAdapter } = await import("./adapters/detect.js");
         const clientInfo = server.server.getClientVersion();
         const signal = detectPlatform(clientInfo ?? undefined);
-        await getAdapter(signal.platform);
+        _detectedAdapter = await getAdapter(signal.platform);
         if (clientInfo) {
             console.error(`MCP client: ${clientInfo.name} v${clientInfo.version} → ${signal.platform}`);
         }
     }
-    catch { /* best effort — don't block server startup */ }
+    catch { /* best effort — _detectedAdapter stays null, falls back to .claude */ }
     console.error(`Context Mode MCP server v${VERSION} running on stdio`);
     console.error(`Detected runtimes:\n${getRuntimeSummary(runtimes)}`);
     if (!hasBunRuntime()) {