context-mode 1.0.108 → 1.0.110

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.108",
+  "version": "1.0.110",
   "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/cli.js

@@ -672,21 +672,45 @@ async function upgrade() {
         if (detection.platform !== 'opencode' && detection.platform !== 'kilo') {
             // Rebuild native addons for current Node.js ABI (fixes #131)
             s.start("Rebuilding native addons");
-            try {
-                npmExecFile(["rebuild", "better-sqlite3"], {
-                    cwd: pluginRoot,
-                    stdio: "pipe",
-                    timeout: 60000,
-                });
-                s.stop(color.green("Native addons rebuilt"));
-                changes.push("Rebuilt better-sqlite3 for current Node.js");
+            const bsqBindingPath = resolve(pluginRoot, "node_modules", "better-sqlite3", "build", "Release", "better_sqlite3.node");
+            // Skip rebuild when the binding from `npm install --production` is
+            // already present. Earlier code ran `npm rebuild better-sqlite3`
+            // unconditionally — its internal prebuild-install spawn raced with
+            // the prior install's tree-prune, intermittently failing to resolve
+            // `rc/index.js` and printing a scary "rebuild warning" even though
+            // the binding was healthy. Pre-check eliminates the race for the
+            // 99% case (binding survived install).
+            if (existsSync(bsqBindingPath)) {
+                s.stop(color.green("Native addons OK") + color.dim(" — binding present"));
+                changes.push("better-sqlite3 binding already present (no rebuild needed)");
             }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                s.stop(color.yellow("Native addon rebuild warning"));
-                p.log.warn(color.yellow("better-sqlite3 rebuild issue") +
-                    ` — ${message}` +
-                    color.dim(`\n  Try manually: cd "${pluginRoot}" && npm rebuild better-sqlite3`));
+            else {
+                // Binding actually missing — delegate to the shared 3-layer heal
+                // (scripts/heal-better-sqlite3.mjs, PR #410) instead of raw
+                // `npm rebuild`. Single source of truth across postinstall +
+                // ensure-deps + cli upgrade. Layer A spawns prebuild-install
+                // directly via process.execPath, bypassing PATH/MSVC and the
+                // npm-internal rc-resolution race that bit `npm rebuild`.
+                try {
+                    const healUrl = pathToFileURL(resolve(pluginRoot, "scripts", "heal-better-sqlite3.mjs")).href;
+                    const { healBetterSqlite3Binding } = await import(healUrl);
+                    const result = healBetterSqlite3Binding(pluginRoot);
+                    if (result?.healed) {
+                        s.stop(color.green("Native addons healed") + color.dim(` (${result.reason})`));
+                        changes.push(`Healed better-sqlite3 binding via ${result.reason}`);
+                    }
+                    else {
+                        s.stop(color.yellow("Native addon heal needs manual step"));
+                        p.log.warn(color.dim(`  Run: cd "${pluginRoot}" && npm install better-sqlite3`));
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    s.stop(color.yellow("Native addon heal unavailable"));
+                    p.log.warn(color.yellow("better-sqlite3 heal helper missing") +
+                        ` — ${message}` +
+                        color.dim(`\n  Try manually: cd "${pluginRoot}" && npm rebuild better-sqlite3`));
+                }
             }
         }
         // Update global npm

package/build/opencode-plugin.js

@@ -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/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

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

package/build/session/analytics.js

@@ -332,6 +332,7 @@ export function getLifetimeStats(opts) {
         ?? join(homedir(), ".claude", "projects");
     let totalEvents = 0;
     let totalSessions = 0;
+    const categoryCounts = {};
     // ── SessionDB aggregation ──
     if (existsSync(sessionsDir)) {
         let dbFiles = [];
@@ -358,6 +359,20 @@ export function getLifetimeStats(opts) {
                             const ss = sdb.prepare("SELECT COUNT(*) AS cnt FROM session_meta").get();
                             totalEvents += ev?.cnt ?? 0;
                             totalSessions += ss?.cnt ?? 0;
+                            // Per-category aggregation across every sidecar so the
+                            // Persistent memory bars stay populated even when the
+                            // current project's local DB is fresh / empty.
+                            try {
+                                const catRows = sdb.prepare("SELECT category, COUNT(*) AS cnt FROM session_events GROUP BY category").all();
+                                for (const row of catRows) {
+                                    if (!row.category)
+                                        continue;
+                                    categoryCounts[row.category] = (categoryCounts[row.category] ?? 0) + (row.cnt ?? 0);
+                                }
+                            }
+                            catch {
+                                // older schema / no category column — ignore
+                            }
                         }
                         finally {
                             sdb.close();
@@ -414,6 +429,7 @@ export function getLifetimeStats(opts) {
         autoMemoryCount,
         autoMemoryProjects,
         autoMemoryByPrefix,
+        categoryCounts,
     };
 }
 // ─────────────────────────────────────────────────────────
@@ -503,7 +519,25 @@ function renderProjectMemory(pm, opts) {
     const lifetimeTokens = lifeEvents * 256 + sessionTokensSaved;
     out.push(`  ${fmtNum(lifeEvents)} events · ${sessionLabel} · ~${tokensToUsd(lifetimeTokens)} saved lifetime`);
     out.push("");
-    const cats = pm.by_category;
+    // Prefer lifetime categoryCounts (aggregated across every SessionDB) so
+    // the bar block matches the lifetime header above. Falls back to the
+    // project-local pm.by_category when lifetime data is absent (tests, older
+    // callers) or when no sidecar has any events yet.
+    const lifetimeCats = opts?.lifetime?.categoryCounts;
+    let cats;
+    if (lifetimeCats && Object.keys(lifetimeCats).length > 0) {
+        cats = Object.entries(lifetimeCats)
+            .filter(([, c]) => c > 0)
+            .map(([category, count]) => ({
+            category,
+            count,
+            label: categoryLabels[category] || category,
+        }))
+            .sort((a, b) => b.count - a.count);
+    }
+    else {
+        cats = pm.by_category;
+    }
     const visible = cats.slice(0, topN);
     const maxCount = visible.length > 0 ? visible[0].count : 1;
     for (const cat of visible) {
@@ -529,8 +563,11 @@ function renderAutoMemory(lifetime) {
     const entries = Object.entries(lifetime.autoMemoryByPrefix)
         .sort((a, b) => b[1] - a[1])
         .slice(0, 6);
+    // Top entry sets the bar scale so the visual stays proportional even when
+    // the absolute counts are tiny. Entries are pre-sorted desc.
+    const maxCount = entries.length > 0 ? entries[0][1] : 1;
     for (const [prefix, count] of entries) {
-        out.push(`  ${prefix.padEnd(12)} ${String(count).padStart(2)}`);
+        out.push(`  ${prefix.padEnd(12)} ${String(count).padStart(2)}   ${dataBar(count, maxCount, 20)}`);
     }
     return out;
 }

package/build/session/db.d.ts

@@ -77,7 +77,9 @@ export declare class SessionDB extends SQLiteBase {
      * Eviction: if session exceeds MAX_EVENTS_PER_SESSION, evicts the
      * lowest-priority (then oldest) event.
      */
-    insertEvent(sessionId: string, event: SessionEvent, sourceHook?: string, attribution?: Partial<ProjectAttribution>): void;
+    insertEvent(sessionId: string, event: Omit<SessionEvent, "data_hash"> & {
+        data_hash?: string;
+    }, sourceHook?: string, attribution?: Partial<ProjectAttribution>): void;
     /**
      * Bulk-insert N events in a SINGLE transaction.
      *

package/build/session/persist-tool-calls.d.ts

@@ -0,0 +1,54 @@
+/**
+ * persist-tool-calls — runtime glue between MCP server's in-memory
+ * `sessionStats` and the on-disk `tool_calls` SessionDB table.
+ *
+ * Why this module exists
+ * ──────────────────────
+ * Commit 4742160 (May 2 16:58) added the SessionDB write path so the
+ * statusline counters survived `npm update -g context-mode` and
+ * `claude --continue`. Commit b392c2f (May 2 21:43) — the concurrency
+ * refactor — silently dropped that wiring as collateral. Same-session
+ * `/ctx-upgrade` flips the statusline back to `0 calls / $0.00`
+ * because the new PID starts with an empty `sessionStats` and never
+ * looks at the table the old PID was writing to.
+ *
+ * This module re-introduces the write path AND adds the read-side
+ * restore that 4742160 never shipped — both pure helpers so the
+ * server.ts wiring is a one-liner and the unit tests don't need to
+ * boot the MCP server.
+ */
+/**
+ * Shape returned by {@link restoreSessionStats}. Subset of the in-memory
+ * `sessionStats` object the MCP server keeps — only the fields that can
+ * be recovered from SessionDB.
+ */
+export interface RestoredSessionStats {
+    /** Per-tool call counts. */
+    calls: Record<string, number>;
+    /** Per-tool returned bytes. */
+    bytesReturned: Record<string, number>;
+    /**
+     * Epoch-ms for `session_meta.started_at` of the latest session, so the
+     * statusline `uptime_ms` reflects the original session start instead of
+     * resetting to `Date.now()` on every PID change.
+     */
+    sessionStart: number;
+}
+/**
+ * Increment the persistent tool-call counter for `toolName` under whatever
+ * session_id `session_meta` currently treats as the most recent. This is
+ * called from {@link trackResponse} on every tool response and must be
+ * cheap, non-throwing, and best-effort — a stats failure must never break
+ * the MCP tool call.
+ */
+export declare function persistToolCallCounter(sessionDbPath: string, toolName: string, bytes: number): void;
+/**
+ * Read the latest session's tool-call totals back out of SessionDB so the
+ * MCP server can hydrate its in-memory `sessionStats` on startup. Returns
+ * `null` when the DB is missing or empty so the caller can keep the
+ * default zero-state without branching twice.
+ *
+ * Used during MCP server boot (BEFORE the heartbeat fires) so the
+ * statusline doesn't briefly flash `0 calls / $0.00` after upgrade.
+ */
+export declare function restoreSessionStats(sessionDbPath: string): RestoredSessionStats | null;

package/build/session/persist-tool-calls.js

@@ -0,0 +1,105 @@
+/**
+ * persist-tool-calls — runtime glue between MCP server's in-memory
+ * `sessionStats` and the on-disk `tool_calls` SessionDB table.
+ *
+ * Why this module exists
+ * ──────────────────────
+ * Commit 4742160 (May 2 16:58) added the SessionDB write path so the
+ * statusline counters survived `npm update -g context-mode` and
+ * `claude --continue`. Commit b392c2f (May 2 21:43) — the concurrency
+ * refactor — silently dropped that wiring as collateral. Same-session
+ * `/ctx-upgrade` flips the statusline back to `0 calls / $0.00`
+ * because the new PID starts with an empty `sessionStats` and never
+ * looks at the table the old PID was writing to.
+ *
+ * This module re-introduces the write path AND adds the read-side
+ * restore that 4742160 never shipped — both pure helpers so the
+ * server.ts wiring is a one-liner and the unit tests don't need to
+ * boot the MCP server.
+ */
+import { existsSync } from "node:fs";
+import { SessionDB } from "./db.js";
+/**
+ * Increment the persistent tool-call counter for `toolName` under whatever
+ * session_id `session_meta` currently treats as the most recent. This is
+ * called from {@link trackResponse} on every tool response and must be
+ * cheap, non-throwing, and best-effort — a stats failure must never break
+ * the MCP tool call.
+ */
+export function persistToolCallCounter(sessionDbPath, toolName, bytes) {
+    try {
+        if (!existsSync(sessionDbPath))
+            return;
+        const sdb = new SessionDB({ dbPath: sessionDbPath });
+        try {
+            const sid = sdb.getLatestSessionId();
+            if (!sid)
+                return;
+            sdb.incrementToolCall(sid, toolName, bytes);
+        }
+        finally {
+            sdb.close();
+        }
+    }
+    catch {
+        // Best-effort: counter must never throw and break the parent tool call.
+    }
+}
+/**
+ * Read the latest session's tool-call totals back out of SessionDB so the
+ * MCP server can hydrate its in-memory `sessionStats` on startup. Returns
+ * `null` when the DB is missing or empty so the caller can keep the
+ * default zero-state without branching twice.
+ *
+ * Used during MCP server boot (BEFORE the heartbeat fires) so the
+ * statusline doesn't briefly flash `0 calls / $0.00` after upgrade.
+ */
+export function restoreSessionStats(sessionDbPath) {
+    try {
+        if (!existsSync(sessionDbPath))
+            return null;
+        const sdb = new SessionDB({ dbPath: sessionDbPath });
+        try {
+            const sid = sdb.getLatestSessionId();
+            if (!sid)
+                return null;
+            const stats = sdb.getToolCallStats(sid);
+            const calls = {};
+            const bytesReturned = {};
+            for (const [tool, row] of Object.entries(stats.byTool)) {
+                calls[tool] = row.calls;
+                bytesReturned[tool] = row.bytesReturned;
+            }
+            // started_at is "YYYY-MM-DD HH:MM:SS" in UTC (SQLite datetime() default);
+            // append "Z" so Date.parse interprets it as UTC, matching how the
+            // session was actually persisted.
+            let sessionStart = Date.now();
+            try {
+                const meta = sdb.getSessionStats(sid);
+                if (meta?.started_at) {
+                    const parsed = Date.parse(`${meta.started_at}Z`);
+                    if (Number.isFinite(parsed) && parsed > 0)
+                        sessionStart = parsed;
+                }
+            }
+            catch {
+                // best-effort — keep `Date.now()` fallback
+            }
+            // Skip empty restores so callers can `if (restored)` and not stomp
+            // their already-zero default with another zero.
+            if (Object.keys(calls).length === 0 &&
+                Object.keys(bytesReturned).length === 0) {
+                // Still useful to return sessionStart so uptime_ms doesn't reset
+                // even when no tool calls were made — but only if we found a session.
+                return { calls, bytesReturned, sessionStart };
+            }
+            return { calls, bytesReturned, sessionStart };
+        }
+        finally {
+            sdb.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}

package/build/session/project-attribution.d.ts

@@ -36,7 +36,7 @@ export declare const ATTRIBUTION_CONFIDENCE: {
     /** Fallback: session_origin without path signal */
     readonly FALLBACK_SESSION_ORIGIN: 0.35;
 };
-export type AttributionSource = "event_path" | "cwd_event" | "input_cwd" | "workspace_root" | "last_seen" | "session_origin" | "unknown";
+export type AttributionSource = "event_path" | "cwd_event" | "input_cwd" | "workspace_root" | "last_seen" | "session_origin" | "env" | "test" | "unknown";
 export interface ProjectAttribution {
     projectDir: string;
     source: AttributionSource;