context-mode 1.0.133 → 1.0.135

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/.openclaw-plugin/package.json

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

@@ -11,7 +11,9 @@
  *                     CLAUDE_PROJECT_DIR, CLAUDE_SESSION_ID | ~/.claude/
  *   - Gemini CLI:     GEMINI_PROJECT_DIR (hooks), GEMINI_CLI (MCP) | ~/.gemini/
  *   - KiloCode:       KILO, KILO_PID | ~/.config/kilo/
- *   - OpenCode:       OPENCODE, OPENCODE_PID | ~/.config/opencode/
+ *   - OpenCode:       OPENCODE_PROJECT_DIR, OPENCODE_CLIENT,
+ *                     OPENCODE_TERMINAL, OPENCODE, OPENCODE_PID |
+ *                     ~/.config/opencode/
  *   - OpenClaw:       OPENCLAW_HOME, OPENCLAW_CLI | ~/.openclaw/
  *   - Codex CLI:      CODEX_CI, CODEX_THREAD_ID | ~/.codex/
  *   - Cursor:         CURSOR_TRACE_ID (MCP), CURSOR_CLI (terminal) | ~/.cursor/

package/build/adapters/detect.js

@@ -11,7 +11,9 @@
  *                     CLAUDE_PROJECT_DIR, CLAUDE_SESSION_ID | ~/.claude/
  *   - Gemini CLI:     GEMINI_PROJECT_DIR (hooks), GEMINI_CLI (MCP) | ~/.gemini/
  *   - KiloCode:       KILO, KILO_PID | ~/.config/kilo/
- *   - OpenCode:       OPENCODE, OPENCODE_PID | ~/.config/opencode/
+ *   - OpenCode:       OPENCODE_PROJECT_DIR, OPENCODE_CLIENT,
+ *                     OPENCODE_TERMINAL, OPENCODE, OPENCODE_PID |
+ *                     ~/.config/opencode/
  *   - OpenClaw:       OPENCLAW_HOME, OPENCLAW_CLI | ~/.openclaw/
  *   - Codex CLI:      CODEX_CI, CODEX_THREAD_ID | ~/.codex/
  *   - Cursor:         CURSOR_TRACE_ID (MCP), CURSOR_CLI (terminal) | ~/.cursor/
@@ -109,12 +111,15 @@ const _PLATFORM_ENV_VARS_RAW = [
             { name: "KILO_PID", role: "identification" },
         ]],
     // opencode — sst/opencode packages/opencode/src/index.ts:108-109 sets
-    // OPENCODE=1 + OPENCODE_PID=<pid> on every CLI invocation.
+    // OPENCODE=1 + OPENCODE_PID=<pid> on CLI invocations. OpenCode desktop
+    // shells also expose OPENCODE_CLIENT=desktop and OPENCODE_TERMINAL=1.
     // OPENCODE_PROJECT_DIR is the documented workspace var (consumed by the
     // legacy resolver cascade) — listed first so the workspace cascade picks
     // it up under strict mode.
     ["opencode", [
             { name: "OPENCODE_PROJECT_DIR", role: "workspace" },
+            { name: "OPENCODE_CLIENT", role: "identification" },
+            { name: "OPENCODE_TERMINAL", role: "identification" },
             { name: "OPENCODE", role: "identification" },
             { name: "OPENCODE_PID", role: "identification" },
         ]],

package/build/adapters/pi/mcp-bridge.d.ts

