context-mode 1.0.147 → 1.0.149

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.147",
+  "version": "1.0.149",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/.codex-plugin/plugin.json

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

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.147",
+  "version": "1.0.149",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
   "author": {
     "name": "Mert Koseoğlu",

package/build/adapters/codex/index.d.ts

@@ -15,6 +15,12 @@
  */
 import { BaseAdapter } from "../base.js";
 import { type HookAdapter, type HookParadigm, type PlatformCapabilities, type DiagnosticResult, type PreToolUseEvent, type PostToolUseEvent, type PreCompactEvent, type SessionStartEvent, type PreToolUseResponse, type PostToolUseResponse, type PreCompactResponse, type SessionStartResponse, type HookRegistration } from "../types.js";
+type CodexVersionRunner = (file: string, args: string[], options: {
+    encoding: BufferEncoding;
+    stdio: ["ignore", "pipe", "ignore"];
+    timeout: number;
+}) => string | Buffer;
+export declare function probeCodexCliVersion(runCommand?: CodexVersionRunner): string | null;
 export declare class CodexAdapter extends BaseAdapter implements HookAdapter {
     constructor();
     readonly name = "Codex CLI";
@@ -67,3 +73,4 @@ export declare class CodexAdapter extends BaseAdapter implements HookAdapter {
      */
     private extractSessionId;
 }
+export {};

package/build/adapters/codex/index.js

@@ -13,6 +13,7 @@
  * while input rewriting remains blocked on upstream updatedInput support.
  * Track: https://github.com/openai/codex/issues/18491
  */
+import { execFileSync } from "node:child_process";
 import { readFileSync, writeFileSync, accessSync, copyFileSync, constants, mkdirSync, } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -54,6 +55,26 @@ const LEGACY_HOOK_PATH_SUFFIXES = {
     UserPromptSubmit: ["hooks/userpromptsubmit.mjs", "hooks/codex/userpromptsubmit.mjs"],
     Stop: ["hooks/stop.mjs", "hooks/codex/stop.mjs"],
 };
+export function probeCodexCliVersion(runCommand = execFileSync) {
+    try {
+        const output = process.platform === "win32"
+            ? runCommand("cmd.exe", ["/d", "/s", "/c", "codex --version"], {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 5000,
+            })
+            : runCommand("codex", ["--version"], {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 1500,
+            });
+        const version = String(output).trim();
+        return version.length > 0 ? version : "available (version output empty)";
+    }
+    catch {
+        return null;
+    }
+}
 function getTomlSection(raw, sectionName) {
     const lines = raw.split(/\r?\n/);
     let inSection = false;
@@ -365,6 +386,15 @@ export class CodexAdapter extends BaseAdapter {
     // ── Diagnostics (doctor) ─────────────────────────────────
     validateHooks(_pluginRoot) {
         const results = [];
+        const codexCliVersion = probeCodexCliVersion();
+        results.push({
+            check: "Codex CLI binary",
+            status: codexCliVersion ? "pass" : "warn",
+            message: codexCliVersion
+                ? `codex --version resolved to ${codexCliVersion}`
+                : "Could not run codex --version; hooks need the Codex CLI available on PATH",
+            ...(codexCliVersion ? {} : { fix: "Install Codex CLI or make codex available on PATH" }),
+        });
         try {
             const raw = readFileSync(this.getSettingsPath(), "utf-8");
             const enabled = hasCodexHooksFeature(raw);
@@ -498,8 +528,9 @@ export class CodexAdapter extends BaseAdapter {
         }
     }
     getInstalledVersion() {
-        // Codex CLI has no marketplace or plugin system
-        return "not installed";
+        // Codex uses standalone MCP registration; there is no platform-owned
+        // plugin version to compare against the context-mode npm package.
+        return "standalone";
     }
     // ── Upgrade ────────────────────────────────────────────
     configureAllHooks(pluginRoot) {

package/build/adapters/types.d.ts

@@ -229,7 +229,10 @@ export interface HookAdapter {
     getHealthChecks?(pluginRoot: string): readonly HealthCheck[];
     /** Check if the plugin is registered/enabled on this platform. */
     checkPluginRegistration(): DiagnosticResult;
-    /** Get the installed version from this platform's registry/marketplace. */
+    /**
+     * Get the installed version from this platform's registry/marketplace, or
+     * "standalone" when no platform-owned plugin version exists.
+     */
     getInstalledVersion(): string;
     /** Configure all hooks for this platform. Returns change descriptions. */
     configureAllHooks(pluginRoot: string): string[];

package/build/cli.js

@@ -763,7 +763,11 @@ async function doctor() {
             ` — local v${localVersion}, latest v${latestVersion}` +
             color.dim("\n  Run: /context-mode:ctx-upgrade"));
     }
-    if (installedVersion === "not installed") {
+    if (installedVersion === "standalone") {
+        p.log.info(color.dim(`${adapter.name}: standalone MCP mode`) +
+            " — no platform plugin version to compare");
+    }
+    else if (installedVersion === "not installed") {
         p.log.info(color.dim(`${adapter.name}: not installed`) +
             " — using standalone MCP mode");
     }

package/build/executor.d.ts

@@ -19,6 +19,15 @@ interface ExecuteOptions {
     timeout?: number;
     /** Keep process running after timeout instead of killing it. */
     background?: boolean;
+    /**
+     * Issue #45 — per-call cwd override for the shell language. When set,
+     * the shell script runs in this directory instead of `#projectRoot`.
+     * Non-shell languages keep their tmpDir sandbox cwd regardless (the
+     * script file lives there). Used by Codex MCP handlers to pin shell
+     * commands to a resolved project root when the spawning host inherited
+     * a non-project cwd (e.g. $HOME).
+     */
+    cwd?: string;
 }
 interface ExecuteFileOptions extends ExecuteOptions {
     path: string;

package/build/executor.js

@@ -130,7 +130,7 @@ export class PolyglotExecutor {
         this.#backgroundedPids.clear();
     }
     async execute(opts) {
-        const { language, code, timeout, background = false } = opts;
+        const { language, code, timeout, background = false, cwd: cwdOverride } = opts;
         const tmpDir = mkdtempSync(join(OS_TMPDIR, ".ctx-mode-"));
         try {
             const filePath = this.#writeScript(tmpDir, code, language);
@@ -142,7 +142,11 @@ export class PolyglotExecutor {
             // Shell commands run in the project directory so git, relative paths,
             // and other project-aware tools work naturally. Non-shell languages
             // run in the temp directory where their script file is written.
-            const cwd = language === "shell" ? this.#projectRoot : tmpDir;
+            // Issue #45 — `cwdOverride` lets per-call sites (Codex MCP handlers)
+            // pin shell cwd without mutating process-wide state.
+            const cwd = language === "shell"
+                ? (cwdOverride ?? this.#projectRoot)
+                : tmpDir;
             const result = await this.#spawn(cmd, cwd, tmpDir, timeout, background);
             // Skip tmpDir cleanup if process was backgrounded — it may still need files
             if (!result.backgrounded) {

package/build/server.d.ts

@@ -78,6 +78,18 @@ export declare function resolveSessionIdFromSessionDB(opts?: {
     sessionsDir?: string;
     bypassCache?: boolean;
 }): string | undefined;
+/**
+ * Project directory detection across supported platforms.
+ *
+ * Priority:
+ *   1. Platform-specific env var (set by host IDE before MCP server spawn)
+ *   2. CONTEXT_MODE_PROJECT_DIR (set by start.mjs for ALL platforms — universal)
+ *   3. process.cwd() (last resort)
+ *
+ * CONTEXT_MODE_PROJECT_DIR guarantees correct projectDir even for platforms
+ * that don't set their own env var (Cursor, OpenClaw, Codex, Kiro, Zed).
+ */
+export declare function getProjectDir(): string;
 /**
  * Parse FTS5 highlight markers to find match positions in the
  * original (marker-free) text. Returns character offsets into the

package/build/server.js

@@ -465,7 +465,7 @@ function getSessionDir() {
  * CONTEXT_MODE_PROJECT_DIR guarantees correct projectDir even for platforms
  * that don't set their own env var (Cursor, OpenClaw, Codex, Kiro, Zed).
  */
-function getProjectDir() {
+export function getProjectDir() {
     const override = projectDirOverride.getStore();
     if (override)
         return override.projectDir;
@@ -500,14 +500,22 @@ function getProjectDir() {
     // and the legacy literal cascade is preserved there for semver safety.
     let transcriptsRoot;
     let strictPlatform;
+    let codexHome;
     try {
         const detected = detectPlatform().platform;
         strictPlatform = detected;
         if (detected === "claude-code") {
             transcriptsRoot = join(homedir(), ".claude", "projects");
         }
+        // Issue #45 — Codex publishes no workspace env var, so the resolver
+        // reads `meta.cwd` from the most-recently-modified session.jsonl under
+        // `${codexHome}/sessions/`. Wire codexHome at the call site so the
+        // resolver can be exercised under test without process-level mutation.
+        if (detected === "codex") {
+            codexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
+        }
     }
-    catch { /* detection failure — leave both undefined, resolver uses legacy cascade */ }
+    catch { /* detection failure — leave undefined, resolver uses legacy cascade */ }
     return resolveProjectDir({
         env: process.env,
         cwd: process.cwd(),
@@ -515,6 +523,7 @@ function getProjectDir() {
         transcriptsRoot,
         transcriptMaxAgeMs: 5 * 60 * 1000,
         strictPlatform,
+        codexHome,
     });
 }
 /**
@@ -1731,13 +1740,20 @@ EXAMPLE: ctx_index(path: "/path/to/large-spec.md", source: "openapi-v2-spec")`,
         path: z
             .string()
             .optional()
-            .describe("File path to read and index (content never enters context). Provide this OR content."),
+            .describe("File OR directory path to read and index (content never enters context). Provide this OR content. Directory paths trigger a bounded recursive walk (#687)."),
         source: z
             .string()
             .optional()
             .describe("Label for the indexed content (e.g., 'Context7: React useEffect', 'Skill: frontend-design')"),
+        include: z.array(z.string()).optional().describe("Directory-only: glob patterns to include (default: all matching extensions)."),
+        exclude: z.array(z.string()).optional().describe("Directory-only: glob patterns to exclude. Merged with defaults (node_modules, .git, dist, build, .next, coverage, .venv, __pycache__, .DS_Store)."),
+        maxDepth: z.number().int().min(0).optional().describe("Directory-only: max recursion depth from root (default: 5)."),
+        maxFiles: z.number().int().min(1).optional().describe("Directory-only: hard cap on files indexed (default: 200) — FTS5 blow-up guard."),
+        extensions: z.array(z.string()).optional().describe("Directory-only: allowed file extensions (default: .md .mdx .txt .json .yaml .yml .ts .tsx .js .jsx .py .rs .go .sh)."),
+        respectGitignore: z.boolean().optional().describe("Directory-only: apply nearest .gitignore (default: true)."),
+        followSymlinks: z.boolean().optional().describe("Directory-only: follow directory symlinks (default: false — cycle hazard + escape risk)."),
     }),
-}, async ({ content, path, source }) => {
+}, async ({ content, path, source, include, exclude, maxDepth, maxFiles, extensions, respectGitignore, followSymlinks }) => {
     if (!content && !path) {
         return trackResponse("ctx_index", {
             content: [
@@ -1760,6 +1776,54 @@ EXAMPLE: ctx_index(path: "/path/to/large-spec.md", source: "openapi-v2-spec")`,
     }
     try {
         const resolvedPath = path ? resolveProjectPath(path) : undefined;
+        // Directory dispatch (#687, reported by @matiasduartee). When the
+        // resolved path is a directory, walk it bounded and re-enter `index()`
+        // per-file so the security gate at store.ts:845 (TOCTOU defense from
+        // #442 round-3) keeps running for every file.
+        if (resolvedPath && existsSync(resolvedPath) && statSync(resolvedPath).isDirectory()) {
+            const store = getStore();
+            const projectDir = getProjectDir();
+            const denyGlobs = readToolDenyPatterns("Read", projectDir);
+            const isWin32 = process.platform === "win32";
+            const perFileDeny = (absPath) => {
+                try {
+                    return evaluateFilePath(absPath, denyGlobs, isWin32, projectDir).denied;
+                }
+                catch {
+                    return false; // fail-open consistent with checkFilePathDenyPolicy
+                }
+            };
+            const dirResult = store.indexDirectory({
+                path: resolvedPath,
+                source: source ?? resolvedPath,
+                attribution: currentAttribution(),
+                perFileDeny,
+                include,
+                exclude,
+                maxDepth,
+                maxFiles,
+                extensions,
+                respectGitignore,
+                followSymlinks,
+            });
+            const capNote = dirResult.capped
+                ? ` (cap reached — only first ${dirResult.filesIndexed} of ${dirResult.totalSeen}+ files; raise maxFiles to index more)`
+                : "";
+            const denyNote = dirResult.denied > 0
+                ? ` (${dirResult.denied} file${dirResult.denied === 1 ? "" : "s"} blocked by Read deny policy)`
+                : "";
+            const failNote = dirResult.failed > 0
+                ? ` (${dirResult.failed} file${dirResult.failed === 1 ? "" : "s"} failed to read)`
+                : "";
+            return trackResponse("ctx_index", {
+                content: [
+                    {
+                        type: "text",
+                        text: `Indexed ${dirResult.filesIndexed} file${dirResult.filesIndexed === 1 ? "" : "s"} (${dirResult.totalChunks} sections) from directory: ${dirResult.label}${capNote}${denyNote}${failNote}\nUse ctx_search(queries: ["..."]) to query this content.`,
+                    },
+                ],
+            });
+        }
         // Track the raw bytes being indexed (content or file)
         if (content)
             trackIndexed(Buffer.byteLength(content));
@@ -3106,7 +3170,47 @@ server.registerTool("ctx_stats", {
                         // 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 });
+                        // v1.0.148 Bug E+F: a conversation typically spans many
+                        // session_ids (resume cycles, /compact rebirths, PID
+                        // sub-process sessions launched by ctx_execute). Scoping
+                        // per-session loses sandbox-burst bytes_avoided that the
+                        // PID-sessions own. Look up THIS session's project_dir
+                        // from META and aggregate via META subquery so all
+                        // sibling sessions in the same cwd attribute together.
+                        // Fallback to sessionId scope if the META lookup fails
+                        // (best-effort — the original metric is still defensible).
+                        let convReal;
+                        try {
+                            const Database = loadDatabase();
+                            const dbFiles = (await import("node:fs"))
+                                .readdirSync(getSessionDir())
+                                .filter((f) => f.endsWith(".db") && (!dbHash || f.startsWith(dbHash)));
+                            let projectDirForSid;
+                            for (const file of dbFiles) {
+                                try {
+                                    const sdb = new Database((await import("node:path")).join(getSessionDir(), file), { readonly: true });
+                                    try {
+                                        const r = sdb
+                                            .prepare("SELECT project_dir FROM session_meta WHERE session_id = ?")
+                                            .get(sid);
+                                        if (r?.project_dir) {
+                                            projectDirForSid = r.project_dir;
+                                            break;
+                                        }
+                                    }
+                                    finally {
+                                        sdb.close();
+                                    }
+                                }
+                                catch { /* skip unreadable DB */ }
+                            }
+                            convReal = projectDirForSid
+                                ? getRealBytesStats({ projectDir: projectDirForSid, sessionsDir: getSessionDir(), worktreeHash: dbHash, contentDbPath })
+                                : getRealBytesStats({ sessionId: sid, sessionsDir: getSessionDir(), worktreeHash: dbHash, contentDbPath });
+                        }
+                        catch {
+                            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"

package/build/session/analytics.d.ts

@@ -427,6 +427,25 @@ export declare function getRealBytesStats(opts: {
     sessionId?: string;
     sessionsDir?: string;
     worktreeHash?: string;
+    /**
+     * v1.0.148 follow-up (Bug E+F): when set, the function aggregates across
+     * EVERY session whose `session_meta.project_dir` matches this value, not
+     * just one session_id. Resolves the per-conversation under-attribution:
+     * one Claude Code conversation typically spans many session_ids (resume
+     * cycles, /compact rebirths, PID sub-process sessions spawned by
+     * ctx_execute), so a single-session_id filter loses the sandbox-burst
+     * bytes_avoided that all live under the conversation's cwd.
+     *
+     * Uses a META subquery (`session_id IN (SELECT session_id FROM
+     * session_meta WHERE project_dir = ?)`), then sums ALL events for
+     * matching sessions regardless of their event-level project_dir
+     * (sandbox-burst events write `project_dir = ''` even when the
+     * META row carries the parent cwd — see Bug F).
+     *
+     * Mutually exclusive with `sessionId`. When both are set, `sessionId`
+     * wins for back-compat.
+     */
+    projectDir?: 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

package/build/session/analytics.js

@@ -13,6 +13,7 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, sep } from "node:path";
 import { loadDatabase as loadDatabaseImpl } from "../db-base.js";
+import { ensureSessionEventsSchema } from "./db.js";
 import { resolveClaudeConfigDir } from "../util/claude-config.js";
 function semverNewer(a, b) {
     const pa = a.split(".").map(Number);
@@ -857,6 +858,15 @@ export function getRealBytesStats(opts) {
     // don't need to type-narrow per row.
     for (const file of dbFiles) {
         const dbPath = join(sessionsDir, file);
+        // v1.0.148 hotfix: historical DBs were created with pre-v1.0.130
+        // schema (no bytes_avoided / bytes_returned / project_dir columns).
+        // The SELECT below references those columns, so without an in-place
+        // migration the prepare() throws and the surrounding catch silently
+        // skips the WHOLE DB — losing even the LENGTH(data) signal. Run the
+        // shared migration helper before opening readonly. Idempotent: a
+        // PRAGMA check inside the helper short-circuits when the DB is
+        // already current, so post-first-read calls are cheap.
+        ensureSessionEventsSchema(dbPath, DatabaseCtor);
         try {
             const sdb = new DatabaseCtor(dbPath, { readonly: true });
             try {
@@ -878,6 +888,36 @@ export function getRealBytesStats(opts) {
                     }
                     catch { /* old schema */ }
                 }
+                else if (opts.projectDir) {
+                    // Bug E+F: META-scoped aggregation. Take every session_id whose
+                    // session_meta.project_dir matches, then sum ALL of those
+                    // sessions' events regardless of the events' own project_dir
+                    // (sandbox-burst PID sessions write empty event-level project_dir
+                    // even when their META carries the parent cwd).
+                    const row = sdb.prepare(`SELECT
+               COALESCE(SUM(LENGTH(data)), 0)   AS data_bytes,
+               COALESCE(SUM(bytes_avoided), 0)  AS bytes_avoided,
+               COALESCE(SUM(bytes_returned), 0) AS bytes_returned
+             FROM session_events
+             WHERE session_id IN (
+               SELECT session_id FROM session_meta WHERE project_dir = ?
+             )`).get(opts.projectDir);
+                    if (row) {
+                        eventDataBytes += Number(row.data_bytes ?? 0);
+                        bytesAvoided += Number(row.bytes_avoided ?? 0);
+                        bytesReturned += Number(row.bytes_returned ?? 0);
+                    }
+                    try {
+                        const snap = sdb.prepare(`SELECT COALESCE(SUM(LENGTH(snapshot)), 0) AS bytes
+               FROM session_resume
+               WHERE session_id IN (
+                 SELECT session_id FROM session_meta WHERE project_dir = ?
+               )`).get(opts.projectDir);
+                        if (snap?.bytes)
+                            snapshotBytes += Number(snap.bytes);
+                    }
+                    catch { /* old schema */ }
+                }
                 else {
                     const row = sdb.prepare(`SELECT
                COALESCE(SUM(LENGTH(data)), 0)   AS data_bytes,
@@ -1504,34 +1544,44 @@ function renderNarrative5Section(args) {
         out.push(`  Without that, you'd be re-explaining everything to a blank model right now.`);
     }
     out.push("");
-    // Without/With bars — measured from real per-event bytes_returned / bytes_avoided.
+    // Without/With bars — strict compression (v1.0.148, Bug G / ADR-0004).
     //
-    // 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
+    // Honest definitions:
+    //   Without = bytes the model WOULD have re-seen if context-mode
+    //             had not diverted them
+    //           = bytesAvoided + bytesReturned
     //   With    = bytes the model ACTUALLY re-saw after context-mode
-    //           = bytes_returned + eventDataBytes
+    //           = max(1, bytesReturned)
     //
-    // 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.
+    // Why eventDataBytes is excluded from this ratio:
+    //   `eventDataBytes` is the raw hook payload (tool args, prompt
+    //   body) we captured for the knowledge base. Those bytes are
+    //   analytics infrastructure — they NEVER enter the model context
+    //   window. Including them on either side (as v1.0.134 SLICE B did
+    //   to dodge a degenerate 100% bar) misrepresents context cost.
+    //   SLICE B was an incidental fix that crushed the displayed
+    //   percentage from ~95% (the true compression ratio) to ~56% on
+    //   live conversations. eventDataBytes is rendered in Section 2
+    //   (captures count), not in this Section 1 Without/With bar.
     //
-    // No fallback to heuristic. If the schema has zero signal for this
-    // conversation (no hook ever populated any of the three columns),
-    // the section is skipped entirely. Honesty over decoration.
+    // Empty-state branch:
+    //   If neither bytesAvoided nor bytesReturned has been measured yet
+    //   (early in a session, schema-migration recovery in progress, or
+    //   tool-heavy work that hasn't re-hit the index), we do NOT draw
+    //   a degenerate 0% / 100% bar. We emit one honest hint line and
+    //   skip the bar — honesty over decoration.
     const realConv = realBytes?.conversation;
     const measuredAvoided = realConv?.bytesAvoided ?? 0;
     const measuredReturned = realConv?.bytesReturned ?? 0;
-    const measuredEvent = realConv?.eventDataBytes ?? 0;
-    if (measuredAvoided + measuredReturned + measuredEvent > 0) {
-        const convBytesWithout = measuredAvoided + measuredReturned + measuredEvent;
-        const convBytesWith = Math.max(1, measuredReturned + measuredEvent);
+    if (measuredAvoided + measuredReturned === 0) {
+        // No measurable redirect activity yet — captures may exist, but
+        // nothing has been diverted from the model context window.
+        out.push("  No measurable redirect activity captured yet — bars will appear once context-mode diverts its first payload.");
+        out.push("");
+    }
+    else {
+        const convBytesWithout = measuredAvoided + measuredReturned;
+        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);

package/build/session/db.d.ts

@@ -179,6 +179,50 @@ export interface ToolCallStats {
         bytesReturned: number;
     }>;
 }
+/**
+ * Apply any missing post-v1.0.130 `session_events` columns to an already-
+ * open writable database handle. Idempotent — each ALTER is guarded by a
+ * PRAGMA table_xinfo check, and the project_dir index is created only
+ * when a migration actually ran. Returns true if any column was added.
+ *
+ * Used by both the SessionDB constructor (for the active DB) and the
+ * analytics aggregator (for the 100+ historical DBs that never get
+ * opened through SessionDB). ADR-0001 compatible: no EXCLUSIVE pragma,
+ * no acquireDbLock — relies on the SQLite busy_timeout + WAL semantics
+ * already provided by SQLiteBase.
+ */
+export declare function applyMissingSessionEventsColumns(db: {
+    pragma: (q: string) => Array<{
+        name: string;
+    }>;
+    exec: (sql: string) => void;
+}): boolean;
+/**
+ * Open a session DB file briefly, run any missing schema migrations,
+ * and close. Best-effort: missing tables, file-locks, corrupt files,
+ * and any DatabaseCtor error are swallowed silently — the caller
+ * (analytics aggregator) handles the readonly query that follows and
+ * will skip the DB if it remains unreadable.
+ *
+ * Lazy migration entry point for the analytics aggregator, which would
+ * otherwise read 100+ historical DBs with the old (pre-v1.0.130) schema
+ * and lose every signal (not just bytes_avoided) because the SELECT
+ * statement references columns that don't exist on legacy schemas.
+ *
+ * Two open/close cycles in the worst case (one readonly probe to detect
+ * legacy schema, one writable to migrate). For already-migrated DBs
+ * (the common case after first read), this opens writable once and
+ * exits without writing — cheaper than always-writable.
+ */
+export declare function ensureSessionEventsSchema(dbPath: string, DatabaseCtor: new (path: string, opts?: {
+    readonly?: boolean;
+}) => {
+    pragma: (q: string) => Array<{
+        name: string;
+    }>;
+    exec: (sql: string) => void;
+    close: () => void;
+}): void;
 export declare class SessionDB extends SQLiteBase {
     /**
      * Cached prepared statements. Stored in a Map to avoid the JS private-field