@pi-unipi/compactor 0.2.2 → 2.0.0

package/src/info-screen.ts

@@ -1,15 +1,19 @@
 /**
  * Info-screen integration for @pi-unipi/compactor
  *
- * Budget-focused stats: tokensSaved, costSaved, pctReduction,
- * topTools, compactions, toolCalls.
+ * Stats driven by COMPACTION SAVINGS (the compactor's actual value),
+ * not sandbox/index diversion bytes.
+ *
+ * Data sources (in priority order):
+ * 1. Runtime counters (in-memory, current session only)
+ * 2. DB compaction stats (total_chars_before/kept in session_meta)
+ * 3. Session event counts (session_events table, always reliable)
  */
 
 import type { SessionDB } from "./session/db.js";
-import type { RuntimeStats, FullReport } from "./session/analytics.js";
-import { AnalyticsEngine, createMinimalDb } from "./session/analytics.js";
 import { getLastCompactionStats } from "./compaction/hooks.js";
 import { parseUsageStats } from "@pi-unipi/info-screen/usage-parser.js";
+import type { RuntimeCounters } from "./types.js";
 
 export interface CompactorInfoData {
   tokensSaved: { value: string; detail: string };
@@ -45,7 +49,6 @@ function estimateCostPerToken(): number | null {
     const models = usage.byModelToday;
     const todayKeys = Object.keys(models);
     if (todayKeys.length > 0) {
-      // Pick the model with most tokens today
       const topModel = todayKeys.reduce((a, b) => models[a].tokens > models[b].tokens ? a : b);
       const entry = models[topModel];
       if (entry.tokens > 0 && entry.cost > 0) {
@@ -70,40 +73,92 @@ function estimateCostPerToken(): number | null {
 export async function getInfoScreenData(
   sessionDB: SessionDB,
   sessionId: string,
-  runtimeStats: RuntimeStats,
+  counters?: RuntimeCounters,
 ): Promise<CompactorInfoData> {
   try {
-    const db = sessionDB.getDb();
-    const adapter = db ?? createMinimalDb();
-    const engine = new AnalyticsEngine(adapter);
-    const report = engine.queryAll(runtimeStats);
-    const compactStats = getLastCompactionStats();
+    // ── Compaction savings (the compactor's actual value) ──
+    // Priority: in-memory counter → DB per-session stats → DB all-time stats
+    let tokensSaved = counters?.totalTokensCompacted ?? 0;
+    let charsBefore = 0;
+    let charsKept = 0;
+
+    if (tokensSaved === 0) {
+      // Try DB per-session stats
+      const sessionStats = sessionDB.getSessionStats(sessionId);
+      if (sessionStats) {
+        charsBefore = (sessionStats as any).total_chars_before ?? 0;
+        charsKept = (sessionStats as any).total_chars_kept ?? 0;
+        tokensSaved = Math.round((charsBefore - charsKept) / 4);
+      }
+    }
 
-    // Tokens saved: bytes kept out of context / 4
-    const tokensSaved = Math.round(report.savings.kept_out / 4);
-
-    // Per-tool breakdown table for tokensSaved detail
-    const toolsWithCalls = report.savings.by_tool
-      .filter(t => t.calls > 0)
-      .sort((a, b) => b.tokens - a.tokens);
-    const toolBreakdown = toolsWithCalls.length > 0
-      ? toolsWithCalls.map(t =>
-          `  ${t.tool.padEnd(20)} ${String(t.calls).padStart(4)} calls  ${formatTokens(t.tokens).padStart(8)} tok`
-        ).join("\n")
+    if (tokensSaved === 0) {
+      // Try DB all-time stats
+      const allTime = sessionDB.getAllTimeStats();
+      charsBefore = allTime.allCharsBefore;
+      charsKept = allTime.allCharsKept;
+      tokensSaved = Math.round((charsBefore - charsKept) / 4);
+    }
+
+    // ── Compaction count ──
+    let compactionCount = counters?.compactions ?? 0;
+    if (compactionCount === 0) {
+      const allTime = sessionDB.getAllTimeStats();
+      compactionCount = allTime.allCompactions;
+    }
+
+    // ── Compression ratio / pct reduction ──
+    let pctReduction = 0;
+    if (charsBefore > 0) {
+      pctReduction = Math.round((1 - charsKept / charsBefore) * 100);
+    }
+
+    // ── Tool call counts from session_events (always reliable) ──
+    // The session_events table captures every tool_result event, so this
+    // is an accurate count regardless of runtimeStats state.
+    interface ToolCountRow { category: string; cnt: number }
+    let toolCountRows: ToolCountRow[] = [];
+    let totalToolCalls = 0;
+    try {
+      const db = sessionDB.getDb();
+      if (db) {
+        toolCountRows = db.prepare(
+          "SELECT category, COUNT(*) as cnt FROM session_events WHERE session_id = ? GROUP BY category",
+        ).all(sessionId) as ToolCountRow[];
+        for (const row of toolCountRows) {
+          totalToolCalls += row.cnt;
+        }
+      }
+    } catch {
+      // Non-fatal: DB query failed, show zero
+    }
+
+    // Build per-tool breakdown for display
+    const toolBreakdown = toolCountRows.length > 0
+      ? toolCountRows
+          .sort((a, b) => b.cnt - a.cnt)
+          .map(r => `  ${r.category.padEnd(20)} ${String(r.cnt).padStart(5)} events`)
+          .join("\n")
       : "No tool calls yet";
 
-    // Cost saved: tokensSaved × cost per token
+    const topCategory = toolCountRows.length > 0
+      ? toolCountRows.reduce((a, b) => a.cnt > b.cnt ? a : b)
+      : null;
+
+    const top5Detail = toolCountRows.length > 0
+      ? toolCountRows
+          .sort((a, b) => b.cnt - a.cnt)
+          .slice(0, 5)
+          .map(r => `${r.category}: ${r.cnt} events`)
+          .join("\n")
+      : "No tool calls yet";
+
+    // ── Cost saved estimate ──
     const costPerToken = estimateCostPerToken();
     const costSaved = costPerToken !== null ? tokensSaved * costPerToken : null;
 
-    // Top consuming tool
-    const topTool = toolsWithCalls[0];
-    const top5Tools = toolsWithCalls.slice(0, 5);
-    const top5Detail = top5Tools.length > 0
-      ? top5Tools.map(t =>
-          `${t.tool}: ${formatTokens(t.tokens)} (${t.calls} calls)`
-        ).join("\n")
-      : "No tool calls yet";
+    // ── Last compaction details ──
+    const compactStats = getLastCompactionStats();
 
     return {
       tokensSaved: {
@@ -117,24 +172,26 @@ export async function getInfoScreenData(
           : "Cost data unavailable for current model",
       },
       pctReduction: {
-        value: `${report.savings.pct}%`,
-        detail: `${formatTokens(Math.round(report.savings.processed_kb * 1024 / 4))} processed → ${formatTokens(Math.round(report.savings.entered_kb * 1024 / 4))} entered context`,
+        value: `${pctReduction}%`,
+        detail: charsBefore > 0
+          ? `${formatTokens(Math.round(charsBefore / 4))} before → ${formatTokens(Math.round(charsKept / 4))} after compaction`
+          : "No compaction data yet",
       },
       topTools: {
-        value: topTool ? `${topTool.tool}: ${formatTokens(topTool.tokens)}` : "N/A",
+        value: topCategory ? `${topCategory.category}: ${topCategory.cnt}` : "N/A",
         detail: top5Detail,
       },
       compactions: {
-        value: String(report.continuity.compact_count),
+        value: String(compactionCount),
         detail: compactStats
-          ? `Last: ${compactStats.summarized} msgs summarized, ${compactStats.kept} kept (~${formatTokens(compactStats.keptTokensEst)} tok)`
-          : report.continuity.compact_count > 0
-            ? `${report.continuity.compact_count} compaction(s) this session`
+          ? `Last: ${compactStats.totalMessages} messages (~${formatTokens(compactStats.tokensBefore)} tokens) → ${compactStats.kept} messages (~${formatTokens(compactStats.tokensAfterEst)} tokens)`
+          : compactionCount > 0
+            ? `${compactionCount} compaction(s) across all sessions`
             : "No compactions yet",
       },
       toolCalls: {
-        value: String(report.savings.total_calls),
-        detail: `${report.savings.total_calls} total tool calls across ${toolsWithCalls.length} tool${toolsWithCalls.length !== 1 ? "s" : ""}`,
+        value: String(totalToolCalls),
+        detail: `${totalToolCalls} events across ${toolCountRows.length} categor${toolCountRows.length !== 1 ? "ies" : "y"}`,
       },
     };
   } catch {

package/src/session/analytics.ts

@@ -66,6 +66,7 @@ export interface FullReport {
   continuity: {
     total_events: number;
     compact_count: number;
+    all_time_compact_count: number;
     resume_ready: boolean;
   };
   /** Persistent project memory — all events across all sessions */
@@ -135,6 +136,11 @@ export class AnalyticsEngine {
     ).get(sid) as { compact_count: number } | undefined;
     const compactCount = meta?.compact_count ?? 0;
 
+    // ── All-time compaction count across all sessions ──
+    const allTimeCompactions = (this.db.prepare(
+      "SELECT COALESCE(SUM(compact_count), 0) as total FROM session_meta",
+    ).get() as { total: number }).total;
+
     const resume = this.db.prepare(
       "SELECT event_count, consumed FROM session_resume WHERE session_id = ? ORDER BY created_at DESC LIMIT 1",
     ).get(sid) as { event_count: number; consumed: number } | undefined;
@@ -165,6 +171,7 @@ export class AnalyticsEngine {
       continuity: {
         total_events: eventTotal,
         compact_count: compactCount,
+        all_time_compact_count: allTimeCompactions,
         resume_ready: resumeReady,
       },
       projectMemory: {
@@ -188,7 +195,7 @@ export function createMinimalDb(): DatabaseAdapter {
   // so AnalyticsEngine queries don't fail.
   const emptyStmt = {
     run: (..._params: unknown[]) => {},
-    get: (..._params: unknown[]) => ({ cnt: 0, sessions: 0, compact_count: 0, session_id: "", event_count: 0, consumed: 1 }),
+    get: (..._params: unknown[]) => ({ cnt: 0, sessions: 0, compact_count: 0, total: 0, session_id: "", event_count: 0, consumed: 1 }),
     all: (..._params: unknown[]) => [] as unknown[],
   };
 

package/src/session/db.ts

@@ -59,9 +59,9 @@ async function getSQLite() {
 }
 
 interface PreparedStatement {
-  get(...args: any[]): any;
-  all(...args: any[]): any[];
-  run(...args: any[]): { changes: number };
+  get(...args: unknown[]): unknown;
+  all(...args: unknown[]): unknown[];
+  run(...args: unknown[]): { changes: number };
 }
 
 const MAX_EVENTS_PER_SESSION = 1000;
@@ -143,8 +143,8 @@ export class SessionDB {
       const safeAddColumn = (table: string, col: string, def: string) => {
         try {
           this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${def}`);
-        } catch (e: any) {
-          if (e?.message?.includes("duplicate column")) return;
+        } catch (e: unknown) {
+          if (e instanceof Error && e.message.includes("duplicate column")) return;
           throw e;
         }
       };
@@ -156,6 +156,21 @@ export class SessionDB {
       safeAddColumn("session_events", "data_hash", "TEXT NOT NULL DEFAULT ''");
       this.db.pragma("user_version = 1");
     }
+
+    if (currentVersion < 2) {
+      // V2: Add sandbox/search counter columns for persistent stats
+      const safeAddColumn = (table: string, col: string, def: string) => {
+        try {
+          this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${def}`);
+        } catch (e: unknown) {
+          if (e instanceof Error && e.message.includes("duplicate column")) return;
+          throw e;
+        }
+      };
+      safeAddColumn("session_meta", "sandbox_runs", "INTEGER NOT NULL DEFAULT 0");
+      safeAddColumn("session_meta", "search_queries", "INTEGER NOT NULL DEFAULT 0");
+      this.db.pragma("user_version = 2");
+    }
   }
 
   private prepareStatements(): void {
@@ -171,10 +186,12 @@ export class SessionDB {
     p("evictLowestPriority", `DELETE FROM session_events WHERE id = (SELECT id FROM session_events WHERE session_id = ? ORDER BY priority ASC, id ASC LIMIT 1)`);
     p("updateMetaLastEvent", `UPDATE session_meta SET last_event_at = datetime('now'), event_count = event_count + 1 WHERE session_id = ?`);
     p("ensureSession", `INSERT OR IGNORE INTO session_meta (session_id, project_dir) VALUES (?, ?)`);
-    p("getSessionStats", `SELECT session_id, project_dir, started_at, last_event_at, event_count, compact_count, total_chars_before, total_chars_kept, total_messages_summarized FROM session_meta WHERE session_id = ?`);
+    p("getSessionStats", `SELECT session_id, project_dir, started_at, last_event_at, event_count, compact_count, total_chars_before, total_chars_kept, total_messages_summarized, sandbox_runs, search_queries FROM session_meta WHERE session_id = ?`);
     p("incrementCompactCount", `UPDATE session_meta SET compact_count = compact_count + 1 WHERE session_id = ?`);
     p("addCompactionStats", `UPDATE session_meta SET total_chars_before = total_chars_before + ?, total_chars_kept = total_chars_kept + ?, total_messages_summarized = total_messages_summarized + ? WHERE session_id = ?`);
-    p("getAllTimeStats", `SELECT COALESCE(SUM(total_chars_before), 0) AS all_chars_before, COALESCE(SUM(total_chars_kept), 0) AS all_chars_kept, COALESCE(SUM(total_messages_summarized), 0) AS all_messages_summarized, COALESCE(SUM(compact_count), 0) AS all_compactions FROM session_meta`);
+    p("getAllTimeStats", `SELECT COALESCE(SUM(total_chars_before), 0) AS all_chars_before, COALESCE(SUM(total_chars_kept), 0) AS all_chars_kept, COALESCE(SUM(total_messages_summarized), 0) AS all_messages_summarized, COALESCE(SUM(compact_count), 0) AS all_compactions, COALESCE(SUM(sandbox_runs), 0) AS all_sandbox_runs, COALESCE(SUM(search_queries), 0) AS all_search_queries FROM session_meta`);
+    p("incrementSandboxRuns", `UPDATE session_meta SET sandbox_runs = sandbox_runs + 1 WHERE session_id = ?`);
+    p("incrementSearchQueries", `UPDATE session_meta SET search_queries = search_queries + 1 WHERE session_id = ?`);
     p("upsertResume", `INSERT INTO session_resume (session_id, snapshot, event_count) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET snapshot = excluded.snapshot, event_count = excluded.event_count, created_at = datetime('now'), consumed = 0`);
     p("getResume", `SELECT snapshot, event_count, consumed FROM session_resume WHERE session_id = ?`);
     p("markResumeConsumed", `UPDATE session_resume SET consumed = 1 WHERE session_id = ?`);
@@ -248,17 +265,29 @@ export class SessionDB {
     this.stmt("addCompactionStats").run(charsBefore, charsKept, messagesSummarized, sessionId);
   }
 
-  getAllTimeStats(): { allCharsBefore: number; allCharsKept: number; allMessagesSummarized: number; allCompactions: number } {
-    if (!this.stmts) return { allCharsBefore: 0, allCharsKept: 0, allMessagesSummarized: 0, allCompactions: 0 };
-    const row = this.stmt("getAllTimeStats").get() as { all_chars_before: number; all_chars_kept: number; all_messages_summarized: number; all_compactions: number };
+  getAllTimeStats(): { allCharsBefore: number; allCharsKept: number; allMessagesSummarized: number; allCompactions: number; allSandboxRuns: number; allSearchQueries: number } {
+    if (!this.stmts) return { allCharsBefore: 0, allCharsKept: 0, allMessagesSummarized: 0, allCompactions: 0, allSandboxRuns: 0, allSearchQueries: 0 };
+    const row = this.stmt("getAllTimeStats").get() as { all_chars_before: number; all_chars_kept: number; all_messages_summarized: number; all_compactions: number; all_sandbox_runs: number; all_search_queries: number };
     return {
       allCharsBefore: row?.all_chars_before ?? 0,
       allCharsKept: row?.all_chars_kept ?? 0,
       allMessagesSummarized: row?.all_messages_summarized ?? 0,
       allCompactions: row?.all_compactions ?? 0,
+      allSandboxRuns: row?.all_sandbox_runs ?? 0,
+      allSearchQueries: row?.all_search_queries ?? 0,
     };
   }
 
+  incrementSandboxRuns(sessionId: string): void {
+    if (!this.stmts) return;
+    this.stmt("incrementSandboxRuns").run(sessionId);
+  }
+
+  incrementSearchQueries(sessionId: string): void {
+    if (!this.stmts) return;
+    this.stmt("incrementSearchQueries").run(sessionId);
+  }
+
   upsertResume(sessionId: string, snapshot: string, eventCount?: number): void {
     if (!this.stmts) return;
     this.stmt("upsertResume").run(sessionId, snapshot, eventCount ?? 0);
@@ -294,7 +323,7 @@ export class SessionDB {
   }
 
   /** Expose the underlying db for AnalyticsEngine (read-only queries). Returns null if init failed. */
-  getDb(): any { return this.db ?? null; }
+  getDb(): { prepare(sql: string): { get(...args: unknown[]): unknown; all(...args: unknown[]): unknown[]; run(...args: unknown[]): { changes: number } }; exec(sql: string): void; close(): void } | null { return this.db as ReturnType<typeof this.getDb> ?? null; }
 
   close(): void {
     try { this.db.close(); } catch { /* ignore */ }

package/src/session/extract.ts

@@ -73,6 +73,43 @@ export function extractEventsFromToolResult(result: ToolResult): SessionEvent[]
     });
   }
 
+  // Sandbox execution
+  if (["sandbox", "ctx_execute", "sandbox_file", "ctx_execute_file", "sandbox_batch", "ctx_batch_execute"].includes(result.toolName)) {
+    const language = String(result.toolInput.language ?? "unknown");
+    const code = String(result.toolInput.code ?? "").slice(0, 200);
+    events.push({
+      type: "sandbox_execution",
+      category: "sandbox",
+      data: `[${language}] ${code}`,
+      priority: EventPriority.LOW,
+      data_hash: "",
+    });
+  }
+
+  // Content search queries
+  if (["content_search", "ctx_search"].includes(result.toolName)) {
+    const query = String(result.toolInput.query ?? "").slice(0, 200);
+    events.push({
+      type: "content_search",
+      category: "search",
+      data: query,
+      priority: EventPriority.LOW,
+      data_hash: "",
+    });
+  }
+
+  // Content indexing
+  if (["content_index", "ctx_index", "content_fetch", "ctx_fetch_and_index"].includes(result.toolName)) {
+    const label = String(result.toolInput.label ?? result.toolInput.url ?? "").slice(0, 200);
+    events.push({
+      type: "content_indexed",
+      category: "index",
+      data: label,
+      priority: EventPriority.LOW,
+      data_hash: "",
+    });
+  }
+
   return events;
 }
 

package/src/tools/ctx-batch-execute.ts

@@ -1,10 +1,9 @@
 /**
- * ctx_batch_execute tool — atomic batch of commands + searches
+ * ctx_batch_execute tool — atomic batch of commands
  */
 
 import { PolyglotExecutor } from "../executor/executor.js";
-import type { ContentStore } from "../store/index.js";
-import type { Language, ExecResult, SearchResult } from "../types.js";
+import type { Language, ExecResult } from "../types.js";
 
 export interface BatchCommand {
   type: "execute";
@@ -13,22 +12,15 @@ export interface BatchCommand {
   timeout?: number;
 }
 
-export interface BatchSearch {
-  type: "search";
-  query: string;
-  limit?: number;
-}
-
-export type BatchItem = BatchCommand | BatchSearch;
+export type BatchItem = BatchCommand;
 
 export interface BatchResult {
   results: Array<
-    | { type: "execute"; result: ExecResult }
-    | { type: "search"; results: SearchResult[] }
+    { type: "execute"; result: ExecResult }
   >;
 }
 
-export async function ctxBatchExecute(store: ContentStore, items: BatchItem[]): Promise<BatchResult> {
+export async function ctxBatchExecute(items: BatchItem[]): Promise<BatchResult> {
   const results: BatchResult["results"] = [];
   const executor = new PolyglotExecutor();
 
@@ -40,9 +32,6 @@ export async function ctxBatchExecute(store: ContentStore, items: BatchItem[]):
         timeout: item.timeout ?? 30000,
       });
       results.push({ type: "execute", result });
-    } else {
-      const searchResults = await store.search(item.query, { limit: item.limit ?? 10 });
-      results.push({ type: "search", results: searchResults });
     }
   }
 

package/src/tools/ctx-doctor.ts

@@ -5,7 +5,6 @@
 import { existsSync } from "node:fs";
 import { COMPACTOR_CONFIG_PATH } from "../config/manager.js";
 import type { SessionDB } from "../session/db.js";
-import type { ContentStore } from "../store/index.js";
 
 export interface DoctorResult {
   healthy: boolean;
@@ -18,7 +17,6 @@ export interface DoctorResult {
 
 export async function ctxDoctor(
   sessionDB: SessionDB,
-  contentStore: ContentStore,
 ): Promise<DoctorResult> {
   const checks: DoctorResult["checks"] = [];
 
@@ -45,22 +43,6 @@ export async function ctxDoctor(
     });
   }
 
-  // Content store check
-  try {
-    const stats = await contentStore.getStats();
-    checks.push({
-      name: "Content Store",
-      status: "pass",
-      message: `FTS5 index: ${stats.sources} sources, ${stats.chunks} chunks`,
-    });
-  } catch (err) {
-    checks.push({
-      name: "Content Store",
-      status: "fail",
-      message: `FTS5 error: ${err}`,
-    });
-  }
-
   // Runtime checks
   const runtimes = ["node", "python3", "bash"];
   for (const rt of runtimes) {

package/src/tools/ctx-stats.ts

@@ -1,9 +1,10 @@
 /**
  * ctx_stats tool — context savings dashboard
+ *
+ * Stats driven by compaction savings (DB-first) with runtime counter fallback.
  */
 
 import type { SessionDB } from "../session/db.js";
-import type { ContentStore } from "../store/index.js";
 import type { RuntimeCounters } from "../types.js";
 
 export interface CtxStatsResult {
@@ -11,29 +12,85 @@ export interface CtxStatsResult {
   compactions: number;
   tokensSaved: number;
   compressionRatio: string;
-  indexedDocs: number;
-  indexedChunks: number;
   sandboxRuns: number;
   searchQueries: number;
 }
 
 export async function ctxStats(
   sessionDB: SessionDB,
-  contentStore: ContentStore,
   sessionId: string,
   counters?: RuntimeCounters,
 ): Promise<CtxStatsResult> {
   const sessionStats = sessionDB.getSessionStats(sessionId);
-  const storeStats = await contentStore.getStats();
+
+  // Compute tokensSaved: prefer in-memory counters (current session),
+  // fall back to per-session DB stats, then all-time DB stats.
+  let tokensSaved = counters?.totalTokensCompacted ?? 0;
+  if (tokensSaved === 0 && sessionStats) {
+    const sessionCharsBefore = (sessionStats as any).total_chars_before ?? 0;
+    const sessionCharsKept = (sessionStats as any).total_chars_kept ?? 0;
+    tokensSaved = Math.round((sessionCharsBefore - sessionCharsKept) / 4);
+  }
+  if (tokensSaved === 0) {
+    const allTime = sessionDB.getAllTimeStats();
+    tokensSaved = Math.round((allTime.allCharsBefore - allTime.allCharsKept) / 4);
+  }
+
+  // Compute compactions: prefer in-memory counter (current session),
+  // fall back to per-session DB, then all-time DB.
+  let compactions = counters?.compactions ?? 0;
+  if (compactions === 0) {
+    compactions = sessionStats?.compact_count ?? 0;
+  }
+  if (compactions === 0) {
+    const allTime = sessionDB.getAllTimeStats();
+    compactions = allTime.allCompactions;
+  }
+
+  // Compression ratio
+  let ratio = "N/A";
+  if (sessionStats) {
+    const before = (sessionStats as any).total_chars_before ?? 0;
+    const kept = (sessionStats as any).total_chars_kept ?? 0;
+    if (before > 0 && kept > 0) {
+      ratio = `${(before / kept).toFixed(1)}:1`;
+    }
+  }
 
   return {
     sessionEvents: sessionStats?.event_count ?? 0,
-    compactions: counters?.compactions ?? sessionStats?.compact_count ?? 0,
-    tokensSaved: counters?.totalTokensCompacted ?? 0,
-    compressionRatio: "N/A",
-    indexedDocs: storeStats.sources,
-    indexedChunks: storeStats.chunks,
-    sandboxRuns: counters?.sandboxRuns ?? 0,
-    searchQueries: counters?.searchQueries ?? 0,
+    compactions,
+    tokensSaved,
+    compressionRatio: ratio,
+    sandboxRuns: computeSandboxRuns(counters, sessionDB, sessionId),
+    searchQueries: computeSearchQueries(counters, sessionDB, sessionId),
   };
 }
+
+/** Compute sandbox runs: prefer in-memory counter, fall back to DB. */
+function computeSandboxRuns(counters: RuntimeCounters | undefined, sessionDB: SessionDB, sessionId: string): number {
+  let sandboxRuns = counters?.sandboxRuns ?? 0;
+  if (sandboxRuns === 0) {
+    const sessionStats = sessionDB.getSessionStats(sessionId);
+    sandboxRuns = (sessionStats as any)?.sandbox_runs ?? 0;
+  }
+  if (sandboxRuns === 0) {
+    const allTime = sessionDB.getAllTimeStats();
+    sandboxRuns = allTime.allSandboxRuns;
+  }
+  return sandboxRuns;
+}
+
+/** Compute search queries: prefer in-memory counter, fall back to DB. */
+function computeSearchQueries(counters: RuntimeCounters | undefined, sessionDB: SessionDB, sessionId: string): number {
+  let searchQueries = counters?.searchQueries ?? 0;
+  if (searchQueries === 0) {
+    const sessionStats = sessionDB.getSessionStats(sessionId);
+    searchQueries = (sessionStats as any)?.search_queries ?? 0;
+  }
+  if (searchQueries === 0) {
+    const allTime = sessionDB.getAllTimeStats();
+    searchQueries = allTime.allSearchQueries;
+  }
+  return searchQueries;
+}