squeezr-ai 1.21.8 → 1.22.0

package/README.md

@@ -125,6 +125,7 @@ Built-in MCP server (`squeezr-mcp`) that gives any MCP-capable AI CLI real-time
 | `squeezr_check_updates` | Check npm for newer Squeezr version |
 | `squeezr_update` | Update to latest version via `npm install -g squeezr-ai@latest` |
 | `squeezr_set_project` | Manually set/clear the current project name (overrides auto-detection) |
+| `squeezr_bypass` | Toggle bypass mode — disable compression instantly without restart (runtime-only) |
 
 Every MCP tool response automatically checks for updates and appends a notification banner when a new version is available.
 
@@ -245,12 +246,25 @@ squeezr gain --session # live session savings from the running proxy
 squeezr gain --details # all-time stats with per-tool breakdown
 squeezr gain --reset   # reset all-time counters
 squeezr discover       # detect which AI CLIs are installed
+squeezr bypass         # toggle bypass mode (skip compression, keep logging)
+squeezr bypass --on    # enable bypass (disable compression)
+squeezr bypass --off   # disable bypass (resume compression)
 squeezr mcp install    # register MCP server in Claude Code, Cursor, Windsurf, Cline
 squeezr mcp uninstall  # remove MCP server registration
 squeezr uninstall      # remove Squeezr completely (env vars, CA, auto-start, logs)
 squeezr version        # print version
 ```
 
+## Resilience
+
+Squeezr sits in the critical path between your AI CLI and the upstream API. It's designed to never break your workflow:
+
+- **Circuit breaker** — If the AI compression backend (Haiku, GPT-4o-mini, etc.) fails 3 times in a row, Squeezr automatically skips AI compression for 60 seconds, then probes recovery. Deterministic compression continues working. Visible in dashboard, `squeezr status`, and MCP.
+- **5-second AI timeout** — Each AI compression call has a hard 5s timeout. If the backend is slow, the original content passes through unmodified.
+- **Bypass mode** — `squeezr bypass` instantly disables all compression without restarting. Requests still pass through and are logged. Toggle via CLI, MCP, dashboard, or REST API.
+- **Expand rate tracking** — Monitors how often the model calls `squeezr_expand` to recover compressed content. High expand rate signals the compression is too aggressive.
+- **Latency tracking** — p50/p95/p99 compression latency visible in dashboard and MCP stats.
+
 ## Compression backends
 
 Squeezr uses cheap/free models for AI compression (the deterministic layer is pure regex, no API calls):

package/bin/squeezr.js

@@ -203,6 +203,9 @@ Usage:
   squeezr mcp uninstall    Remove Squeezr MCP registration
   squeezr ports            Change HTTP and MITM proxy ports
   squeezr tunnel           Expose proxy via Cloudflare Tunnel for Cursor IDE
+  squeezr bypass           Toggle bypass mode (skip compression, keep logging)
+  squeezr bypass --on      Enable bypass (disable compression)
+  squeezr bypass --off     Disable bypass (resume compression)
   squeezr update           Kill old processes, install latest from npm, restart
   squeezr uninstall        Remove Squeezr completely (env vars, CA, auto-start, logs)
   squeezr version          Print version
@@ -383,6 +386,18 @@ async function checkStatus() {
           console.log(`  HTTP proxy (Claude/Aider/Gemini): http://localhost:${port}`)
           console.log(`  MITM proxy (Codex):               http://localhost:${mitmPort}`)
           console.log(`  Dashboard:                        http://localhost:${port}/squeezr/dashboard`)
+          if (json.mode) console.log(`  Mode:     ${json.mode}`)
+          if (json.uptime_seconds != null) {
+            const s = json.uptime_seconds
+            const fmt = s < 60 ? `${s}s` : s < 3600 ? `${Math.floor(s/60)}m ${s%60}s` : `${Math.floor(s/3600)}h ${Math.floor((s%3600)/60)}m`
+            console.log(`  Uptime:   ${fmt}`)
+          }
+          if (json.bypassed) console.log(`  ⚠ Bypass mode is ON (compression disabled)`)
+          if (json.circuit_breaker) {
+            const cb = json.circuit_breaker
+            const icons = { closed: '🟢 OK', open: '🔴 OPEN', 'half-open': '🟡 PROBING' }
+            console.log(`  Circuit:  ${icons[cb.state] || cb.state}${cb.total_trips ? ` (${cb.total_trips} trip${cb.total_trips > 1 ? 's' : ''})` : ''}`)
+          }
         } catch {
           console.log(`Squeezr is running on port ${port}`)
         }
