context-mode 1.0.129 → 1.0.131

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.129",
+  "version": "1.0.131",
   "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/db-base.d.ts

@@ -139,6 +139,26 @@ export declare function isSQLiteCorruptionError(msg: string): boolean;
 export declare function renameCorruptDB(dbPath: string): void;
 export declare abstract class SQLiteBase {
     #private;
+    /**
+     * Open (or create) a SQLite DB at `dbPath`.
+     *
+     * v1.0.130 — multi-writer is the contract. ALL SQLiteBase consumers
+     * (SessionDB, ContentStore) may open the same on-disk dbPath from
+     * multiple processes simultaneously — that is the legitimate multi-
+     * window UX shape and the WAL handles it natively. SQLITE_BUSY on
+     * write contention is absorbed by `withRetry()` below (busy_timeout
+     * = 30000ms inside `new Database(...)`).
+     *
+     * v1.0.128 introduced a single-writer guard here as a defense against
+     * #560. That defense was an over-correction — the actual root causes
+     * of #560 were #559 (zombie MCP child accumulation) and #561 (Pi
+     * misdetection writing to the wrong DB path), both fixed in v1.0.128
+     * + v1.0.129. The single-writer guard broke legitimate multi-window
+     * users; v1.0.130 rolls it out. See
+     * docs/adr/0001-sessiondb-multi-writer.md and the v1.0.130 INVARIANT
+     * block in tests/util/db-base-platform-gate.test.ts for the
+     * regression-proof anchor (source-pin + behavioural).
+     */
     constructor(dbPath: string);
     /** Called once after WAL pragmas are applied. Subclasses run CREATE TABLE/VIRTUAL TABLE here. */
     protected abstract initSchema(): void;

package/build/db-base.js

@@ -9,12 +9,6 @@ import { createRequire } from "node:module";
 import { existsSync, unlinkSync, renameSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-// v1.0.128 — Issue #560 single-writer enforcement.
-// Lockfile is the PRIMARY defense (clean UX with conflicting PID),
-// `locking_mode = EXCLUSIVE` (applied in applyWALPragmas below) is the
-// SECONDARY defense for the narrow race window between lockfile claim
-// and the actual `new Database(...)` open. Both skip-gate on tmpdir paths.
-import { acquireDbLock, releaseDbLock } from "./util/db-lock.js";
 // ─────────────────────────────────────────────────────────
 // bun:sqlite adapter (#45)
 // ─────────────────────────────────────────────────────────
@@ -317,14 +311,12 @@ export function applyWALPragmas(db) {
     }
     catch { /* unsupported runtime */ }
     // NOTE: `locking_mode = EXCLUSIVE` is intentionally NOT applied here.
-    // Multi-writer scenarios are valid: `ContentStore` (FTS5 shared
-    // knowledge base) is opened concurrently from multiple sessions on the
-    // SAME db file by design — applying EXCLUSIVE here would deadlock the
-    // second instance and break documented `withRetry`-based BUSY handling.
-    // Single-writer enforcement (lockfile + EXCLUSIVE) lives in
-    // `SQLiteBase` ctor which is opted into by per-project DBs (SessionDB).
-    // Different DB paths from different worktrees/sessions ARE concurrent
-    // by design — the lockfile is per-dbPath, not per-process.
+    // ALL DBs built on this helper — ContentStore (FTS5 shared knowledge
+    // base) AND SessionDB (per-project events) — are multi-writer-safe by
+    // contract. WAL + busy_timeout + the withRetry() wrapper below handle
+    // SQLITE_BUSY natively. EXCLUSIVE locking is opt-out, never opt-in
+    // from a base class shared by multi-writer consumers.
+    // See docs/adr/0001-sessiondb-multi-writer.md for the v1.0.130 ADR.
 }
 // ─────────────────────────────────────────────────────────
 // DB file helpers
@@ -465,26 +457,19 @@ export function renameCorruptDB(dbPath) {
  * re-imports within the same fork process (ESM isolate mode clears
  * module-level state but globalThis persists).
  */
-// v1.0.128 — symbol name versioned because the value type changed from
-// Set<DatabaseInstance> to Map<DatabaseInstance, string> (issue #560).
-// A persistent global slot from a pre-v128 module would deserialize as
-// the wrong shape and crash the exit hook iteration.
-const _kLiveDBs = Symbol.for("__context_mode_live_dbs_v2__");
-// v1.0.128 — issue #560: pair each DatabaseInstance with the dbPath that
-// owns its lockfile. The exit hook needs both — closeDB(db) handles the
-// WAL checkpoint, releaseDbLock(dbPath) drops the .lock file. We use a
-// Map keyed by DatabaseInstance to keep API call sites unchanged.
+// v1.0.130 — symbol name bumped because the value type reverted from
+// Map<DatabaseInstance, string> (v1.0.128 lockfile pairing) back to
+// Set<DatabaseInstance>. A persistent global slot from a v1.0.128 or
+// v1.0.129 module would deserialize as the wrong shape and crash the
+// exit hook iteration.
+const _kLiveDBs = Symbol.for("__context_mode_live_dbs_v3__");
 const _liveDBs = (() => {
     const g = globalThis;
     if (!g[_kLiveDBs]) {
-        g[_kLiveDBs] = new Map();
+        g[_kLiveDBs] = new Set();
         process.on("exit", () => {
-            for (const [db, dbPath] of g[_kLiveDBs]) {
+            for (const db of g[_kLiveDBs]) {
                 closeDB(db);
-                // Release lock AFTER close so the WAL checkpoint inside closeDB
-                // runs while we still own the writer slot (no second-opener can
-                // race in mid-checkpoint).
-                releaseDbLock({ dbPath });
             }
             g[_kLiveDBs].clear();
         });
@@ -494,45 +479,34 @@ const _liveDBs = (() => {
 export class SQLiteBase {
     #dbPath;
     #db;
+    /**
+     * Open (or create) a SQLite DB at `dbPath`.
+     *
+     * v1.0.130 — multi-writer is the contract. ALL SQLiteBase consumers
+     * (SessionDB, ContentStore) may open the same on-disk dbPath from
+     * multiple processes simultaneously — that is the legitimate multi-
+     * window UX shape and the WAL handles it natively. SQLITE_BUSY on
+     * write contention is absorbed by `withRetry()` below (busy_timeout
+     * = 30000ms inside `new Database(...)`).
+     *
+     * v1.0.128 introduced a single-writer guard here as a defense against
+     * #560. That defense was an over-correction — the actual root causes
+     * of #560 were #559 (zombie MCP child accumulation) and #561 (Pi
+     * misdetection writing to the wrong DB path), both fixed in v1.0.128
+     * + v1.0.129. The single-writer guard broke legitimate multi-window
+     * users; v1.0.130 rolls it out. See
+     * docs/adr/0001-sessiondb-multi-writer.md and the v1.0.130 INVARIANT
+     * block in tests/util/db-base-platform-gate.test.ts for the
+     * regression-proof anchor (source-pin + behavioural).
+     */
     constructor(dbPath) {
         const Database = loadDatabase();
         this.#dbPath = dbPath;
-        // v1.0.128 — Issue #560 PRIMARY single-writer guard. Must claim
-        // BEFORE `new Database(...)` so a contending opener gets the clean
-        // DatabaseLockedError UX (PID + verbatim message) instead of the
-        // SQLITE_BUSY surfaced by EXCLUSIVE locking. Skip-gate via
-        // tmpdir-prefix check inside the helper — defaultDBPath() output
-        // (per-process tmp DBs) does not contend, so it never claims a lock.
-        acquireDbLock({ dbPath });
-        // v1.0.129 — single source of truth for skip decision. Both lockfile
-        // (above) and EXCLUSIVE pragma (below) MUST share the same skip-gate:
-        // tests open SessionDB twice on the same tmpdir path to exercise
-        // multi-writer scenarios; if EXCLUSIVE fires here when lockfile didn't,
-        // the second open hits SQLITE_BUSY on its FIRST pragma call inside
-        // applyWALPragmas — caused 82 test failures during v1.0.128 verification.
-        const skipExclusive = dbPath.startsWith(tmpdir());
         cleanOrphanedWALFiles(dbPath);
         let db;
         try {
             db = new Database(dbPath, { timeout: 30000 });
             applyWALPragmas(db);
-            // v1.0.128 — Issue #560 SECONDARY defense for SQLiteBase callers (single-writer
-            // DBs like SessionDB). The .lock file (acquireDbLock above) is PRIMARY — it
-            // surfaces the conflicting PID with a clear UX message. EXCLUSIVE locking
-            // closes the narrow race window between lockfile claim + the actual
-            // `new Database(...)` open: a parallel process passing the lockfile
-            // check would still get SQLITE_BUSY from this pragma. Wrapped in try/catch —
-            // backends that don't expose locking_mode (or pragma at all) still get the
-            // lockfile floor. NOTE: NOT applied in `applyWALPragmas` because multi-writer
-            // callers (ContentStore — FTS5 shared knowledge base across sessions) rely
-            // on the default SHARED locking mode + withRetry to handle SQLITE_BUSY.
-            // Skip on tmpdir paths to match acquireDbLock's skip-gate.
-            if (!skipExclusive) {
-                try {
-                    db.pragma("locking_mode = EXCLUSIVE");
-                }
-                catch { /* unsupported runtime */ }
-            }
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -542,27 +516,17 @@ export class SQLiteBase {
                 try {
                     db = new Database(dbPath, { timeout: 30000 });
                     applyWALPragmas(db);
-                    if (!skipExclusive) {
-                        try {
-                            db.pragma("locking_mode = EXCLUSIVE");
-                        }
-                        catch { /* unsupported runtime */ }
-                    }
                 }
                 catch (retryErr) {
-                    // Free the lock before bubbling — caller can never reach
-                    // close()/cleanup() if the ctor throws.
-                    releaseDbLock({ dbPath });
                     throw new Error(`Failed to create fresh DB after renaming corrupt file: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`);
                 }
             }
             else {
-                releaseDbLock({ dbPath });
                 throw err;
             }
         }
         this.#db = db;
-        _liveDBs.set(this.#db, dbPath);
+        _liveDBs.add(this.#db);
         this.initSchema();
         this.prepareStatements();
     }
@@ -578,10 +542,6 @@ export class SQLiteBase {
     close() {
         _liveDBs.delete(this.#db);
         closeDB(this.#db);
-        // v1.0.128 — Issue #560: drop the .lock file AFTER closeDB so the
-        // WAL checkpoint inside closeDB completes while we still own the
-        // writer slot. releaseDbLock is no-op for tmpdir paths (skip-gate).
-        releaseDbLock({ dbPath: this.#dbPath });
     }
     withRetry(fn) {
         return withRetry(fn);
@@ -594,9 +554,5 @@ export class SQLiteBase {
         _liveDBs.delete(this.#db);
         closeDB(this.#db);
         deleteDBFiles(this.#dbPath);
-        // v1.0.128 — Issue #560: also drop the lockfile during cleanup. Per-
-        // process tmp DBs (defaultDBPath()) skip-gate inside the helper, so
-        // this is only a side-effect for shared on-disk content stores.
-        releaseDbLock({ dbPath: this.#dbPath });
     }
 }

package/build/session/analytics.js

@@ -1256,7 +1256,16 @@ function renderNarrative5Section(args) {
     const lifetimeLegacyTokens = lifetimeEventsTokens + lifetimeRescueTokens;
     const lifetimeRealTokens = realBytes?.lifetime?.totalSavedTokens ?? 0;
     const lifetimeTokensWithout = Math.max(lifetimeLegacyTokens, lifetimeRealTokens);
-    const lifetimeTokensWith = Math.max(1, Math.round(lifetimeTokensWithout * 0.02));
+    // Lifetime "with" — measured when available, else legacy 0.02 fallback.
+    // Honest definition (matches conversation bar below):
+    //   "with"    = bytes_returned (what the model actually re-saw)
+    //   "without" = bytes_returned + bytes_avoided
+    // When the schema has measurement, derive `with` from `bytes_returned/4`.
+    const lifeRet = realBytes?.lifetime?.bytesReturned ?? 0;
+    const lifeAv = realBytes?.lifetime?.bytesAvoided ?? 0;
+    const lifetimeTokensWith = (lifeRet + lifeAv) > 0
+        ? Math.max(1, Math.floor(lifeRet / 4))
+        : Math.max(1, Math.round(lifetimeTokensWithout * 0.02));
     // Bytes from realBytes when present, else derive from tokens (×4 — same
     // ratio Phase 8 uses everywhere). All-work bytes drives the opener tally
     // + the section-3 receipt + section-4 cost example.
@@ -1328,15 +1337,32 @@ function renderNarrative5Section(args) {
         out.push(`  Without that, you'd be re-explaining everything to a blank model right now.`);
     }
     out.push("");
-    // Without/With bars — the screenshottable proof for THIS conversation.
-    const convTokensWith = Math.max(1, Math.round(conversationTokens * 0.02));
-    const withoutBar = dataBar(conversationTokens, conversationTokens, 32);
-    const withBar = dataBar(convTokensWith, conversationTokens, 32);
-    const convPct = conversationTokens > 0 ? (1 - convTokensWith / conversationTokens) * 100 : 0;
-    out.push(`  Without context-mode  ${kb(convBytes).padStart(8)}  ${withoutBar}   ${fmtNum(conversationTokens).padStart(7)} tokens`);
-    out.push(`  With context-mode     ${kb(Math.max(1, Math.round(convBytes * 0.02))).padStart(8)}  ${withBar}   ${fmtNum(convTokensWith).padStart(7)} tokens`);
-    out.push(`                          ${convPct.toFixed(0)}% kept out of context · your AI ran ${Math.max(1, Math.round(conversationTokens / convTokensWith))}× longer before /compact fired`);
-    out.push("");
+    // Without/With bars — measured from real per-event bytes_returned / bytes_avoided.
+    //
+    // Honest definitions:
+    //   Without = bytes the model WOULD have re-seen with no filtering    = bytes_returned + bytes_avoided
+    //   With    = bytes the model ACTUALLY re-saw after context-mode      = bytes_returned
+    //
+    // No fallback to heuristic. If the schema has zero signal for this
+    // conversation (no hook ever populated bytes_avoided / bytes_returned),
+    // the section is skipped entirely. Honesty over decoration.
+    const realConv = realBytes?.conversation;
+    const measuredAvoided = realConv?.bytesAvoided ?? 0;
+    const measuredReturned = realConv?.bytesReturned ?? 0;
+    if (measuredAvoided + measuredReturned > 0) {
+        const convBytesWithout = measuredReturned + measuredAvoided;
+        const convBytesWith = Math.max(1, measuredReturned);
+        const convTokensWithout = Math.max(1, Math.floor(convBytesWithout / 4));
+        const convTokensWith = Math.max(1, Math.floor(convBytesWith / 4));
+        const withoutBar = dataBar(convTokensWithout, convTokensWithout, 32);
+        const withBar = dataBar(convTokensWith, convTokensWithout, 32);
+        const convPct = (1 - convTokensWith / convTokensWithout) * 100;
+        const convMult = Math.max(1, Math.round(convTokensWithout / convTokensWith));
+        out.push(`  Without context-mode  ${kb(convBytesWithout).padStart(8)}  ${withoutBar}   ${fmtNum(convTokensWithout).padStart(7)} tokens`);
+        out.push(`  With context-mode     ${kb(convBytesWith).padStart(8)}  ${withBar}   ${fmtNum(convTokensWith).padStart(7)} tokens`);
+        out.push(`                          ${convPct.toFixed(0)}% kept out of context · your AI ran ${convMult}× longer before /compact fired`);
+        out.push("");
+    }
     // Timeline — drop-in if conversation has byDay.
     if (conversation.byDay && conversation.byDay.length > 0) {
         const totalConvDays = conversation.lastEventMs && conversation.firstEventMs