context-mode 1.0.132 → 1.0.134

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.132",
+  "version": "1.0.134",
   "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/server.d.ts

@@ -1,6 +1,23 @@
 #!/usr/bin/env node
 import { type SpawnSyncOptions, type SpawnSyncReturns } from "node:child_process";
 import { ContentStore } from "./store.js";
+/**
+ * Build the FK-attribution object passed to every ContentStore.index*() call
+ * in this process. CLAUDE_SESSION_ID is the only MCP-side handle we have on
+ * the current session — eventId stays undefined because MCP tool invocations
+ * are not paired with PostToolUse event rows at index time (the hook fires
+ * AFTER the tool returns). Empty-string fallback inside #insertChunks keeps
+ * legacy unattributed rows readable.
+ */
+export declare function currentAttribution(): {
+    sessionId?: string;
+} | undefined;
+/** v1.0.134 SLICE A: opts injection for testability. Production callers pass nothing. */
+export declare function resolveSessionIdFromSessionDB(opts?: {
+    projectDir?: string;
+    sessionsDir?: string;
+    bypassCache?: boolean;
+}): string | undefined;
 /**
  * Parse FTS5 highlight markers to find match positions in the
  * original (marker-free) text. Returns character offsets into the

package/build/server.js

@@ -29,7 +29,7 @@ import { getHookScriptPaths } from "./util/hook-config.js";
 import { resolveClaudeConfigDir } from "./util/claude-config.js";
 import { resolveProjectDir } from "./util/project-dir.js";
 import { loadDatabase } from "./db-base.js";
-import { AnalyticsEngine, formatReport, getConversationStats, getLifetimeStats, getMultiAdapterLifetimeStats, getRealBytesStats, OPUS_INPUT_PRICE_PER_TOKEN } from "./session/analytics.js";
+import { AnalyticsEngine, formatReport, getConversationStats, getContentBytesAllSessions, getLifetimeStats, getMultiAdapterLifetimeStats, getRealBytesStats, OPUS_INPUT_PRICE_PER_TOKEN } from "./session/analytics.js";
 const __pkg_dir = dirname(fileURLToPath(import.meta.url));
 const VERSION = (() => {
     for (const rel of ["../package.json", "./package.json"]) {
@@ -86,12 +86,56 @@ let _store = null;
  * AFTER the tool returns). Empty-string fallback inside #insertChunks keeps
  * legacy unattributed rows readable.
  */
