context-mode 1.0.149 → 1.0.151

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.149",
+  "version": "1.0.151",
   "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/.codex-plugin/plugin.json

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

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.149",
+  "version": "1.0.151",
   "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/adapters/vscode-copilot/index.js

@@ -43,7 +43,19 @@ export class VSCodeCopilotAdapter extends CopilotBaseAdapter {
         return `pid-${process.ppid}`;
     }
     getProjectDir() {
-        return process.env.CLAUDE_PROJECT_DIR || process.cwd();
+        // Cascade order (locked by tests/adapters/vscode-copilot.test.ts):
+        //   1. CLAUDE_PROJECT_DIR — top priority for users running VS Code under
+        //      Claude Code CLI.
+        //   2. VSCODE_CWD — exported by VS Code's bootstrap into every child it
+        //      spawns (refs/platforms/vscode-copilot/src/util/vs/base/common/
+        //      process.ts:31). The MCP child inherits it. Was previously missing
+        //      from this cascade — every direct VS Code Copilot session silently
+        //      lost its workspace folder. PR #689 5-agent EM audit (Phase A
+        //      claim verification) confirmed the gap; this is the minimal fix.
+        //   3. process.cwd() — last resort.
+        return (process.env.CLAUDE_PROJECT_DIR
+            || process.env.VSCODE_CWD
+            || process.cwd());
     }
     getSessionDir() {
         // Issue #649: CONTEXT_MODE_DATA_DIR wins over both the .github project

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/opencode-plugin.js

@@ -179,7 +179,7 @@ async function createContextModePlugin(ctx) {
             const toolInput = output.args ?? {};
             let decision;
             try {
-                decision = routing.routePreToolUse(toolName, toolInput, projectDir, getPlatform());
+                decision = routing.routePreToolUse(toolName, toolInput, projectDir, platform);
             }
             catch {
                 return; // Routing failure → allow passthrough
@@ -194,7 +194,10 @@ async function createContextModePlugin(ctx) {
                 // Mutate output.args — OpenCode reads the mutated output object
                 Object.assign(output.args, decision.updatedInput);
             }
-            // "context" action → no-op (OpenCode doesn't support context injection)
+            if (decision.action === "context" && decision.additionalContext) {
+                // Mutate output.args — OpenCode reads the mutated output object
+                output.args.additionalContext = decision.additionalContext;
+            }
         },
         // ── PostToolUse: Session event capture ──────────────
         "tool.execute.after": async (input, output) => {

package/build/routing-block.d.ts

@@ -0,0 +1,8 @@
+import type { ToolNamer } from "./tool-naming.js";
+export interface RoutingBlockOptions {
+    includeCommands?: boolean;
+}
+export declare function createRoutingBlock(t: ToolNamer, options?: RoutingBlockOptions): string;
+export declare function createReadGuidance(t: ToolNamer): string;
+export declare function createGrepGuidance(t: ToolNamer): string;
+export declare function createBashGuidance(t: ToolNamer): string;

package/build/routing-block.js

@@ -0,0 +1,86 @@
+export function createRoutingBlock(t, options = {}) {
+    const { includeCommands = true } = options;
+    return `
+<context_window_protection>
+  <priority_instructions>
+    Raw tool output floods context window. MUST use context-mode MCP tools. Keep raw data in sandbox.
+  </priority_instructions>
+
+  <tool_selection_hierarchy>
+    0. MEMORY: ${t("ctx_search")}(sort: "timeline")
+       - After resume, check prior context before asking user.
+    1. GATHER: ${t("ctx_batch_execute")}(commands, queries)
+       - Primary research tool. Runs commands, auto-indexes, searches. ONE call replaces many steps.
+       - Each command: {label: "section header", command: "shell command"}
+       - label becomes FTS5 chunk title — descriptive labels improve search.
+    2. FOLLOW-UP: ${t("ctx_search")}(queries: ["q1", "q2", ...])
+       - All follow-up questions. ONE call, many queries (default relevance mode).
+    3. PROCESSING: ${t("ctx_execute")}(language, code) | ${t("ctx_execute_file")}(path, language, code)
+       - API calls, log analysis, data processing.
+  </tool_selection_hierarchy>
+
+  <forbidden_actions>
+    - NO Bash for commands producing >20 lines output.
+    - NO Read for analysis — use execute_file. Read IS correct for files you intend to Edit.
+    - NO WebFetch — use ${t("ctx_fetch_and_index")}.
+    - Bash ONLY for git/mkdir/rm/mv/navigation.
+    - NO ${t("ctx_execute")} or ${t("ctx_execute_file")} for file creation/modification.
+      ctx_execute is for analysis, processing, computation only.
+  </forbidden_actions>
+
+  <file_writing_policy>
+    ALWAYS use native Write/Edit tools for file creation/modification.
+    NEVER use ${t("ctx_execute")}, ${t("ctx_execute_file")}, or Bash to write files.
+    Applies to all file types: code, configs, plans, specs, YAML, JSON, markdown.
+  </file_writing_policy>
+
+  <output_constraints>
+    <communication_style>
+      Terse like caveman. Technical substance exact. Only fluff die.
+      Use fragments when clear. Short synonyms (fix not "implement a solution for").
+      Technical terms exact. Code blocks unchanged.
+      Auto-expand for: security warnings, irreversible actions, user confusion.
+    </communication_style>
+    <artifact_policy>
+      Write artifacts (code, configs, PRDs) to FILES. NEVER inline.
+      Return only: file path + 1-line description.
+    </artifact_policy>
+    <response_format>
+      Concise summary:
+      - Actions taken (2-3 bullets)
+      - File paths created/modified
+      - Key findings
+    </response_format>
+  </output_constraints>
+  <session_continuity>
+    Skills, roles, and decisions set during this session remain active until the user revokes them.
+    Do not drop behavioral directives as context grows.
+  </session_continuity>
+${includeCommands ? `
+  <ctx_commands>
+    "ctx stats" | "ctx-stats" | "/ctx-stats" | context savings question
+    → Call stats MCP tool, display full output verbatim.
+
+    "ctx doctor" | "ctx-doctor" | "/ctx-doctor" | diagnose context-mode
+    → Call doctor MCP tool, run returned shell command, display as checklist.
+
+    "ctx upgrade" | "ctx-upgrade" | "/ctx-upgrade" | update context-mode
+    → Call upgrade MCP tool, run returned shell command, display as checklist.
+
+    "ctx purge" | "ctx-purge" | "/ctx-purge" | wipe/reset knowledge base
+    → Call purge MCP tool with confirm: true. Warn: irreversible.
+
+    After /clear or /compact: knowledge base preserved. Tell user: "context-mode knowledge base preserved. Use \`ctx purge\` to start fresh."
+  </ctx_commands>
+` : ''}
+</context_window_protection>`;
+}
+export function createReadGuidance(t) {
+    return '<context_guidance>\n  <tip>\n    Reading to Edit? Read is correct — Edit needs content in context.\n    Reading to analyze/explore? Use ' + t("ctx_execute_file") + '(path, language, code) — only printed summary enters context.\n  </tip>\n</context_guidance>';
+}
+export function createGrepGuidance(t) {
+    return '<context_guidance>\n  <tip>\n    May flood context. Use ' + t("ctx_execute") + '(language: "shell", code: "...") to run searches in sandbox. Only printed summary enters context.\n  </tip>\n</context_guidance>';
+}
+export function createBashGuidance(t) {
+    return '<context_guidance>\n  <tip>\n    May produce large output. Use ' + t("ctx_batch_execute") + '(commands, queries) for multiple commands, ' + t("ctx_execute") + '(language: "shell", code: "...") for single. Only printed summary enters context. Bash only for: git, mkdir, rm, mv, navigation.\n  </tip>\n</context_guidance>';
+}

package/build/tool-naming.d.ts

@@ -0,0 +1,4 @@
+export declare function getToolName(platform: string, bareTool: string): string;
+export type ToolNamer = (bareTool: string) => string;
+export declare function createToolNamer(platform: string): ToolNamer;
+export declare const KNOWN_PLATFORMS: string[];

package/build/tool-naming.js

@@ -0,0 +1,24 @@
+const TOOL_PREFIXES = {
+    "claude-code": (tool) => `mcp__plugin_context-mode_context-mode__${tool}`,
+    "gemini-cli": (tool) => `mcp__context-mode__${tool}`,
+    "antigravity": (tool) => `mcp__context-mode__${tool}`,
+    "opencode": (tool) => `context-mode_${tool}`,
+    "kilo": (tool) => `context-mode_${tool}`,
+    "vscode-copilot": (tool) => `context-mode_${tool}`,
+    "jetbrains-copilot": (tool) => `context-mode_${tool}`,
+    "kiro": (tool) => `@context-mode/${tool}`,
+    "zed": (tool) => `mcp:context-mode:${tool}`,
+    "cursor": (tool) => tool,
+    "codex": (tool) => tool,
+    "openclaw": (tool) => tool,
+    "pi": (tool) => tool,
+    "qwen-code": (tool) => `mcp__context-mode__${tool}`,
+};
+export function getToolName(platform, bareTool) {
+    const fn = TOOL_PREFIXES[platform] || TOOL_PREFIXES["claude-code"];
+    return fn(bareTool);
+}
+export function createToolNamer(platform) {
+    return (bareTool) => getToolName(platform, bareTool);
+}
+export const KNOWN_PLATFORMS = Object.keys(TOOL_PREFIXES);

package/build/util/plugin-cache-integrity.d.ts

@@ -22,6 +22,20 @@
  * (package.json files[]); a missing helper means the install is
  * fundamentally broken.
  */
+/**
+ * Files `start.mjs` needs to launch the MCP server, checked dependency-free
+ * (fs only) so this works even when the integrity helper
+ * (`scripts/plugin-cache-integrity.mjs`) is itself missing — a missing helper
+ * is itself a partial-install symptom, and the operator most needs to know
+ * whether the launch entrypoint survived.
+ *
+ * - `start.mjs` is the plugin `command` target (`.claude-plugin/plugin.json`)
+ *   and has NO fallback: if absent, `node ${CLAUDE_PLUGIN_ROOT}/start.mjs`
+ *   fails immediately and the MCP server never starts.
+ * - The server is loaded by start.mjs from `server.bundle.mjs`, falling back
+ *   to `build/server.js`; it is only "missing" when BOTH are absent.
+ */
+export declare function findMissingLaunchFiles(pluginRoot: string): string[];
 /**
  * Run the integrity check synchronously. If the helper module is
  * still loading (not yet cached) returns a FAIL with detail

package/build/util/plugin-cache-integrity.js

@@ -22,6 +22,8 @@
  * (package.json files[]); a missing helper means the install is
  * fundamentally broken.
  */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 let cached = null;
 let cachedError = null;
 async function loadHelper() {
@@ -67,6 +69,30 @@ async function loadHelper() {
 // intentionally — by the time any HealthCheck.check() runs (doctor
 // command, well after MCP server boot), the import has resolved.
 void loadHelper();
+/**
+ * Files `start.mjs` needs to launch the MCP server, checked dependency-free
+ * (fs only) so this works even when the integrity helper
+ * (`scripts/plugin-cache-integrity.mjs`) is itself missing — a missing helper
+ * is itself a partial-install symptom, and the operator most needs to know
+ * whether the launch entrypoint survived.
+ *
+ * - `start.mjs` is the plugin `command` target (`.claude-plugin/plugin.json`)
+ *   and has NO fallback: if absent, `node ${CLAUDE_PLUGIN_ROOT}/start.mjs`
+ *   fails immediately and the MCP server never starts.
+ * - The server is loaded by start.mjs from `server.bundle.mjs`, falling back
+ *   to `build/server.js`; it is only "missing" when BOTH are absent.
+ */
+export function findMissingLaunchFiles(pluginRoot) {
+    const missing = [];
+    if (!existsSync(join(pluginRoot, "start.mjs"))) {
+        missing.push("start.mjs");
+    }
+    if (!existsSync(join(pluginRoot, "server.bundle.mjs")) &&
+        !existsSync(join(pluginRoot, "build", "server.js"))) {
+        missing.push("server.bundle.mjs (or build/server.js)");
+    }
+    return missing;
+}
 /**
  * Run the integrity check synchronously. If the helper module is
  * still loading (not yet cached) returns a FAIL with detail
@@ -89,6 +115,21 @@ export function checkPluginCacheIntegritySync(pluginRoot) {
         };
     }
     if (cachedError) {
+        // The integrity helper (scripts/plugin-cache-integrity.mjs) ships in
+        // package.json files[]; if it failed to load, the install is already
+        // partial. Don't stop at "helper unavailable" — directly surface whether
+        // the launch entrypoint survived, because a missing start.mjs / server
+        // bundle is exactly what stops the MCP server from starting (and is what
+        // an interrupted /ctx-upgrade swap leaves behind).
+        const launchMissing = findMissingLaunchFiles(pluginRoot);
+        if (launchMissing.length > 0) {
+            return {
+                status: "FAIL",
+                detail: `partial install — critical launch files missing: ${launchMissing.join(", ")} ` +
+                    `(integrity helper also missing: ${cachedError}); the MCP server cannot start. ` +
+                    `Reinstall: npm install -g context-mode@latest`,
+            };
+        }
         return {
             status: "FAIL",
             detail: `integrity helper unavailable: ${cachedError}`,