context-mode 1.0.107 → 1.0.109

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.107",
+  "version": "1.0.109",
   "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

@@ -404,7 +404,7 @@ Full configs: [`configs/cursor/hooks.json`](configs/cursor/hooks.json) | [`confi
 
    The `mcp` entry registers all 11 MCP tools. The `plugin` entry enables hooks — OpenCode calls the plugin's TypeScript functions directly before and after each tool execution, blocking dangerous commands and enforcing sandbox routing.
 
-3. *(Optional)* Copy the routing rules file. OpenCode lacks a SessionStart hook, so the model needs an `AGENTS.md` file for routing awareness:
+3. *(Optional)* Copy the routing rules file. The model needs an `AGENTS.md` file for routing awareness:
 
    ```bash
    cp node_modules/context-mode/configs/opencode/AGENTS.md AGENTS.md
@@ -416,9 +416,9 @@ Full configs: [`configs/cursor/hooks.json`](configs/cursor/hooks.json) | [`confi
 
 **Verify:** In the OpenCode session, type `ctx stats`. Context-mode tools should appear and respond.
 
-**Routing:** Hooks enforce routing programmatically via `tool.execute.before` and `tool.execute.after`. The optional [`AGENTS.md`](configs/opencode/AGENTS.md) file provides routing instructions for model awareness. The `experimental.session.compacting` hook builds resume snapshots when the conversation compacts.
+**Routing:** Hooks enforce routing programmatically via `tool.execute.before` and `tool.execute.after`. The optional [`AGENTS.md`](configs/opencode/AGENTS.md) file provides routing instructions for model awareness. The `experimental.session.compacting` hook builds resume snapshots when the conversation compacts. The `experimental.chat.system.transform` hook injects the routing block and prior-session snapshots at session start, enabling session continuity across restarts. The `chat.message` hook captures user prompts and decisions (UserPromptSubmit equivalent).
 
-> **Note:** OpenCode's SessionStart hook is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), so startup/resume session restore is not supported. Compaction recovery works fully via the plugin.
+> **Note:** OpenCode lacks a real SessionStart hook ([#14808](https://github.com/sst/opencode/issues/14808), [#5409](https://github.com/sst/opencode/issues/5409)). The plugin uses `experimental.chat.system.transform` as a surrogate — it injects both the routing block and resume snapshots into the system prompt. User-prompt capture uses `chat.message` instead of the missing UserPromptSubmit hook. AGENTS.md/CLAUDE.md/CONTEXT.md rules are captured automatically on first hook fire per project.
 
 Full configs: [`configs/opencode/opencode.json`](configs/opencode/opencode.json) | [`configs/opencode/AGENTS.md`](configs/opencode/AGENTS.md)
 
@@ -454,7 +454,7 @@ Full configs: [`configs/opencode/opencode.json`](configs/opencode/opencode.json)
 
    The `mcp` entry registers all 11 MCP tools. The `plugin` entry enables hooks — KiloCode calls the plugin's TypeScript functions directly before and after each tool execution, blocking dangerous commands and enforcing sandbox routing.
 
-3. *(Optional)* Copy the routing rules file. KiloCode shares the OpenCode plugin architecture and lacks SessionStart, so the model needs an `AGENTS.md` file for routing awareness:
+3. *(Optional)* Copy the routing rules file. KiloCode shares the OpenCode plugin architecture, so the model needs an `AGENTS.md` file for routing awareness:
 
    ```bash
    cp node_modules/context-mode/configs/opencode/AGENTS.md AGENTS.md
@@ -464,9 +464,9 @@ Full configs: [`configs/opencode/opencode.json`](configs/opencode/opencode.json)
 
 **Verify:** In the KiloCode session, type `ctx stats`. Context-mode tools should appear and respond.
 
-**Routing:** Hooks enforce routing programmatically via `tool.execute.before` and `tool.execute.after`. The optional [`AGENTS.md`](configs/opencode/AGENTS.md) file provides routing instructions for model awareness. The `experimental.session.compacting` hook builds resume snapshots when the conversation compacts.
+**Routing:** Hooks enforce routing programmatically via `tool.execute.before` and `tool.execute.after`. The optional [`AGENTS.md`](configs/opencode/AGENTS.md) file provides routing instructions for model awareness. The `experimental.session.compacting` hook builds resume snapshots when the conversation compacts. The `experimental.chat.system.transform` hook injects the routing block and prior-session snapshots at session start, enabling session continuity across restarts. The `chat.message` hook captures user prompts and decisions (UserPromptSubmit equivalent).
 
-> **Note:** KiloCode shares the same plugin architecture as OpenCode, using the OpenCodeAdapter with platform-specific configuration paths (`kilo.json` instead of `opencode.json`, `~/.config/kilo/` instead of `~/.config/opencode/`). SessionStart hook availability depends on KiloCode's implementation.
+> **Note:** KiloCode shares the same plugin architecture as OpenCode, using the OpenCodeAdapter with platform-specific configuration paths (`kilo.json` instead of `opencode.json`, `~/.config/kilo/` instead of `~/.config/opencode/`). Like OpenCode, it lacks a real SessionStart hook — the plugin uses `experimental.chat.system.transform` as a surrogate. User-prompt capture uses `chat.message` instead of the missing UserPromptSubmit hook. AGENTS.md/CLAUDE.md/CONTEXT.md rules are captured automatically on first hook fire per project.
 
 </details>
 
@@ -817,6 +817,8 @@ Context Mode uses [better-sqlite3](https://github.com/WiseLibs/better-sqlite3) o
 
 On older glibc systems (CentOS 7/8, RHEL 8, Debian 10), prebuilt binaries don't load and better-sqlite3 **automatically falls back to compiling from source** via `prebuild-install || node-gyp rebuild --release`. This requires a C++20 compiler (GCC 10+), Make, and Python with setuptools.
 
+**Windows / missing binding self-heal:** if `better_sqlite3.node` ends up missing after install (e.g. `prebuild-install` not on cmd.exe PATH, no MSVC toolchain), the postinstall script and the runtime hook automatically re-fetch the prebuild and repair the binding — no manual `npm rebuild` needed (#408).
+
 **CentOS 8 / RHEL 8** (glibc 2.28):
 
 ```bash
@@ -919,20 +921,22 @@ This means `--continue` sessions preserve indexed docs across restarts. No re-fe
 
 When the context window fills up, the agent compacts the conversation — dropping older messages to make room. Without session tracking, the model forgets which files it was editing, what tasks are in progress, what errors were resolved, and what you last asked for.
 
-Context Mode captures every meaningful event during your session and persists them in a per-project SQLite database. When the conversation compacts (or you resume with `--continue`), your working state is rebuilt automatically — the model continues from your last prompt without asking you to repeat anything.
+Context Mode captures every meaningful event during your session and persists them in a per-project SQLite database. When the conversation compacts (or you resume with `--continue`, `--resume`, or `/resume`), your working state is rebuilt automatically — the model continues from your last prompt without asking you to repeat anything.
+
+> Resuming a non-latest session via `/resume <picker>` works the same way: the SessionStart hook detects the empty live-event table for the freshly issued session id and falls back to the most recent unconsumed snapshot for the project (`session_resume` table). The picker selects the conversation; context-mode rehydrates the prior working state.
 
-Session continuity requires 4 hooks working together:
+Session continuity requires 5 hooks working together:
 
 | Hook | Role | Claude Code | Gemini CLI | VS Code Copilot | JetBrains Copilot | Cursor | OpenCode | KiloCode | OpenClaw | Codex CLI | Antigravity | Kiro | Zed | Pi |
 |---|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
 | **PreToolUse** | Enforces sandbox routing before tool execution | Yes | -- | -- | -- | Yes | -- | -- | -- | Yes | -- | Yes | -- | ✓ (via tool_call event) |
 | **PostToolUse** | Captures events after each tool call | Yes | Yes | Yes | Yes | Yes | Plugin | Plugin | Plugin | Yes | -- | Yes | -- | ✓ (via tool_result event) |
-| **UserPromptSubmit** | Captures user decisions and corrections | Yes | -- | -- | -- | -- | -- | -- | -- | Yes | -- | -- | -- | -- |
+| **UserPromptSubmit** | Captures user decisions and corrections | Yes | -- | -- | -- | -- | Plugin (via chat.message) | Plugin (via chat.message) | -- | Yes | -- | -- | -- | -- |
 | **PreCompact** | Builds snapshot before compaction | Yes | Yes | Yes | Yes | -- | Plugin | Plugin | Plugin | -- | -- | -- | -- | ✓ (via session_before_compact) |
-| **SessionStart** | Restores state after compaction or resume | Yes | Yes | Yes | Yes | -- | -- | -- | Plugin | Yes | -- | -- | -- | ✓ (via session_start event) |
-| | **Session completeness** | **Full** | **High** | **High** | **High** | **Partial** | **High** | **High** | **High** | **Partial** | **--** | **Partial** | **--** | **High** |
+| **SessionStart** | Restores state after compaction or resume | Yes | Yes | Yes | Yes | -- | ✓ (via experimental.chat.system.transform) | ✓ (via experimental.chat.system.transform) | Plugin | Yes | -- | -- | -- | ✓ (via session_start event) |
+| | **Session completeness** | **Full** | **High** | **High** | **High** | **Partial** | **Full** | **Full** | **High** | **Partial** | **--** | **Partial** | **--** | **High** |
 
-> **Note:** Full session continuity (capture + snapshot + restore) works on **Claude Code**, **Gemini CLI**, **VS Code Copilot**, and **JetBrains Copilot**. **OpenCode** provides **high** session continuity: it captures tool events and injects compaction snapshots via the plugin, but SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), so startup/resume restore is not supported. **KiloCode** shares the same plugin architecture as OpenCode via the OpenCodeAdapter, so its continuity level depends on KiloCode's SessionStart support. **Cursor** captures tool events via `preToolUse`/`postToolUse`, but `sessionStart` is currently rejected by Cursor's validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)), so session restore after compaction is not available yet. **OpenClaw** uses native gateway plugin hooks (`api.on()`) for full session continuity. **Pi Coding Agent** provides high session continuity via extension hooks (`tool_call`, `tool_result`, `session_start`, `session_before_compact`). **Codex CLI** provides partial hook-based session tracking through PreToolUse, PostToolUse, SessionStart, UserPromptSubmit, and Stop; MCP tools work. **Antigravity**, **Kiro**, and **Zed** have no hook support in the current release, so session tracking is not available.
+> **Note:** Full session continuity (capture + snapshot + restore) works on **Claude Code**, **Gemini CLI**, **VS Code Copilot**, **JetBrains Copilot**, **OpenCode**, and **KiloCode**. **OpenCode** and **KiloCode** use `experimental.chat.system.transform` as a SessionStart surrogate to inject the routing block and restore prior sessions, plus `chat.message` for user-prompt capture; full SessionStart hook support is not yet available ([#14808](https://github.com/sst/opencode/issues/14808), [#5409](https://github.com/sst/opencode/issues/5409)), but prior-session continuity and user-decision capture work fully. **Cursor** captures tool events via `preToolUse`/`postToolUse`, but `sessionStart` is currently rejected by Cursor's validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)), so session restore after compaction is not available yet. **OpenClaw** uses native gateway plugin hooks (`api.on()`) for full session continuity. **Pi Coding Agent** provides high session continuity via extension hooks (`tool_call`, `tool_result`, `session_start`, `session_before_compact`). **Codex CLI** provides partial hook-based session tracking through PreToolUse, PostToolUse, SessionStart, UserPromptSubmit, and Stop; MCP tools work. **Antigravity**, **Kiro**, and **Zed** have no hook support in the current release, so session tracking is not available.
 
 <details>
 <summary><strong>What gets captured</strong></summary>
@@ -1015,7 +1019,7 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `ctx_s
 <details>
 <summary><strong>Per-platform details</strong></summary>
 
-**Claude Code** — Full session support. All 5 hook types fire, capturing tool events, user decisions, building compaction snapshots, and restoring state after compaction or `--continue`.
+**Claude Code** — Full session support. All 5 hook types fire, capturing tool events, user decisions, building compaction snapshots, and restoring state after compaction, `--continue`, `--resume`, or `/resume`.
 
 **Gemini CLI** — High coverage. PostToolUse (AfterTool), PreCompact (PreCompress), and SessionStart all fire. Missing UserPromptSubmit, so user decisions and corrections aren't captured — but file edits, git ops, errors, and tasks are fully tracked.
 
@@ -1025,9 +1029,9 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `ctx_s
 
 **Cursor** — Partial coverage. Native `preToolUse` and `postToolUse` hooks capture tool events. `sessionStart` is documented by Cursor but currently rejected by their validator, so session restore is not available. Routing instructions are delivered via MCP server startup instead.
 
-**OpenCode** — Partial. The TypeScript plugin captures PostToolUse events via `tool.execute.after`, but SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)). Events are stored but not automatically restored after compaction.
+**OpenCode** — Full session support. The TypeScript plugin captures PostToolUse events via `tool.execute.after`, user prompts and decisions via `chat.message`, builds compaction snapshots via `experimental.session.compacting`, and restores prior sessions via `experimental.chat.system.transform` (SessionStart surrogate). Routing block is injected on first `chat.system.transform` per session. AGENTS.md/CLAUDE.md/CONTEXT.md rules are captured automatically on first hook fire.
 
-**KiloCode** — Partial. Shares the same plugin architecture as OpenCode via the OpenCodeAdapter. The TypeScript plugin captures PostToolUse events via `tool.execute.after`, but SessionStart availability depends on KiloCode's implementation. Events are stored but may not be automatically restored after compaction.
+**KiloCode** — Full session support. Shares the same plugin architecture as OpenCode via the OpenCodeAdapter. The TypeScript plugin captures PostToolUse events via `tool.execute.after`, user prompts and decisions via `chat.message`, builds compaction snapshots via `experimental.session.compacting`, and restores prior sessions via `experimental.chat.system.transform` (SessionStart surrogate).
 
 **OpenClaw / Pi Agent** — High coverage. All tool lifecycle hooks (`after_tool_call`, `before_compaction`, `session_start`) fire via the native gateway plugin. User decisions aren't captured but file edits, git ops, errors, and tasks are fully tracked. Falls back to DB snapshot reconstruction if compaction hooks fail on older gateway versions. See [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md).
 
@@ -1050,7 +1054,7 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `ctx_s
 | MCP Server | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
 | PreToolUse Hook | Yes | Yes | Yes | Yes | Yes | Yes | Plugin | Plugin | Plugin | Yes | -- | Yes | -- | Yes (extension) |
 | PostToolUse Hook | Yes | Yes | Yes | Yes | Yes | Yes | Plugin | Plugin | Plugin | Yes | -- | Yes | -- | Yes (extension) |
-| SessionStart Hook | Yes | Yes | Yes | Yes | Yes | -- | -- | -- | Plugin | Yes | -- | -- | -- | Yes (extension) |
+| SessionStart Hook | Yes | Yes | Yes | Yes | Yes | -- | ✓ (via experimental.chat.system.transform) | ✓ (via experimental.chat.system.transform) | Plugin | Yes | -- | -- | -- | Yes (extension) |
 | PreCompact Hook | Yes | Yes | Yes | Yes | Yes | -- | Plugin | Plugin | Plugin | -- | -- | -- | -- | Yes (extension) |
 | Can Modify Args | Yes | Yes | Yes | Yes | Yes | Yes | Plugin | Plugin | Plugin | -- | -- | -- | -- | Yes (extension) |
 | Can Block Tools | Yes | Yes | Yes | Yes | Yes | Yes | Plugin | Plugin | Plugin | Yes | -- | Yes | -- | Yes (extension) |
@@ -1058,9 +1062,9 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `ctx_s
 | Slash Commands | Yes | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- |
 | Plugin Marketplace | Yes | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- |
 
-> **OpenCode** uses a TypeScript plugin paradigm — hooks run as in-process functions via `tool.execute.before`, `tool.execute.after`, and `experimental.session.compacting`, providing the same routing enforcement and session continuity as shell-based hooks. SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), but compaction recovery works via the plugin's compacting hook.
+> **OpenCode** uses a TypeScript plugin paradigm — hooks run as in-process functions via `tool.execute.before`, `tool.execute.after`, `experimental.session.compacting`, `experimental.chat.system.transform`, and `chat.message`, providing full routing enforcement, session continuity, and user-prompt capture. The `experimental.chat.system.transform` hook acts as a SessionStart surrogate to inject the routing block and restore prior sessions. The `chat.message` hook captures user prompts and decisions (UserPromptSubmit equivalent).
 >
-> **KiloCode** shares the same TypeScript plugin architecture as OpenCode via the OpenCodeAdapter, with platform-specific configuration paths (`kilo.json` instead of `opencode.json`, `~/.config/kilo/` instead of `~/.config/opencode/`). Hook capabilities depend on KiloCode's implementation of the plugin interface.
+> **KiloCode** shares the same TypeScript plugin architecture as OpenCode via the OpenCodeAdapter, with platform-specific configuration paths (`kilo.json` instead of `opencode.json`, `~/.config/kilo/` instead of `~/.config/opencode/`). Hook capabilities match OpenCode, including SessionStart surrogate via `experimental.chat.system.transform` and user-prompt capture via `chat.message`.
 >
 > **OpenClaw** runs context-mode as a native gateway plugin targeting Pi Agent sessions. Hooks register via `api.on()` (tool/lifecycle) and `api.registerHook()` (commands). All tool interception and compaction hooks are supported. See [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md).
 >

package/build/adapters/claude-code/index.js

@@ -308,19 +308,36 @@ export class ClaudeCodeAdapter extends ClaudeCodeBaseAdapter {
         if (pluginHooks) {
             const allCovered = REQUIRED_HOOKS.every((ht) => this.checkHookType(undefined, pluginHooks, ht));
             if (allCovered) {
-                // Remove ALL existing context-mode hooks from settings.json — hooks.json
-                // is the source of truth. Keeping them causes duplicate concurrent hook
-                // processes (one from settings.json, one from hooks.json), which triggers
-                // "non-blocking hook error" warnings on every tool call.
+                // Strip ONLY the inner context-mode hook commands from each matcher entry —
+                // hooks.json is the source of truth for ctx-mode. User hooks co-located in
+                // the same matcher entry MUST be preserved (#415: entry-level filter wiped
+                // every co-located user hook). After stripping, prune entries whose `hooks`
+                // array becomes empty.
+                const ctxScriptNames = Object.values(HOOK_SCRIPTS);
+                const isCtxModeCommand = (cmd) => cmd != null &&
+                    (ctxScriptNames.some((s) => cmd.includes(s)) ||
+                        cmd.includes("context-mode hook"));
                 for (const hookType of Object.keys(hooks)) {
                     const entries = hooks[hookType];
                     if (!Array.isArray(entries))
                         continue;
-                    const filtered = entries.filter((entry) => !isAnyContextModeHook(entry));
-                    const removed = entries.length - filtered.length;
-                    if (removed > 0) {
-                        hooks[hookType] = filtered;
-                        changes.push(`Removed ${removed} duplicate ${hookType} hook(s) — covered by plugin hooks.json`);
+                    let totalRemoved = 0;
+                    for (const entry of entries) {
+                        const typedEntry = entry;
+                        const innerHooks = typedEntry.hooks ?? [];
+                        const before = innerHooks.length;
+                        typedEntry.hooks = innerHooks.filter((h) => !isCtxModeCommand(h.command));
+                        totalRemoved += before - typedEntry.hooks.length;
+                    }
+                    const pruned = entries.filter((e) => {
+                        const ih = e.hooks;
+                        return Array.isArray(ih) && ih.length > 0;
+                    });
+                    if (totalRemoved > 0 || pruned.length !== entries.length) {
+                        hooks[hookType] = pruned;
+                        if (totalRemoved > 0) {
+                            changes.push(`Removed ${totalRemoved} duplicate ${hookType} hook(s) — covered by plugin hooks.json`);
+                        }
                     }
                 }
                 settings.hooks = hooks;

package/build/adapters/opencode/index.js

@@ -40,10 +40,10 @@ export class OpenCodeAdapter extends BaseAdapter {
         preToolUse: true,
         postToolUse: true,
         preCompact: true, // experimental
-        sessionStart: false,
+        sessionStart: true,
         canModifyArgs: true,
         canModifyOutput: true, // with TUI bug caveat for bash (#13575)
-        canInjectSessionContext: false,
+        canInjectSessionContext: true,
     };
     platform;
     constructor(platform = "opencode") {
@@ -310,11 +310,11 @@ export class OpenCodeAdapter extends BaseAdapter {
                 fix: "context-mode upgrade",
             });
         }
-        // Warn about SessionStart limitation
+        // Note: SessionStart handled via experimental.chat.system.transform surrogate
         results.push({
             check: "SessionStart hook",
-            status: "warn",
-            message: `SessionStart not supported in ${this.name} (see issues #14808, #5409)`,
+            status: "pass",
+            message: `SessionStart via experimental.chat.system.transform surrogate (native hook pending #14808, #5409)`,
         });
         return results;
     }

package/build/cli.js

@@ -382,9 +382,26 @@ async function doctor() {
         }
         else {
             criticalFails++;
-            p.log.error(color.red("FTS5 / better-sqlite3: FAIL") +
-                ` — ${message}` +
-                color.dim("\n  Try: npm rebuild better-sqlite3"));
+            // Detect better-sqlite3 native bindings-missing pattern (issue #408).
+            // The `bindings` package throws "Could not locate the bindings file"
+            // when better_sqlite3.node failed to install — typical on Windows
+            // when prebuild-install was not on PATH so install fell through to
+            // node-gyp without an MSVC toolchain.
+            const isBindingsMissing = /Could not locate the bindings file/i.test(message) ||
+                /bindings\.node/i.test(message) ||
+                /\bbindings\b/i.test(message);
+            if (isBindingsMissing && process.platform === "win32") {
+                p.log.error(color.red("FTS5 / better-sqlite3: FAIL") +
+                    ` — ${message}` +
+                    color.dim("\n  Root cause: prebuild-install was likely not on PATH, so install fell through to node-gyp without an MSVC toolchain (Windows)." +
+                        "\n  Try (primary): npm install better-sqlite3   # re-resolves the dep tree and re-links the prebuild-install bin shim to fetch a prebuilt binary" +
+                        "\n  Try (fallback): npm rebuild better-sqlite3"));
+            }
+            else {
+                p.log.error(color.red("FTS5 / better-sqlite3: FAIL") +
+                    ` — ${message}` +
+                    color.dim("\n  Try: npm rebuild better-sqlite3"));
+            }
         }
     }
     // Version check — adapter-aware
@@ -545,6 +562,36 @@ async function upgrade() {
     let pluginRoot = getPluginRoot();
     const changes = [];
     const s = p.spinner();
+    // Step 0: Sync the marketplace clone (#418).
+    // Claude Code reads plugin metadata from ~/.claude/plugins/marketplaces/context-mode/.
+    // Without a git pull there, the marketplace stays pinned at the install-time
+    // commit and CC keeps reporting the old version even after our cache dir is
+    // updated — users then see "ctx-upgrade succeeded" but nothing actually
+    // changed at the plugin-system level.
+    const marketplaceDir = resolve(homedir(), ".claude", "plugins", "marketplaces", "context-mode");
+    if (existsSync(join(marketplaceDir, ".git"))) {
+        s.start("Syncing marketplace clone");
+        try {
+            // Preserve user dev edits (Mert-class users symlink the clone to a worktree).
+            const statusOut = execFileSync("git", ["-C", marketplaceDir, "status", "--porcelain"], { stdio: "pipe", encoding: "utf-8", timeout: 5000 });
+            if (statusOut.trim()) {
+                s.stop(color.yellow("Marketplace clone has local edits — skipping git pull"));
+                p.log.info(color.dim(`  Run manually: git -C "${marketplaceDir}" stash && git pull --ff-only`));
+            }
+            else {
+                execFileSync("git", ["-C", marketplaceDir, "fetch", "--tags", "origin"], { stdio: "pipe", timeout: 30000 });
+                execFileSync("git", ["-C", marketplaceDir, "reset", "--hard", "origin/HEAD"], { stdio: "pipe", timeout: 10000 });
+                s.stop(color.green("Marketplace clone synced"));
+                changes.push("Marketplace clone updated to upstream");
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            s.stop(color.yellow("Marketplace sync skipped"));
+            p.log.warn(color.yellow("git refresh on marketplace failed") + ` — ${message}`);
+            p.log.info(color.dim("  Continuing — cache dir update will still happen."));
+        }
+    }
     // Step 1: Pull latest from GitHub
     p.log.step("Pulling latest from GitHub...");
     const localVersion = getLocalVersion();
@@ -596,12 +643,16 @@ async function upgrade() {
             }
             catch { /* some files may not exist in source */ }
         }
-        // Write .mcp.json with resolved absolute path (fixes #132)
+        // Write .mcp.json with CLAUDE_PLUGIN_ROOT placeholder (fixes #411).
+        // Absolute paths bake-in the current pluginRoot dir, which sessionstart.mjs
+        // (#181) deletes after upgrade — breaking MCP server resolution. The literal
+        // ${CLAUDE_PLUGIN_ROOT} placeholder is resolved by Claude at load-time and
+        // stays valid across version cleanups. Matches .claude-plugin/plugin.json.
         const mcpConfig = {
             mcpServers: {
                 "context-mode": {
                     command: "node",
-                    args: [resolve(pluginRoot, "start.mjs")],
+                    args: ["${CLAUDE_PLUGIN_ROOT}/start.mjs"],
                 },
             },
         };
@@ -773,14 +824,43 @@ async function upgrade() {
  * statusline — forward to bin/statusline.mjs
  * ------------------------------------------------------- */
 function statuslineForward() {
-    const scriptPath = resolve(getPluginRoot(), "bin", "statusline.mjs");
-    if (!existsSync(scriptPath)) {
-        process.stderr.write(`statusline script missing: ${scriptPath}\n`);
-        process.exit(1);
+    // Try multiple plugin-root candidates in priority order. After ctx-upgrade,
+    // getPluginRoot() can resolve to a cache dir that sessionstart.mjs (#181)
+    // already cleaned, leaving bin/statusline.mjs missing. Falling back to the
+    // marketplace clone (#418-synced, stable across upgrades) and to the path
+    // Claude Code itself loads from (installed_plugins.json) keeps the bar
+    // alive instead of silently going blank.
+    const candidates = [
+        resolve(getPluginRoot(), "bin", "statusline.mjs"),
+        resolve(homedir(), ".claude", "plugins", "marketplaces", "context-mode", "bin", "statusline.mjs"),
+    ];
+    // installed_plugins.json may list one or more install paths CC actually
+    // loads from. Prefer those if they exist.
+    try {
+        const registryPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+        if (existsSync(registryPath)) {
+            const registry = JSON.parse(readFileSync(registryPath, "utf-8"));
+            const entries = registry?.plugins?.["context-mode@context-mode"];
+            if (Array.isArray(entries)) {
+                for (const entry of entries) {
+                    const installPath = entry?.installPath;
+                    if (typeof installPath === "string" && installPath) {
+                        candidates.push(resolve(installPath, "bin", "statusline.mjs"));
+                    }
+                }
+            }
+        }
+    }
+    catch { /* registry malformed — fall through to other candidates */ }
+    const scriptPath = candidates.find((c) => existsSync(c));
+    if (!scriptPath) {
+        // Statusline output is the user-facing status bar; stderr surfaces visibly
+        // in some terminals. Exit silently — the bar simply stays empty until the
+        // next /ctx-upgrade or restart resolves the path.
+        process.exit(0);
     }
     // Re-exec via dynamic import so stdin/stdout are inherited cleanly.
-    import(pathToFileURL(scriptPath).href).catch((err) => {
-        process.stderr.write(`statusline failed: ${err?.message ?? err}\n`);
-        process.exit(1);
+    import(pathToFileURL(scriptPath).href).catch(() => {
+        process.exit(0);
     });
 }

package/build/server.js

@@ -19,6 +19,7 @@ import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime
 import { classifyNonZeroExit } from "./exit-classify.js";
 import { startLifecycleGuard } from "./lifecycle.js";
 import { getWorktreeSuffix, SessionDB } from "./session/db.js";
+import { persistToolCallCounter, restoreSessionStats } from "./session/persist-tool-calls.js";
 import { searchAllSources } from "./search/unified.js";
 import { buildNodeCommand } from "./adapters/types.js";
 import { detectPlatform, getSessionDirSegments } from "./adapters/detect.js";
@@ -169,6 +170,15 @@ function hashProjectDir() {
     const normalized = projectDir.replace(/\\/g, "/");
     return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
 }
+/**
+ * Resolve the per-project SessionDB path the way 4742160 originally did
+ * for `persistToolCallCounter`. Centralized so the write-back, the
+ * restore-on-startup, and any future SessionDB consumer all hash to the
+ * same file under worktree isolation.
+ */
+function getSessionDbPath() {
+    return join(getSessionDir(), `${hashProjectDir()}${getWorktreeSuffix()}.db`);
+}
 /**
  * Compute a per-project, per-platform persistent path for the ContentStore.
  * Derives content dir from the adapter's session dir so each platform
@@ -351,10 +361,13 @@ function trackResponse(toolName, response) {
     // Persist a sidecar JSON snapshot for the statusline — read at ~3-5 Hz by
     // bin/statusline.mjs (and any external dashboard) so they don't have to
     // open the SQLite database. Throttled inside persistStats() (500ms) so
-    // it's safe to call on every response. The b392c2f concurrency refactor
-    // dropped the SessionDB tool-call counter (`persistToolCallCounter`); we
-    // keep persistStats here because the statusline depends on it.
+    // it's safe to call on every response.
     persistStats();
+    // Persist to SessionDB so counters survive process restart, --continue,
+    // upgrade. Re-introduces the write path 4742160 added and b392c2f dropped.
+    // setImmediate keeps this off the response hot path; the helper itself
+    // is best-effort (never throws).
+    setImmediate(() => persistToolCallCounter(getSessionDbPath(), toolName, bytes));
     return response;
 }
 function trackIndexed(bytes) {
@@ -2823,6 +2836,28 @@ async function main() {
         }
     }
     catch { /* best effort — _detectedAdapter stays null, falls back to .claude */ }
+    // Restore tool-call counters from SessionDB BEFORE the heartbeat fires
+    // so the very first persistStats() carries the prior PID's totals into
+    // the sidecar JSON the statusline reads. Otherwise `/ctx-upgrade` flashes
+    // `0 calls / $0.00` until the user makes another MCP tool call. Wrapped
+    // in try/catch — a stats-restore failure must never block server startup.
+    try {
+        const restored = restoreSessionStats(getSessionDbPath());
+        if (restored) {
+            for (const [tool, count] of Object.entries(restored.calls)) {
+                sessionStats.calls[tool] = count;
+            }
+            for (const [tool, bytes] of Object.entries(restored.bytesReturned)) {
+                sessionStats.bytesReturned[tool] = bytes;
+            }
+            // Anchor uptime_ms to the original session start so `/ctx-upgrade`
+            // doesn't reset the "session age" the statusline shows.
+            if (restored.sessionStart > 0) {
+                sessionStats.sessionStart = restored.sessionStart;
+            }
+        }
+    }
+    catch { /* best effort — never block startup on a stats restore failure */ }
     // Non-blocking version check — result stored for trackResponse warnings.
     // First fetch at startup, then refresh every hour so long-running sessions
     // (some users keep the MCP server alive 24h+) catch new releases without a
@@ -2834,6 +2869,13 @@ async function main() {
         fetchLatestVersion().then(v => { if (v !== "unknown")
             _latestVersion = v; });
     }, 60 * 60 * 1000).unref();
+    // Stats heartbeat — keep the statusline truthful while the user works in
+    // tools other than MCP (Bash/Read/Edit during long sessions or post-/compact
+    // pauses). Without this, stats.updated_at only advances on MCP tool calls,
+    // so bin/statusline.mjs falsely flips to "stale — restart to resume saving"
+    // even though the server is alive. Heartbeat refreshes updated_at every 60s;
+    // statusline staleness threshold is 30min (cliff is 30 missed ticks away).
+    setInterval(() => persistStats(), 60_000).unref();
     console.error(`Context Mode MCP server v${VERSION} running on stdio`);
     console.error(`Detected runtimes:\n${getRuntimeSummary(runtimes)}`);
     if (!hasBunRuntime()) {

package/build/session/analytics.d.ts

@@ -185,6 +185,13 @@ export interface LifetimeStats {
     autoMemoryProjects: number;
     /** Per-prefix breakdown of auto-memory files (user/feedback/project/...). */
     autoMemoryByPrefix: Record<string, number>;
+    /**
+     * Per-category event counts aggregated across every SessionDB on disk.
+     * Keys are the raw category strings (file/cwd/rule/...) — the renderer
+     * looks them up against `categoryLabels` for display. Empty `{}` when no
+     * sidecar has any events. Optional for back-compat with older fixtures.
+     */
+    categoryCounts: Record<string, number>;
 }
 /**
  * Aggregate lifetime stats from all SessionDB files in `sessionsDir` and