@@ -1532,6 +1547,33 @@ switch (command) {
     await startTunnel()
     break
 
+  case 'bypass':
+    await (async () => {
+      const port = getPort()
+      const body = args[1] === '--on' ? JSON.stringify({ enabled: true })
+        : args[1] === '--off' ? JSON.stringify({ enabled: false })
+        : '{}'
+      try {
+        const res = await fetch(`http://localhost:${port}/squeezr/bypass`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body,
+        })
+        const json = await res.json()
+        if (json.bypassed) {
+          console.log('⏸️  Bypass mode ON — compression disabled')
+          console.log('   Requests pass through uncompressed but are still logged.')
+          console.log('   Turn off: squeezr bypass --off')
+        } else {
+          console.log('▶️  Bypass mode OFF — compression active')
+        }
+      } catch {
+        console.log('Squeezr is NOT running')
+        console.log('Start it with: squeezr start')
+      }
+    })()
+    break
+
   case 'uninstall':
     await uninstall()
     break

package/dist/bypass.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bypass module — runtime-only compression toggle.
+ *
+ * When bypass is ON, requests pass through uncompressed but still logged.
+ * Resets on process restart. Does not touch config files.
+ */
+export declare function isBypassed(): boolean;
+export declare function setBypassed(val: boolean): void;
+export declare function toggleBypassed(): boolean;

package/dist/bypass.js

@@ -0,0 +1,18 @@
+/**
+ * Bypass module — runtime-only compression toggle.
+ *
+ * When bypass is ON, requests pass through uncompressed but still logged.
+ * Resets on process restart. Does not touch config files.
+ */
+let bypassed = false;
+export function isBypassed() {
+    return bypassed;
+}
+export function setBypassed(val) {
+    bypassed = val;
+    console.log(`[squeezr] Bypass mode ${val ? 'ON — compression disabled' : 'OFF — compression active'}`);
+}
+export function toggleBypassed() {
+    setBypassed(!bypassed);
+    return bypassed;
+}

package/dist/circuitBreaker.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Circuit breaker for AI compression calls.
+ *
+ * Prevents hammering a down backend (Haiku, GPT-4o-mini, etc.)
+ * with repeated failing requests. After N consecutive failures,
+ * the circuit opens and all AI compression is skipped for a cooldown
+ * period, then a single probe is allowed to test recovery.
+ *
+ * States:
+ *   closed    → normal operation, AI compression enabled
+ *   open      → backend down, all AI calls skipped (passthrough)
+ *   half-open → cooldown elapsed, allow one probe call
+ */
+export type CircuitState = 'closed' | 'open' | 'half-open';
+export interface CircuitBreakerConfig {
+    failureThreshold: number;
+    resetTimeoutMs: number;
+    callTimeoutMs: number;
+}
+export interface CircuitSnapshot {
+    state: CircuitState;
+    consecutive_failures: number;
+    last_failure_time: number | null;
+    last_success_time: number | null;
+    total_trips: number;
+    config: CircuitBreakerConfig;
+}
+export declare class CircuitBreaker {
+    private state;
+    private consecutiveFailures;
+    private lastFailureTime;
+    private lastSuccessTime;
+    private totalTrips;
+    private config;
+    constructor(config?: Partial<CircuitBreakerConfig>);
+    /** Returns current state, transitioning open→half-open if cooldown elapsed. */
+    getState(): CircuitState;
+    /** Whether the next AI call should be attempted. */
+    shouldAllow(): boolean;
+    recordSuccess(): void;
+    recordFailure(): void;
+    /** Wraps an async AI call with timeout and circuit logic. */
+    call<T>(fn: () => Promise<T>): Promise<T>;
+    snapshot(): CircuitSnapshot;
+}
+/** Singleton circuit breaker for all AI compression backends. */
+export declare const circuitBreaker: CircuitBreaker;