@@ -85,6 +85,14 @@ export declare class MCPStdioClient {
     initialize(): Promise<void>;
     listTools(): Promise<MCPTool[]>;
     callTool(name: string, args: unknown): Promise<MCPCallResult>;
+    /**
+     * Respawn the MCP child after an exit (clean idle shutdown or crash).
+     * Resets state so a fresh `start()` + `initialize()` cycle runs, then
+     * the caller's pending request flows through the new child.
+     *
+     * Internal — exposed only via the public `callTool()` happy path.
+     */
+    private respawn;
     shutdown(): void;
 }
 /**

package/build/adapters/pi/mcp-bridge.js

@@ -284,8 +284,40 @@ export class MCPStdioClient {
         return Array.isArray(result.tools) ? result.tools : [];
     }
     async callTool(name, args) {
+        // Respawn-on-idle-exit (#583). The MCP server gained an idle
+        // self-shutdown in 1.0.132 (#565/#568, src/lifecycle.ts). When the
+        // Pi-spawned child exits cleanly after the idle window, Pi keeps the
+        // tool handles registered, but the bridge client is `exited=true`
+        // and every subsequent request would reject with
+        // "MCP server has exited" — leaving Pi's ctx_* tools permanently
+        // broken until the user restarts Pi.
+        //
+        // The structural fix is here, not in lifecycle.ts: the bridge owns
+        // the child lifecycle, so it transparently respawns + re-initialises
+        // the server on the next call. Restores parity with adapters whose
+        // host MCP client respawns on EOF (Claude Code, Codex, etc.).
+        if (this.exited)
+            await this.respawn();
         return this.request("tools/call", { name, arguments: args ?? {} }, DEFAULT_CALL_TIMEOUT_MS);
     }
+    /**
+     * Respawn the MCP child after an exit (clean idle shutdown or crash).
+     * Resets state so a fresh `start()` + `initialize()` cycle runs, then
+     * the caller's pending request flows through the new child.
+     *
+     * Internal — exposed only via the public `callTool()` happy path.
+     */
+    async respawn() {
+        // Drop the dead child handle and clear stream buffer so leftover
+        // bytes from the previous incarnation don't get parsed as JSON-RPC
+        // for the new one. Pending map is already cleared by onExit().
+        this.child = null;
+        this.buffer = "";
+        this.exited = false;
+        this.initialized = false;
+        this.start();
+        await this.initialize();
+    }
     shutdown() {
         if (!this.child)
             return;

package/build/cli.js

@@ -933,6 +933,22 @@ async function upgrade(opts) {
                 const message = err instanceof Error ? err.message : String(err);
                 throw new Error(`.mcp.json drift check failed: ${message}`);
             }
+            // v1.0.X — Layer 7 heal: update user-level ~/.claude.json MCP server
+            // registrations that point to old context-mode version dirs.
+            // (anthropics/claude-code#59310 workaround — see heal-installed-plugins.mjs)
+            try {
+                // @ts-expect-error — JS module, no TS declarations
+                const { healClaudeJsonMcpArgs } = await import("../scripts/heal-installed-plugins.mjs");
+                const dotClaudeJson = resolve(homedir(), ".claude.json");
+                const pluginCacheParent = resolve(resolveClaudeConfigDir(), "plugins", "cache", "context-mode", "context-mode");
+                const result = healClaudeJsonMcpArgs({ dotClaudeJsonPath: dotClaudeJson, pluginCacheParent, newPluginRoot: pluginRoot });
+                if (result.healed && result.healed.length > 0) {
+                    p.log.info(color.dim("  ~/.claude.json user MCP registrations updated → " + newVersion));
+                }
+            }
+            catch {
+                /* best effort — never block upgrade */
+            }
             // v1.0.114 hotfix — marketplace post-pull assertion: clone (if
             // present) MUST be on newVersion. Mert's case showed marketplace
             // stuck at v1.0.89 — the sync block above swallowed that silently.
@@ -1151,6 +1167,7 @@ async function upgrade(opts) {
             stdio: "inherit",
             timeout: 30000,
             cwd: pluginRoot,
+            env: { ...process.env, CONTEXT_MODE_PLATFORM: detection.platform },
         });
     }
     catch {

package/build/runtime.js

@@ -12,11 +12,14 @@ import { existsSync } from "node:fs";
  * Match is case-insensitive; `.exe` extension tolerated for Windows binaries.
  */
 const ALLOWED_SHELL_BASENAMES = /^(bash|sh|zsh|dash|pwsh|powershell|cmd)(\.exe)?$/i;
+const BUN_BASENAME = /^bun(\.exe)?$/i;
+function runtimeBasename(runtimePath) {
+    const segments = runtimePath.split(/[\\/]/);
+    return segments[segments.length - 1] ?? runtimePath;
+}
 export function isAllowlistedShell(shellPath) {
     // Cross-OS basename: split on either separator, take the last segment.
-    const segments = shellPath.split(/[\\/]/);
-    const base = segments[segments.length - 1];
-    return ALLOWED_SHELL_BASENAMES.test(base);
+    return ALLOWED_SHELL_BASENAMES.test(runtimeBasename(shellPath));
 }
 const isWindows = process.platform === "win32";
 function commandExists(cmd) {
@@ -305,14 +308,14 @@ export function getAvailableLanguages(runtimes) {
 export function buildCommand(runtimes, language, filePath) {
     switch (language) {
         case "javascript":
-            return runtimes.javascript.endsWith("bun")
+            return BUN_BASENAME.test(runtimeBasename(runtimes.javascript))
                 ? [runtimes.javascript, "run", filePath]
                 : [runtimes.javascript, filePath];
         case "typescript":
             if (!runtimes.typescript) {
                 throw new Error("No TypeScript runtime available. Install one of: bun (recommended), tsx (npm i -g tsx), or ts-node.");
             }
-            if (runtimes.typescript?.endsWith("bun"))
+            if (BUN_BASENAME.test(runtimeBasename(runtimes.typescript)))
                 return [runtimes.typescript, "run", filePath];
             if (runtimes.typescript === "tsx")
                 return ["tsx", filePath];

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.
@@ -2622,7 +2666,21 @@ server.registerTool("ctx_stats", {
                         // Render-time read-only — no DB mutation, no backfill.
                         const contentDbPath = getStorePath();
                         const convReal = getRealBytesStats({ sessionId: sid, sessionsDir: getSessionDir(), worktreeHash: dbHash, contentDbPath });
-                        const lifeReal = getRealBytesStats({ sessionsDir: getSessionDir() });
+                        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

@@ -391,6 +391,24 @@ export interface RealBytesStats {
 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).
@@ -539,19 +557,6 @@ export declare const adapterLabels: Record<string, string>;
  * information. Scale awareness comes from the unit jump between rows.
  */
 export declare function kb(b: number): string;
-/**
- * Locale + IANA-timezone detection for the narrative renderer.
- *
- * Cascade (each level overrides the next):
- *   1. CONTEXT_MODE_LOCALE / CONTEXT_MODE_TZ env overrides
- *      (used by tests + by users who want to pin output regardless of OS).
- *   2. macOS `defaults read -g AppleLocale` → `en_TR` style → `en-TR`.
- *   3. Linux `LANG` / `LC_TIME` env vars.
- *   4. Fallback: `Intl.DateTimeFormat().resolvedOptions().locale`.
- *
- * Timezone always uses `Intl.DateTimeFormat().resolvedOptions().timeZone`
- * — that one's always available and correct regardless of platform.
- */
 export declare function detectLocaleAndTz(): {
     locale: string;
     tz: string;

package/build/session/analytics.js

@@ -750,6 +750,52 @@ export function getContentBytesForSession(sessionId, contentDbPath, opts) {
         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).
@@ -1044,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;
@@ -1156,9 +1217,45 @@ function formatDuration(uptimeMin) {
  * Timezone always uses `Intl.DateTimeFormat().resolvedOptions().timeZone`
  * — that one's always available and correct regardless of platform.
  */
+/**
+ * Validate that a locale string is a usable BCP 47 tag.
+ *
+ * Ubuntu GHA runners default to `LANG=C.UTF-8`. The extractor below strips
+ * that to `"C"` — a valid POSIX locale identifier but NOT a BCP 47 tag.
+ * On macOS / Node 20, `new Intl.DateTimeFormat("C", …)` throws RangeError
+ * outright. CI run 25887250971 caught this via the v1.0.134 SLICE B test.
+ *
+ * Earlier fix attempt used a permissive `supportedLocalesOf || construction`
+ * OR check — that was wrong: on Linux + Node 22.5, `new Intl.DateTimeFormat
+ * ("POSIX")` does NOT throw, it silently falls back to the root locale and
+ * still emits garbage at format time. CI run 25904838577 surfaced that —
+ * "POSIX" round-tripped through the validator unchanged.
+ *
+ * Strict gate: `Intl.DateTimeFormat.supportedLocalesOf(tag)` returns `[]` for
+ * any tag that doesn't map to a real language (regardless of whether
+ * construction with that tag throws). That's the contract we want — "is this
+ * a BCP 47 tag the host actually has data for". Construction is an explicit
+ * sanity check; both must pass.
+ */
+function isUsableBcp47Locale(raw) {
+    if (!raw)
+        return false;
+    try {
+        if (Intl.DateTimeFormat.supportedLocalesOf(raw).length === 0)
+            return false;
+        // Belt: confirm construction doesn't throw on this host either.
+        new Intl.DateTimeFormat(raw);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function detectLocaleAndTz() {
     const env = (process.env ?? {});
     let locale = env.CONTEXT_MODE_LOCALE ?? "";
+    if (locale && !isUsableBcp47Locale(locale))
+        locale = "";
     if (!locale) {
         if (process.platform === "darwin") {
             try {
@@ -1173,11 +1270,18 @@ export function detectLocaleAndTz() {
                     locale = out.replace(/_/g, "-");
             }
             catch { /* defaults missing or sandbox */ }
+            if (locale && !isUsableBcp47Locale(locale))
+                locale = "";
         }
         if (!locale && (env.LC_TIME || env.LANG)) {
             const raw = (env.LC_TIME || env.LANG || "").split(".")[0];
             if (raw)
                 locale = raw.replace(/_/g, "-");
+            // POSIX locale identifiers (`C`, `POSIX`) survive the simple extraction
+            // above but blow up `new Intl.DateTimeFormat(locale, ...)`. Drop and
+            // fall through to the host-default branch below.
+            if (locale && !isUsableBcp47Locale(locale))
+                locale = "";
         }
         if (!locale) {
             try {
@@ -1197,7 +1301,13 @@ export function detectLocaleAndTz() {
             tz = "UTC";
         }
     }
-    return { locale: locale || "en-US", tz: tz || "UTC" };
+    // Final belt-and-suspenders: if the locale we settled on is somehow still
+    // unusable (env mutation between detection and return, contributor adding
+    // a new extraction path that skips the validator), fall back to en-US so
+    // formatLocalDateTime / monthDay / weekdayCap never throw at render time.
+    if (!isUsableBcp47Locale(locale))
+        locale = "en-US";
+    return { locale, tz: tz || "UTC" };
 }
 /**
  * Format an absolute path as a human-friendly display string by
@@ -1396,19 +1506,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);

package/build/util/claude-config.d.ts

@@ -13,12 +13,18 @@ export declare function resolveClaudeGlobalSettingsPath(env?: NodeJS.ProcessEnv)
  *      adapter is non-claude — claude is already covered by entry 2).
  *   2. The claude global settings.json (always — defense in depth).
  *
- * Lazy import of `./adapters/detect.js` keeps this file free of any direct
- * adapter dependency: the detect module itself only `import type`s adapter
- * types at the top level (concrete adapters are loaded dynamically inside
- * `getAdapter()`), so a static import is safe — but we use `createRequire`
- * to make the dependency direction crystal clear and to avoid surprising
- * future maintainers who add eager adapter imports to detect.ts.
+ * Static import of `../adapters/detect.js` is safe — detect.ts only imports
+ * `node:` builtins, `./types.js` (type-only), and `./client-map.js` (pure
+ * data). It does NOT import claude-config back, so no cycle.
+ *
+ * History: this used `createRequire(import.meta.url).resolve(...)` to lazy-
+ * load detect at call time. That pattern requires `require(esm)`, which is
+ * flag-gated on Node 22.x before 22.12 (`--experimental-require-module`).
+ * CI run 25877550371 on Node 22.5 silently failed every detect.* call —
+ * the catch block ate the error and every cross-adapter deny-policy test
+ * returned an empty policy list. Static import sidesteps the require(esm)
+ * gate entirely, so the same code works on every supported Node version
+ * (20.x, 22.5, 22.12+, 24+) without needing the experimental flag.
  *
  * The returned array is deduplicated and order-stable: adapter-specific path
  * first (most specific), claude global second (fallback).