-function currentAttribution() {
-    const sessionId = process.env.CLAUDE_SESSION_ID;
+export function currentAttribution() {
+    // CLAUDE_SESSION_ID env var is NOT propagated to MCP servers (only to hooks).
+    // Cross-adapter resolution: every adapter (15 of them) sets *_PROJECT_DIR env
+    // and writes session_events via hooks. Read the most-recent session_id from
+    // THIS project's session DB. Works for claude-code/cursor/gemini-cli/codex/
+    // kiro/opencode/zed/kilo/openclaw/qwen-code/vscode-copilot/jetbrains-copilot/
+    // omp/pi/antigravity — no adapter-specific transcript path required.
+    const sessionId = process.env.CLAUDE_SESSION_ID ?? resolveSessionIdFromSessionDB();
     if (!sessionId)
         return undefined;
     return { sessionId };
 }
+let __cachedSessionId;
+/** v1.0.134 SLICE A: opts injection for testability. Production callers pass nothing. */
+export function resolveSessionIdFromSessionDB(opts) {
+    // 2s cache — ctx_fetch_and_index can fire 5+ chunks/sec; DB open cost adds up.
+    const now = Date.now();
+    if (!opts?.bypassCache && __cachedSessionId && now - __cachedSessionId.checkedAt < 2000) {
+        return __cachedSessionId.sid;
+    }
+    try {
+        const projectDir = opts?.projectDir
+            ?? process.env.CLAUDE_PROJECT_DIR
+            ?? process.env.CONTEXT_MODE_PROJECT_DIR;
+        if (!projectDir)
+            return undefined;
+        const sessionsDir = opts?.sessionsDir ?? getSessionDir();
+        const dbPath = resolveSessionDbPath({ projectDir, sessionsDir });
+        if (!existsSync(dbPath))
+            return undefined;
+        const Database = loadDatabase();
+        const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+        try {
+            const row = db.prepare("SELECT session_id FROM session_events ORDER BY created_at DESC LIMIT 1").get();
+            const sid = row?.session_id;
+            if (sid)
+                __cachedSessionId = { sid, checkedAt: now };
+            return sid;
+        }
+        finally {
+            try {
+                db.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Auto-index session events files written by SessionStart hook.
  * Scans ~/.claude/context-mode/sessions/ for *-events.md files.
@@ -1701,7 +1745,24 @@ export function buildFetchCode(url, outputPath) {
     // can serve a public IP for the parent's pre-flight ssrfGuard lookup and
     // then a blocked IP (e.g. 169.254.169.254 IMDS) for the subprocess fetch's
     // own lookup — classic DNS rebinding across the parent/child boundary.
-    const classifyIpSrc = classifyIp.toString();
+    //
+    // CRITICAL: bundlers (esbuild) rename top-level identifiers — `classifyIp`
+    // becomes e.g. `_h` in server.bundle.mjs. `classifyIp.toString()` returns
+    // the renamed source `function _h(t){...}`, but the embedded subprocess
+    // template references the literal name `classifyIp` (and the function's
+    // own internal recursion is also `_h(...)`). Result: the subprocess sees
+    // `function _h(t){...; return _h(...)}` injected, then references to
+    // `classifyIp` blow up with `ReferenceError: classifyIp is not defined`.
+    //
+    // Fix: emit `var <fnName> = <fn-expr>; var classifyIp = <fnName>;`. The
+    // named function expression preserves recursion under whatever name the
+    // bundler chose, and the alias re-exposes the canonical `classifyIp`
+    // identifier the rest of the embedded script depends on.
+    const classifyIpInner = classifyIp.toString();
+    const classifyIpFnName = classifyIp.name || "classifyIp";
+    const classifyIpSrc = classifyIpFnName === "classifyIp"
+        ? `var classifyIp = ${classifyIpInner};`
+        : `var ${classifyIpFnName} = ${classifyIpInner};\nvar classifyIp = ${classifyIpFnName};`;
     const strictMode = process.env.CTX_FETCH_STRICT === "1";
     return `
 const TurndownService = require(${turndownPath});
@@ -2597,8 +2658,29 @@ server.registerTool("ctx_stats", {
                     }
                     if (sid) {
                         conversation = getConversationStats({ sessionId: sid, sessionsDir: getSessionDir(), worktreeHash: dbHash });
-                        const convReal = getRealBytesStats({ sessionId: sid, sessionsDir: getSessionDir(), worktreeHash: dbHash });
-                        const lifeReal = getRealBytesStats({ sessionsDir: getSessionDir() });
+                        // v1.0.133 Slice 3: pass contentDbPath so getRealBytesStats can
+                        // join chunks WHERE session_id = sid and fold the indexed
+                        // content bytes into the per-conversation bar. Without this,
+                        // Mert's session showed ~200B (event metadata only) even with
+                        // 49 MB of indexed content sitting in the content DB.
+                        // Render-time read-only — no DB mutation, no backfill.
+                        const contentDbPath = getStorePath();
+                        const convReal = getRealBytesStats({ sessionId: sid, sessionsDir: getSessionDir(), worktreeHash: dbHash, contentDbPath });
+                        const lifeRealBase = getRealBytesStats({ sessionsDir: getSessionDir() });
+                        // v1.0.134 SLICE C: lifetime tier sums ALL chunks (no
+                        // session_id filter). Without this fold, lifetime "kept out"
+                        // only counts session_events.bytes_avoided and ignores the
+                        // bulk of indexed payload across every prior conversation.
+                        const lifeContentBytes = getContentBytesAllSessions(contentDbPath);
+                        const lifeReal = {
+                            ...lifeRealBase,
+                            contentBytes: lifeRealBase.contentBytes + lifeContentBytes,
+                            bytesAvoided: lifeRealBase.bytesAvoided + lifeContentBytes,
+                            totalSavedTokens: Math.floor((lifeRealBase.eventDataBytes
+                                + lifeRealBase.bytesAvoided
+                                + lifeContentBytes
+                                + lifeRealBase.snapshotBytes) / 4),
+                        };
                         realBytes = { conversation: convReal, lifetime: lifeReal };
                     }
                 }

package/build/session/analytics.d.ts

@@ -358,8 +358,57 @@ export interface RealBytesStats {
     bytesAvoided: number;
     bytesReturned: number;
     snapshotBytes: number;
+    /**
+     * v1.0.133 Slice 3: bytes attributed to this session in the FTS5 content
+     * DB — `SUM(LENGTH(title) + LENGTH(content)) FROM chunks WHERE session_id = ?`.
+     *
+     * Read-only, render-time computation. Populated only when
+     * `getRealBytesStats` is called with both `sessionId` AND `contentDbPath`
+     * (i.e. the conversation tier from ctx_stats). Lifetime / project tiers
+     * leave this at 0 — aggregating across every adapter's content DB is a
+     * separate concern.
+     *
+     * Legacy chunks with empty `session_id` (pre-Slice-1) are NOT backfilled:
+     * the architect rejected the time-window join as unsafe. Old conversations
+     * stay low; new conversations populate honestly.
+     */
+    contentBytes: number;
     totalSavedTokens: number;
 }
+/**
+ * v1.0.133 Slice 3: Sum the bytes attributed to one session in the FTS5
+ * content DB.
+ *
+ * Returns `LENGTH(title) + LENGTH(content)` summed across every chunk
+ * whose `session_id` column matches `sessionId`. Best-effort — returns 0
+ * when the DB file is missing, the schema lacks the `session_id` column
+ * (pre-Slice-1 content DBs), or the query fails. Never throws.
+ *
+ * Render-time only. Does NOT mutate the content DB. Architect-approved
+ * because the read-only join carries no risk of cross-session attribution
+ * (the FK was set at chunk insert time by Slice 1).
+ */
+export declare function getContentBytesForSession(sessionId: string, contentDbPath: string, opts?: {
+    loadDatabase?: () => unknown;
+}): number;
+/**
+ * v1.0.134 SLICE C — lifetime tier all-chunks aggregate.
+ *
+ * Sibling of {@link getContentBytesForSession} that omits the session_id
+ * filter so the lifetime tier sees every chunk in the content store —
+ * including legacy unattributed rows (sessionId === '') and chunks
+ * attributed to other adapters' sessions. Without this, the lifetime
+ * "kept out" headline only counts session_events.bytes_avoided and
+ * misses the bulk of indexed payload.
+ *
+ * Best-effort: returns 0 when the DB file is missing, the schema lacks
+ * the `chunks` table, or the query fails. Never throws — same contract
+ * as the rest of the analytics module so a corrupt content DB cannot
+ * crash ctx_stats.
+ */
+export declare function getContentBytesAllSessions(contentDbPath: string, opts?: {
+    loadDatabase?: () => unknown;
+}): number;
 /**
  * Compute real-bytes stats across one session, one project (worktree
  * filter), or every session on disk (lifetime).
@@ -378,6 +427,13 @@ export declare function getRealBytesStats(opts: {
     sessionId?: string;
     sessionsDir?: string;
     worktreeHash?: string;
+    /**
+     * v1.0.133 Slice 3: when set alongside `sessionId`, the function joins
+     * the FTS5 content DB at this path and folds chunk bytes into
+     * `bytesAvoided` + `totalSavedTokens` + `contentBytes`. Render-time
+     * only — no DB writes.
+     */
+    contentDbPath?: string;
     loadDatabase?: () => unknown;
 }): RealBytesStats;
 /**

package/build/session/analytics.js

@@ -706,6 +706,96 @@ export function getConversationStats(opts) {
         byDay,
     };
 }
+/**
+ * v1.0.133 Slice 3: Sum the bytes attributed to one session in the FTS5
+ * content DB.
+ *
+ * Returns `LENGTH(title) + LENGTH(content)` summed across every chunk
+ * whose `session_id` column matches `sessionId`. Best-effort — returns 0
+ * when the DB file is missing, the schema lacks the `session_id` column
+ * (pre-Slice-1 content DBs), or the query fails. Never throws.
+ *
+ * Render-time only. Does NOT mutate the content DB. Architect-approved
+ * because the read-only join carries no risk of cross-session attribution
+ * (the FK was set at chunk insert time by Slice 1).
+ */
+export function getContentBytesForSession(sessionId, contentDbPath, opts) {
+    if (!sessionId || !contentDbPath)
+        return 0;
+    if (!existsSync(contentDbPath))
+        return 0;
+    let DatabaseCtor = null;
+    try {
+        DatabaseCtor = opts?.loadDatabase
+            ? opts.loadDatabase()
+            : loadDatabaseImpl();
+    }
+    catch {
+        return 0;
+    }
+    if (!DatabaseCtor)
+        return 0;
+    try {
+        const db = new DatabaseCtor(contentDbPath, { readonly: true });
+        try {
+            const row = db.prepare(`SELECT COALESCE(SUM(LENGTH(content) + LENGTH(title)), 0) AS bytes
+         FROM chunks WHERE session_id = ?`).get(sessionId);
+            return Number(row?.bytes ?? 0);
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * v1.0.134 SLICE C — lifetime tier all-chunks aggregate.
+ *
+ * Sibling of {@link getContentBytesForSession} that omits the session_id
+ * filter so the lifetime tier sees every chunk in the content store —
+ * including legacy unattributed rows (sessionId === '') and chunks
+ * attributed to other adapters' sessions. Without this, the lifetime
+ * "kept out" headline only counts session_events.bytes_avoided and
+ * misses the bulk of indexed payload.
+ *
+ * Best-effort: returns 0 when the DB file is missing, the schema lacks
+ * the `chunks` table, or the query fails. Never throws — same contract
+ * as the rest of the analytics module so a corrupt content DB cannot
+ * crash ctx_stats.
+ */
+export function getContentBytesAllSessions(contentDbPath, opts) {
+    if (!contentDbPath)
+        return 0;
+    if (!existsSync(contentDbPath))
+        return 0;
+    let DatabaseCtor = null;
+    try {
+        DatabaseCtor = opts?.loadDatabase
+            ? opts.loadDatabase()
+            : loadDatabaseImpl();
+    }
+    catch {
+        return 0;
+    }
+    if (!DatabaseCtor)
+        return 0;
+    try {
+        const db = new DatabaseCtor(contentDbPath, { readonly: true });
+        try {
+            const row = db.prepare(`SELECT COALESCE(SUM(LENGTH(content) + LENGTH(title)), 0) AS bytes
+         FROM chunks`).get();
+            return Number(row?.bytes ?? 0);
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return 0;
+    }
+}
 /**
  * Compute real-bytes stats across one session, one project (worktree
  * filter), or every session on disk (lifetime).
@@ -726,6 +816,7 @@ export function getRealBytesStats(opts) {
         bytesAvoided: 0,
         bytesReturned: 0,
         snapshotBytes: 0,
+        contentBytes: 0,
         totalSavedTokens: 0,
     };
     const sessionsDir = opts.sessionsDir
@@ -812,8 +903,19 @@ export function getRealBytesStats(opts) {
         }
         catch { /* missing tables / corrupt — skip */ }
     }
+    // v1.0.133 Slice 3: fold content DB chunk bytes for this session into
+    // bytesAvoided. Skipped silently when caller didn't pass contentDbPath
+    // (lifetime / project tiers, or pre-Slice-3 callers). Treated as
+    // "avoided" because indexed chunks are bytes that would have been
+    // re-inflated into context on every search if the model had to
+    // re-read raw files.
+    let contentBytes = 0;
+    if (opts.sessionId && opts.contentDbPath) {
+        contentBytes = getContentBytesForSession(opts.sessionId, opts.contentDbPath, { loadDatabase: opts.loadDatabase });
+        bytesAvoided += contentBytes;
+    }
     const totalSavedTokens = Math.floor((eventDataBytes + bytesAvoided + snapshotBytes) / 4);
-    return { eventDataBytes, bytesAvoided, bytesReturned, snapshotBytes, totalSavedTokens };
+    return { eventDataBytes, bytesAvoided, bytesReturned, snapshotBytes, contentBytes, totalSavedTokens };
 }
 const DEFAULT_REAL_USAGE_FILTER = {
     minEvents: 100,
@@ -975,6 +1077,7 @@ export function getMultiAdapterRealBytesStats(opts) {
         bytesAvoided: 0,
         bytesReturned: 0,
         snapshotBytes: 0,
+        contentBytes: 0,
         totalSavedTokens: 0,
     };
     const perAdapter = [];
@@ -987,6 +1090,21 @@ export function getMultiAdapterRealBytesStats(opts) {
             worktreeHash: opts?.worktreeHash,
             loadDatabase: opts?.loadDatabase,
         });
+        // ARCH-REVIEW-V134-ABC SLICE C: aggregate this adapter's content DB
+        // bytes into the lifetime sum. `getRealBytesStats` operates on
+        // session events only and never touches the sibling content/ tree —
+        // without this step the lifetime tier in ctx_stats reports 0 for
+        // every adapter except whichever one happens to share the
+        // sessionsDir of the caller. Lifetime tier ignores sessionId so
+        // the all-sessions aggregator is the right helper here.
+        if (!opts?.sessionId) {
+            const contentDbPath = join(entry.contentDir, "content.db");
+            const adapterContentBytes = getContentBytesAllSessions(contentDbPath, {
+                loadDatabase: opts?.loadDatabase,
+            });
+            one.contentBytes += adapterContentBytes;
+            sum.contentBytes += adapterContentBytes;
+        }
         perAdapter.push({ name: entry.name, ...one });
         sum.eventDataBytes += one.eventDataBytes;
         sum.bytesAvoided += one.bytesAvoided;
@@ -1339,19 +1457,32 @@ function renderNarrative5Section(args) {
     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
+    // Honest definitions (v1.0.134 SLICE B — eventDataBytes floor):
+    //   Without = bytes the model WOULD have re-seen with no filtering
+    //           = bytes_avoided + bytes_returned + eventDataBytes
+    //   With    = bytes the model ACTUALLY re-saw after context-mode
+    //           = bytes_returned + eventDataBytes
+    //
+    // Why eventDataBytes belongs on BOTH sides:
+    //   `eventDataBytes` is the raw payload captured by the hook (tool args,
+    //   prompt body, etc). Those bytes were "kept out" — never inflated back
+    //   into context — but they still represent real measured signal. Pre-fix
+    //   the formula was `with = max(1, bytesReturned)`, which collapsed to 1
+    //   whenever the conversation hadn't accumulated any re-served bytes yet
+    //   (early in a session, or for tool-heavy work that never re-hits index).
+    //   That produced a degenerate ~100% kept-out bar even when the only
+    //   honest signal we had was a few KB of event payloads.
     //
     // No fallback to heuristic. If the schema has zero signal for this
-    // conversation (no hook ever populated bytes_avoided / bytes_returned),
+    // conversation (no hook ever populated any of the three columns),
     // 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 measuredEvent = realConv?.eventDataBytes ?? 0;
+    if (measuredAvoided + measuredReturned + measuredEvent > 0) {
+        const convBytesWithout = measuredAvoided + measuredReturned + measuredEvent;
+        const convBytesWith = Math.max(1, measuredReturned + measuredEvent);
         const convTokensWithout = Math.max(1, Math.floor(convBytesWithout / 4));
         const convTokensWith = Math.max(1, Math.floor(convBytesWith / 4));
         const withoutBar = dataBar(convTokensWithout, convTokensWithout, 32);