package/dist/circuitBreaker.js

@@ -0,0 +1,91 @@
+/**
+ * Circuit breaker for AI compression calls.
+ *
+ * Prevents hammering a down backend (Haiku, GPT-4o-mini, etc.)
+ * with repeated failing requests. After N consecutive failures,
+ * the circuit opens and all AI compression is skipped for a cooldown
+ * period, then a single probe is allowed to test recovery.
+ *
+ * States:
+ *   closed    → normal operation, AI compression enabled
+ *   open      → backend down, all AI calls skipped (passthrough)
+ *   half-open → cooldown elapsed, allow one probe call
+ */
+const DEFAULT_CONFIG = {
+    failureThreshold: 3,
+    resetTimeoutMs: 60_000,
+    callTimeoutMs: 5_000,
+};
+export class CircuitBreaker {
+    state = 'closed';
+    consecutiveFailures = 0;
+    lastFailureTime = null;
+    lastSuccessTime = null;
+    totalTrips = 0;
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /** Returns current state, transitioning open→half-open if cooldown elapsed. */
+    getState() {
+        if (this.state === 'open' &&
+            this.lastFailureTime !== null &&
+            Date.now() - this.lastFailureTime >= this.config.resetTimeoutMs) {
+            this.state = 'half-open';
+            console.log('[squeezr] Circuit breaker → HALF-OPEN (probing)');
+        }
+        return this.state;
+    }
+    /** Whether the next AI call should be attempted. */
+    shouldAllow() {
+        return this.getState() !== 'open';
+    }
+    recordSuccess() {
+        if (this.state === 'half-open') {
+            console.log('[squeezr] Circuit breaker → CLOSED (backend recovered)');
+        }
+        this.consecutiveFailures = 0;
+        this.state = 'closed';
+        this.lastSuccessTime = Date.now();
+    }
+    recordFailure() {
+        this.consecutiveFailures++;
+        this.lastFailureTime = Date.now();
+        if (this.consecutiveFailures >= this.config.failureThreshold && this.state !== 'open') {
+            this.state = 'open';
+            this.totalTrips++;
+            console.log(`[squeezr] Circuit breaker → OPEN (${this.consecutiveFailures} consecutive failures, ` +
+                `cooldown ${this.config.resetTimeoutMs / 1000}s)`);
+        }
+    }
+    /** Wraps an async AI call with timeout and circuit logic. */
+    async call(fn) {
+        if (!this.shouldAllow()) {
+            throw new Error('Circuit breaker is open — AI compression skipped');
+        }
+        try {
+            const result = await Promise.race([
+                fn(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('AI compression timeout')), this.config.callTimeoutMs)),
+            ]);
+            this.recordSuccess();
+            return result;
+        }
+        catch (err) {
+            this.recordFailure();
+            throw err;
+        }
+    }
+    snapshot() {
+        return {
+            state: this.getState(),
+            consecutive_failures: this.consecutiveFailures,
+            last_failure_time: this.lastFailureTime,
+            last_success_time: this.lastSuccessTime,
+            total_trips: this.totalTrips,
+            config: this.config,
+        };
+    }
+}
+/** Singleton circuit breaker for all AI compression backends. */
+export const circuitBreaker = new CircuitBreaker();

package/dist/compressor.d.ts

@@ -15,6 +15,8 @@ export interface Savings {
     dedupSavedChars?: number;
     aiSavedChars?: number;
     overheadChars?: number;
+    detMs?: number;
+    aiMs?: number;
 }
 export declare function getCache(config: Config): CompressionCache;
 interface AnthropicMessage {
@@ -50,4 +52,5 @@ interface GeminiContent {
     }>;
 }
 export declare function compressGeminiContents(contents: GeminiContent[], apiKey: string, config: Config): Promise<[GeminiContent[], Savings]>;
