context-mode 1.0.94 → 1.0.96

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.94"
+    "version": "1.0.96"
   },
   "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.94",
+      "version": "1.0.96",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.94",
+  "version": "1.0.96",
   "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.94",
+  "version": "1.0.96",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.94",
+  "version": "1.0.96",
   "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/build/cache-heal.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Plugin cache self-heal — fixes broken CLAUDE_PLUGIN_ROOT references.
+ *
+ * Claude Code's plugin auto-update can leave installed_plugins.json pointing
+ * to a non-existent directory (anthropics/claude-code#46915). This module
+ * detects and repairs the mismatch by creating symlinks.
+ *
+ * 4-layer defense:
+ *   1. start.mjs startup — reverse heal (registry → symlink to us)
+ *   2. server.ts first tool call — mid-session heal
+ *   3. postinstall.mjs — backward symlink on new install
+ *   4. global hook auto-deploy — survives total plugin cache breakage
+ */
+export interface HealResult {
+    healed: boolean;
+    action?: "symlink" | "global-hook" | "none";
+    from?: string;
+    to?: string;
+}
+/**
+ * Core heal: if installed_plugins.json points to a non-existent directory,
+ * create a symlink from that path to our actual directory.
+ *
+ * @param currentDir - The directory we're actually running from
+ * @param installedPluginsPath - Path to installed_plugins.json (injectable for testing)
+ */
+export declare function healRegistryMismatch(currentDir: string, installedPluginsPath?: string): HealResult;
+/**
+ * Deploy a global SessionStart hook that heals plugin cache mismatches.
+ * This hook lives outside the plugin directory, so it survives cache breakage.
+ *
+ * Written to ~/.claude/hooks/context-mode-cache-heal.sh
+ */
+export declare function deployGlobalHealHook(): HealResult;
+/**
+ * Backward symlink: during postinstall, if the registry points to a
+ * non-existent OLD path, create a symlink from old → new (our directory).
+ * Same as healRegistryMismatch but called from postinstall context.
+ */
+export { healRegistryMismatch as healBackwardCompat };
+/**
+ * Mid-session heal — call on first MCP tool invocation.
+ * Checks if registry path differs from our running directory.
+ * Creates symlink if needed. Runs only once per process.
+ */
+export declare function healMidSession(currentDir: string): HealResult;
+/** Reset mid-session flag (for testing only) */
+export declare function _resetMidSession(): void;

package/build/cache-heal.js

@@ -0,0 +1,150 @@
+/**
+ * Plugin cache self-heal — fixes broken CLAUDE_PLUGIN_ROOT references.
+ *
+ * Claude Code's plugin auto-update can leave installed_plugins.json pointing
+ * to a non-existent directory (anthropics/claude-code#46915). This module
+ * detects and repairs the mismatch by creating symlinks.
+ *
+ * 4-layer defense:
+ *   1. start.mjs startup — reverse heal (registry → symlink to us)
+ *   2. server.ts first tool call — mid-session heal
+ *   3. postinstall.mjs — backward symlink on new install
+ *   4. global hook auto-deploy — survives total plugin cache breakage
+ */
+import { existsSync, readFileSync, symlinkSync, mkdirSync, writeFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+/**
+ * Core heal: if installed_plugins.json points to a non-existent directory,
+ * create a symlink from that path to our actual directory.
+ *
+ * @param currentDir - The directory we're actually running from
+ * @param installedPluginsPath - Path to installed_plugins.json (injectable for testing)
+ */
+export function healRegistryMismatch(currentDir, installedPluginsPath) {
+    const ipPath = installedPluginsPath ?? resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+    if (!existsSync(ipPath))
+        return { healed: false, action: "none" };
+    if (!existsSync(currentDir))
+        return { healed: false, action: "none" };
+    let ip;
+    try {
+        ip = JSON.parse(readFileSync(ipPath, "utf-8"));
+    }
+    catch {
+        return { healed: false, action: "none" };
+    }
+    for (const [key, entries] of Object.entries(ip.plugins ?? {})) {
+        if (!key.toLowerCase().includes("context-mode"))
+            continue;
+        for (const entry of entries) {
+            const registryPath = entry.installPath;
+            if (!registryPath)
+                continue;
+            // Registry path exists — no healing needed
+            if (existsSync(registryPath))
+                continue;
+            // Registry path doesn't exist — create symlink to our directory
+            try {
+                const parent = dirname(registryPath);
+                if (!existsSync(parent))
+                    mkdirSync(parent, { recursive: true });
+                if (process.platform === "win32") {
+                    // Windows: use junction (no admin required)
+                    symlinkSync(currentDir, registryPath, "junction");
+                }
+                else {
+                    symlinkSync(currentDir, registryPath);
+                }
+                return { healed: true, action: "symlink", from: registryPath, to: currentDir };
+            }
+            catch {
+                return { healed: false, action: "none" };
+            }
+        }
+    }
+    return { healed: false, action: "none" };
+}
+/**
+ * Deploy a global SessionStart hook that heals plugin cache mismatches.
+ * This hook lives outside the plugin directory, so it survives cache breakage.
+ *
+ * Written to ~/.claude/hooks/context-mode-cache-heal.sh
+ */
+export function deployGlobalHealHook() {
+    const hooksDir = resolve(homedir(), ".claude", "hooks");
+    const hookPath = resolve(hooksDir, "context-mode-cache-heal.sh");
+    // Already deployed
+    if (existsSync(hookPath))
+        return { healed: false, action: "none" };
+    try {
+        if (!existsSync(hooksDir))
+            mkdirSync(hooksDir, { recursive: true });
+        const script = `#!/usr/bin/env bash
+# context-mode plugin cache self-heal — auto-deployed by context-mode MCP server
+# Fixes anthropics/claude-code#46915: auto-update breaks CLAUDE_PLUGIN_ROOT
+# This hook runs at SessionStart (global, not plugin-level) so it works even
+# when the plugin cache is broken.
+
+set -euo pipefail
+
+PLUGINS_FILE="$HOME/.claude/plugins/installed_plugins.json"
+[[ -f "$PLUGINS_FILE" ]] || exit 0
+
+# Find context-mode entries and heal missing directories
+node -e '
+const fs = require("fs");
+const path = require("path");
+try {
+  const ip = JSON.parse(fs.readFileSync(process.argv[1], "utf-8"));
+  for (const [key, entries] of Object.entries(ip.plugins || {})) {
+    if (!key.toLowerCase().includes("context-mode")) continue;
+    for (const entry of entries) {
+      const p = entry.installPath;
+      if (!p || fs.existsSync(p)) continue;
+      const parent = path.dirname(p);
+      if (!fs.existsSync(parent)) continue;
+      const dirs = fs.readdirSync(parent).filter(d => /^\\d+\\.\\d+/.test(d) && fs.statSync(path.join(parent, d)).isDirectory());
+      if (dirs.length === 0) continue;
+      dirs.sort((a, b) => {
+        const pa = a.split(".").map(Number), pb = b.split(".").map(Number);
+        for (let i = 0; i < 3; i++) { if ((pa[i]||0) !== (pb[i]||0)) return (pa[i]||0) - (pb[i]||0); }
+        return 0;
+      });
+      const target = path.join(parent, dirs[dirs.length - 1]);
+      try { fs.symlinkSync(target, p); } catch {}
+    }
+  }
+} catch {}
+' "$PLUGINS_FILE" 2>/dev/null || true
+`;
+        writeFileSync(hookPath, script, { mode: 0o755 });
+        return { healed: true, action: "global-hook", from: hookPath };
+    }
+    catch {
+        return { healed: false, action: "none" };
+    }
+}
+/**
+ * Backward symlink: during postinstall, if the registry points to a
+ * non-existent OLD path, create a symlink from old → new (our directory).
+ * Same as healRegistryMismatch but called from postinstall context.
+ */
+export { healRegistryMismatch as healBackwardCompat };
+/** One-shot flag for mid-session heal in server.ts */
+let _midSessionHealed = false;
+/**
+ * Mid-session heal — call on first MCP tool invocation.
+ * Checks if registry path differs from our running directory.
+ * Creates symlink if needed. Runs only once per process.
+ */
+export function healMidSession(currentDir) {
+    if (_midSessionHealed)
+        return { healed: false, action: "none" };
+    _midSessionHealed = true;
+    return healRegistryMismatch(currentDir);
+}
+/** Reset mid-session flag (for testing only) */
+export function _resetMidSession() {
+    _midSessionHealed = false;
+}

package/build/server.js

@@ -3,7 +3,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
-import { existsSync, unlinkSync, readdirSync, readFileSync, writeFileSync, rmSync, mkdirSync, cpSync, statSync } from "node:fs";
+import { existsSync, unlinkSync, readdirSync, readFileSync, writeFileSync, rmSync, mkdirSync, cpSync, statSync, symlinkSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -262,7 +262,42 @@ function shouldShowVersionWarning() {
     _warningBurstCount++;
     return true;
 }
+// ── Self-heal Layer 2: Mid-session registry heal (anthropics/claude-code#46915) ──
+// Runs once on first tool call. If Claude Code auto-updated the registry mid-session,
+// hooks break because CLAUDE_PLUGIN_ROOT points to a deleted directory. We create a
+// symlink from the broken path to our actual directory so hooks recover.
+let _cacheHealDone = false;
+function healCacheMidSession() {
+    if (_cacheHealDone)
+        return;
+    _cacheHealDone = true;
+    try {
+        const ipPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+        if (!existsSync(ipPath))
+            return;
+        const ip = JSON.parse(readFileSync(ipPath, "utf-8"));
+        for (const [key, entries] of Object.entries((ip.plugins ?? {}))) {
+            if (!key.toLowerCase().includes("context-mode"))
+                continue;
+            for (const entry of entries) {
+                const rp = entry.installPath;
+                if (!rp || existsSync(rp))
+                    continue;
+                const parent = dirname(rp);
+                if (!existsSync(parent))
+                    mkdirSync(parent, { recursive: true });
+                const target = resolve(__pkg_dir, "..");
+                if (existsSync(target)) {
+                    symlinkSync(target, rp, process.platform === "win32" ? "junction" : undefined);
+                }
+            }
+        }
+    }
+    catch { /* best effort */ }
+}
 function trackResponse(toolName, response) {
+    // Mid-session cache heal — one-shot, first tool call
+    healCacheMidSession();
     // Prepend version outdated warning if needed
     if (shouldShowVersionWarning() && response.content.length > 0) {
         const hint = getUpgradeHint();

package/build/session/analytics.d.ts

@@ -96,6 +96,16 @@ export interface FullReport {
         compact_count: number;
         resume_ready: boolean;
     };
+    /** Persistent project memory — all events across all sessions */
+    projectMemory: {
+        total_events: number;
+        session_count: number;
+        by_category: Array<{
+            category: string;
+            count: number;
+            label: string;
+        }>;
+    };
 }
 /** Human-readable labels for event categories. */
 export declare const categoryLabels: Record<string, string>;
@@ -155,8 +165,7 @@ export declare class AnalyticsEngine {
  * - Before/After comparison bar is the HERO — one glance = "wow"
  * - "tokens saved" is the number people share
  * - Per-tool breakdown shows what each tool SAVED, sorted by impact
- * - Session memory: one line, reframed as value
+ * - Project memory: category bars showing persistent data across sessions
  * - No: Pct column, category tables, tips, jargon
- * - Under 22 lines for heavy sessions, under 10 for fresh
  */
 export declare function formatReport(report: FullReport, version?: string, latestVersion?: string | null): string;

package/build/session/analytics.js

@@ -199,6 +199,16 @@ export class AnalyticsEngine {
                 : "",
             why: categoryHints[row.category] || "Survives context resets",
         }));
+        // ── Project-wide persistent memory (all sessions, no session_id filter) ──
+        const projectTotals = this.db.prepare("SELECT COUNT(*) as cnt, COUNT(DISTINCT session_id) as sessions FROM session_events").get();
+        const projectByCategory = this.db.prepare("SELECT category, COUNT(*) as cnt FROM session_events GROUP BY category ORDER BY cnt DESC").all();
+        const projectMemoryByCategory = projectByCategory
+            .filter((row) => row.cnt > 0)
+            .map((row) => ({
+            category: row.category,
+            count: row.cnt,
+            label: categoryLabels[row.category] || row.category,
+        }));
         return {
             savings: {
                 processed_kb: Math.round(totalProcessed / 1024 * 10) / 10,
@@ -223,6 +233,11 @@ export class AnalyticsEngine {
                 compact_count: compactCount,
                 resume_ready: resumeReady,
             },
+            projectMemory: {
+                total_events: projectTotals.cnt,
+                session_count: projectTotals.sessions,
+                by_category: projectMemoryByCategory,
+            },
         };
     }
 }
@@ -266,6 +281,24 @@ function dataBar(bytes, maxBytes, width = 40) {
     const filled = Math.max(1, Math.round((bytes / maxBytes) * width));
     return "█".repeat(Math.min(filled, width)) + "░".repeat(Math.max(0, width - filled));
 }
+/**
+ * Render project memory section with category bars.
+ * Shows persistent event data across all sessions.
+ */
+function renderProjectMemory(pm) {
+    if (pm.total_events === 0)
+        return [];
+    const out = [];
+    out.push("");
+    const sessionLabel = pm.session_count === 1 ? "1 session" : `${pm.session_count} sessions`;
+    out.push(`${fmtNum(pm.total_events)} events remembered across ${sessionLabel} \u2014 searchable after compact & restart`);
+    out.push("");
+    const maxCount = pm.by_category.length > 0 ? pm.by_category[0].count : 1;
+    for (const cat of pm.by_category) {
+        out.push(`  ${cat.label.padEnd(18)} ${String(cat.count).padStart(5)}   ${dataBar(cat.count, maxCount, 30)}`);
+    }
+    return out;
+}
 /**
  * Render a FullReport as a visual savings dashboard designed for screenshotting.
  *
@@ -273,9 +306,8 @@ function dataBar(bytes, maxBytes, width = 40) {
  * - Before/After comparison bar is the HERO — one glance = "wow"
  * - "tokens saved" is the number people share
  * - Per-tool breakdown shows what each tool SAVED, sorted by impact
- * - Session memory: one line, reframed as value
+ * - Project memory: category bars showing persistent data across sessions
  * - No: Pct column, category tables, tips, jargon
- * - Under 22 lines for heavy sessions, under 10 for fresh
  */
 export function formatReport(report, version, latestVersion) {
     const lines = [];
@@ -297,6 +329,8 @@ export function formatReport(report, version, latestVersion) {
         else {
             lines.push(`${kb(totalReturned)} entered context  |  0 tokens saved`);
         }
+        // Project memory
+        lines.push(...renderProjectMemory(report.projectMemory));
         // Footer
         lines.push("");
         const versionStr = version ? `v${version}` : "context-mode";
@@ -342,36 +376,8 @@ export function formatReport(report, version, latestVersion) {
             lines.push(`  ${name.padEnd(22)}  ${String(t.calls).padStart(4)} calls  ${kb(t.estimatedSaved).padStart(8)} saved`);
         }
     }
-    // ── Session memory — business-friendly ──
-    if (report.continuity.total_events > 0) {
-        lines.push("");
-        const cats = report.continuity.by_category;
-        // Pick the top 3-4 most impactful categories for a human-readable summary
-        const highlights = [];
-        const fileCount = cats.find(c => c.category === "file")?.count;
-        const gitCount = cats.find(c => c.category === "git")?.count;
-        const promptCount = cats.find(c => c.category === "prompt")?.count;
-        const errorCount = cats.find(c => c.category === "error")?.count;
-        const taskCount = cats.find(c => c.category === "task")?.count;
-        if (fileCount)
-            highlights.push(`${fileCount} files`);
-        if (gitCount)
-            highlights.push(`${gitCount} git ops`);
-        if (promptCount)
-            highlights.push(`${promptCount} prompts`);
-        if (errorCount)
-            highlights.push(`${errorCount} errors`);
-        if (taskCount)
-            highlights.push(`${taskCount} tasks`);
-        const summary = highlights.length > 0 ? `  ·  ${highlights.join(", ")}` : "";
-        if (report.continuity.compact_count > 0) {
-            lines.push(`${fmtNum(report.continuity.total_events)} events remembered across ${report.continuity.compact_count} compaction${report.continuity.compact_count !== 1 ? "s" : ""}${summary}`);
-            lines.push("Zero knowledge lost — picks up exactly where you left off.");
-        }
-        else {
-            lines.push(`${fmtNum(report.continuity.total_events)} events tracked${summary}`);
-        }
-    }
+    // ── Project memory — persistent across sessions ──
+    lines.push(...renderProjectMemory(report.projectMemory));
     // ── Footer ──
     lines.push("");
     const versionStr = version ? `v${version}` : "context-mode";