+export declare function emptySavings(dryRun?: boolean, detSavedChars?: number, dedupSavedChars?: number, detMs?: number): Savings;
 export {};

package/dist/compressor.js

@@ -5,6 +5,7 @@ import { preprocess, preprocessForTool, hitPattern } from './deterministic.js';
 import { storeOriginal } from './expand.js';
 import { hashText, getBlock, setBlock } from './sessionCache.js';
 import { effectiveThreshold, effectiveKeepRecent, aiEnabled } from './config.js';
+import { circuitBreaker } from './circuitBreaker.js';
 const COMPRESS_PROMPT = 'You are compressing a coding tool output to save tokens. ' +
     'Extract ONLY what is essential: errors, file paths, function names, ' +
     'test failures, key values, warnings. ' +
@@ -78,11 +79,14 @@ async function runCompression(items, compressFn, config) {
             if (cached)
                 return { ...item, original: item.text, result: cached };
         }
-        const compressed = await compressFn(preprocessed);
+        const compressed = await circuitBreaker.call(() => compressFn(preprocessed));
         if (config.cacheEnabled)
             cache.set(preprocessed, compressed);
         return { ...item, original: item.text, result: compressed };
     }));
+    const failures = results.filter(r => r.status === 'rejected').length;
+    if (failures > 0)
+        console.log(`[squeezr] ${failures} AI compression(s) failed (circuit: ${circuitBreaker.getState()})`);
     return results
         .filter((r) => r.status === 'fulfilled')
         .map((r) => r.value);
@@ -186,6 +190,7 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
     }
     // ── Step 1: Deterministic preprocessing on ALL tool results (turn 1+) ───────
     // Replaces RTK: applied to recent blocks too, no manual `rtk` prefix needed.
+    const detT0 = Date.now();
     let detSaved = 0;
     for (const { index, subIndex, text, tool } of allResults) {
         if (dedupedSet.has(`${index}:${subIndex}`))
@@ -197,6 +202,7 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
             detSaved += text.length - det.length;
         }
     }
+    const detMs = Date.now() - detT0;
     if (detSaved > 0) {
         const tokens = Math.round(detSaved / 3.5);
         console.log(`[squeezr/det] Deterministic: -${detSaved.toLocaleString()} chars (~${tokens} tokens) across ${allResults.length} block(s)`);
@@ -205,11 +211,16 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
     const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)));
     const toProcess = candidates.filter(c => c.text.length >= threshold && !dedupedSet.has(`${c.index}:${c.subIndex}`));
     if (toProcess.length === 0)
-        return [msgs, emptySavings(false, detSaved, readDedupSaved)];
+        return [msgs, emptySavings(false, detSaved, readDedupSaved, detMs)];
+    // Circuit breaker: skip AI compression entirely if backend is down
+    if (!circuitBreaker.shouldAllow()) {
+        console.log(`[squeezr] Circuit breaker open — skipping AI compression for ${toProcess.length} block(s)`);
+        return [msgs, emptySavings(false, detSaved, readDedupSaved, detMs)];
+    }
     if (config.dryRun) {
         const potential = toProcess.reduce((sum, c) => sum + c.text.length, 0);
         console.log(`[squeezr dry-run] Would AI-compress ${toProcess.length} block(s) | potential -${potential.toLocaleString()} chars | pressure=${Math.round(pressure * 100)}%`);
-        return [msgs, emptySavings(true, detSaved, readDedupSaved)];
+        return [msgs, emptySavings(true, detSaved, readDedupSaved, detMs)];
     }
     // Differential: split session cache hits from uncached
     const sessionHits = [];
@@ -226,9 +237,11 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
             toCompress.push(c);
         }
     }
+    const aiT0 = Date.now();
     const freshlyCompressed = toCompress.length > 0
         ? await runCompression(toCompress, t => compressWithHaiku(t, apiKey), config)
         : [];
+    const aiMs = Date.now() - aiT0;
     let totalOriginal = 0;
     let totalCompressed = 0;
     let totalOverhead = 0;
@@ -266,6 +279,8 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
             dedupSavedChars: readDedupSaved,
             aiSavedChars: totalAiSaved,
             overheadChars: totalOverhead,
+            detMs,
+            aiMs,
         }];
 }
 function extractOpenAIToolResults(messages) {
@@ -331,6 +346,7 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
         }
     }
     // Step 1: Deterministic preprocessing on ALL tool results
+    const oaiDetT0 = Date.now();
     let detSaved = 0;
     for (const { index, text, tool } of allResults) {
         if (dedupedIndices.has(index))
@@ -341,6 +357,7 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
             detSaved += text.length - det.length;
         }
     }
+    const oaiDetMs = Date.now() - oaiDetT0;
     if (detSaved > 0) {
         const tag = isLocal ? 'ollama' : 'codex';
         console.log(`[squeezr/det/${tag}] Deterministic: -${detSaved.toLocaleString()} chars across ${allResults.length} block(s)`);
@@ -349,11 +366,16 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)));
     const toProcess = candidates.filter(c => c.text.length >= threshold && !dedupedIndices.has(c.index));
     if (toProcess.length === 0)
-        return [msgs, emptySavings(false, detSaved, readDedupSaved)];
+        return [msgs, emptySavings(false, detSaved, readDedupSaved, oaiDetMs)];
+    // Circuit breaker: skip AI compression entirely if backend is down
+    if (!circuitBreaker.shouldAllow()) {
+        console.log(`[squeezr] Circuit breaker open — skipping AI compression for ${toProcess.length} block(s)`);
+        return [msgs, emptySavings(false, detSaved, readDedupSaved, oaiDetMs)];
+    }
     if (config.dryRun) {
         const tag = isLocal ? 'ollama' : 'codex';
         console.log(`[squeezr dry-run/${tag}] Would AI-compress ${toProcess.length} block(s) | potential -${toProcess.reduce((s, c) => s + c.text.length, 0).toLocaleString()} chars`);
-        return [msgs, emptySavings(true, detSaved, readDedupSaved)];
+        return [msgs, emptySavings(true, detSaved, readDedupSaved, oaiDetMs)];
     }
     const sessionHits = [];
     const toCompress = [];
@@ -372,9 +394,11 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     const compressFn = isLocal
         ? t => compressWithOllama(t, config.localUpstreamUrl, config.localCompressionModel)
         : t => compressWithGptMini(t, apiKey);
+    const oaiAiT0 = Date.now();
     const freshlyCompressed = toCompress.length > 0
         ? await runCompression(toCompress, compressFn, config)
         : [];
+    const oaiAiMs = Date.now() - oaiAiT0;
     let totalOriginal = 0, totalCompressed = 0, totalOverhead = 0, totalAiSaved = 0;
     const byTool = [];
     for (const { index, tool, block } of sessionHits) {
@@ -399,7 +423,7 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     }
     if (sessionHits.length > 0)
         console.log(`[squeezr] Session cache: ${sessionHits.length} block(s) reused`);
-    return [msgs, { compressed: freshlyCompressed.length, savedChars: totalOriginal - totalCompressed, originalChars: totalOriginal, byTool, dryRun: false, sessionCacheHits: sessionHits.length, detSavedChars: detSaved, dedupSavedChars: readDedupSaved, aiSavedChars: totalAiSaved, overheadChars: totalOverhead }];
+    return [msgs, { compressed: freshlyCompressed.length, savedChars: totalOriginal - totalCompressed, originalChars: totalOriginal, byTool, dryRun: false, sessionCacheHits: sessionHits.length, detSavedChars: detSaved, dedupSavedChars: readDedupSaved, aiSavedChars: totalAiSaved, overheadChars: totalOverhead, detMs: oaiDetMs, aiMs: oaiAiMs }];
 }
 export async function compressGeminiContents(contents, apiKey, config) {
     if (config.disabled)
@@ -456,6 +480,7 @@ export async function compressGeminiContents(contents, apiKey, config) {
         }
     }
     // Step 1: Deterministic preprocessing on ALL tool results
+    const gemDetT0 = Date.now();
     let detSaved = 0;
     for (const { index, subIndex, text, tool } of allResults) {
         if (geminiDedupedSet.has(`${index}:${subIndex}`))
@@ -466,16 +491,22 @@ export async function compressGeminiContents(contents, apiKey, config) {
             detSaved += text.length - det.length;
         }
     }
+    const gemDetMs = Date.now() - gemDetT0;
     if (detSaved > 0)
         console.log(`[squeezr/det/gemini] Deterministic: -${detSaved.toLocaleString()} chars across ${allResults.length} block(s)`);
     // Step 2: AI compression for old blocks above threshold
     const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)))
         .filter(c => c.text.length >= threshold && !geminiDedupedSet.has(`${c.index}:${c.subIndex}`));
     if (candidates.length === 0)
-        return [cts, emptySavings(false, detSaved, geminiReadDedupSaved)];
+        return [cts, emptySavings(false, detSaved, geminiReadDedupSaved, gemDetMs)];
+    // Circuit breaker: skip AI compression entirely if backend is down
+    if (!circuitBreaker.shouldAllow()) {
+        console.log(`[squeezr] Circuit breaker open — skipping AI compression for ${candidates.length} block(s)`);
+        return [cts, emptySavings(false, detSaved, geminiReadDedupSaved, gemDetMs)];
+    }
     if (config.dryRun) {
         console.log(`[squeezr dry-run/gemini] Would AI-compress ${candidates.length} block(s) | potential -${candidates.reduce((s, c) => s + c.text.length, 0).toLocaleString()} chars`);
-        return [cts, emptySavings(true, detSaved, geminiReadDedupSaved)];
+        return [cts, emptySavings(true, detSaved, geminiReadDedupSaved, gemDetMs)];
     }
     const sessionHits = [];
     const toCompress = [];
@@ -486,9 +517,11 @@ export async function compressGeminiContents(contents, apiKey, config) {
         else if (aiEnabled())
             toCompress.push(c);
     }
+    const gemAiT0 = Date.now();
     const freshlyCompressed = toCompress.length > 0
         ? await runCompression(toCompress, t => compressWithGeminiFlash(t, apiKey), config)
         : [];
+    const gemAiMs = Date.now() - gemAiT0;
     let totalOriginal = 0, totalCompressed = 0, totalOverhead = 0, totalAiSaved = 0;
     const byTool = [];
     for (const { index, subIndex, tool, block } of sessionHits) {
@@ -509,8 +542,8 @@ export async function compressGeminiContents(contents, apiKey, config) {
     }
     if (sessionHits.length > 0)
         console.log(`[squeezr/gemini] Session cache: ${sessionHits.length} block(s) reused`);
-    return [cts, { compressed: freshlyCompressed.length, savedChars: totalOriginal - totalCompressed, originalChars: totalOriginal, byTool, dryRun: false, sessionCacheHits: sessionHits.length, detSavedChars: detSaved, dedupSavedChars: geminiReadDedupSaved, aiSavedChars: totalAiSaved, overheadChars: totalOverhead }];
+    return [cts, { compressed: freshlyCompressed.length, savedChars: totalOriginal - totalCompressed, originalChars: totalOriginal, byTool, dryRun: false, sessionCacheHits: sessionHits.length, detSavedChars: detSaved, dedupSavedChars: geminiReadDedupSaved, aiSavedChars: totalAiSaved, overheadChars: totalOverhead, detMs: gemDetMs, aiMs: gemAiMs }];
 }
-function emptySavings(dryRun = false, detSavedChars = 0, dedupSavedChars = 0) {
-    return { compressed: 0, savedChars: 0, originalChars: 0, byTool: [], dryRun, sessionCacheHits: 0, detSavedChars, dedupSavedChars, aiSavedChars: 0, overheadChars: 0 };
+export function emptySavings(dryRun = false, detSavedChars = 0, dedupSavedChars = 0, detMs = 0) {
+    return { compressed: 0, savedChars: 0, originalChars: 0, byTool: [], dryRun, sessionCacheHits: 0, detSavedChars, dedupSavedChars, aiSavedChars: 0, overheadChars: 0, detMs, aiMs: 0 };
 }