@pi-unipi/compactor 0.2.3 → 2.0.0

package/src/config/presets.ts

@@ -11,16 +11,16 @@ const preset = (
 ): CompactorConfig => ({
   ...structuredClone(DEFAULT_COMPACTOR_CONFIG),
   ...overrides,
-  sessionGoals: { ...DEFAULT_COMPACTOR_CONFIG.sessionGoals, ...(overrides.sessionGoals as any) },
-  filesAndChanges: { ...DEFAULT_COMPACTOR_CONFIG.filesAndChanges, ...(overrides.filesAndChanges as any) },
-  commits: { ...DEFAULT_COMPACTOR_CONFIG.commits, ...(overrides.commits as any) },
-  outstandingContext: { ...DEFAULT_COMPACTOR_CONFIG.outstandingContext, ...(overrides.outstandingContext as any) },
-  userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, ...(overrides.userPreferences as any) },
-  briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, ...(overrides.briefTranscript as any) },
-  sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, ...(overrides.sessionContinuity as any) },
-  fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, ...(overrides.fts5Index as any) },
-  sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, ...(overrides.sandboxExecution as any) },
-  toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, ...(overrides.toolDisplay as any) },
+  sessionGoals: { ...DEFAULT_COMPACTOR_CONFIG.sessionGoals, ...(overrides.sessionGoals ?? {}) },
+  filesAndChanges: { ...DEFAULT_COMPACTOR_CONFIG.filesAndChanges, ...(overrides.filesAndChanges ?? {}) },
+  commits: { ...DEFAULT_COMPACTOR_CONFIG.commits, ...(overrides.commits ?? {}) },
+  outstandingContext: { ...DEFAULT_COMPACTOR_CONFIG.outstandingContext, ...(overrides.outstandingContext ?? {}) },
+  userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, ...(overrides.userPreferences ?? {}) },
+  briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, ...(overrides.briefTranscript ?? {}) },
+  sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, ...(overrides.sessionContinuity ?? {}) },
+  fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index, ...(overrides.fts5Index ?? {}) },
+  sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, ...(overrides.sandboxExecution ?? {}) },
+  toolDisplay: { ...DEFAULT_COMPACTOR_CONFIG.toolDisplay, ...(overrides.toolDisplay ?? {}) },
 });
 
 // Pipeline feature defaults per preset:

package/src/executor/executor.ts

@@ -122,11 +122,11 @@ export class PolyglotExecutor {
       }
 
       return result;
-    } catch (err: any) {
+    } catch (err: unknown) {
       try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
       return {
         stdout: "",
-        stderr: err?.message ?? String(err),
+        stderr: (err instanceof Error ? err.message : String(err)),
         exitCode: 1,
         timedOut: false,
       };
@@ -228,10 +228,10 @@ export class PolyglotExecutor {
         timeout: timeout / 2,
         stdio: ["ignore", "pipe", "pipe"],
       });
-    } catch (err: any) {
+    } catch (err: unknown) {
       return {
         stdout: "",
-        stderr: err?.stderr?.toString?.() ?? err?.message ?? "Rust compilation failed",
+        stderr: (err instanceof Error && 'stderr' in err ? String((err as Error & { stderr?: Buffer }).stderr) : '') || (err instanceof Error ? err.message : String(err)) || "Rust compilation failed",
         exitCode: 1,
         timedOut: false,
       };

package/src/index.ts

@@ -9,7 +9,6 @@ import { registerCompactionHooks } from "./compaction/hooks.js";
 import { SessionDB, getWorktreeSuffix } from "./session/db.js";
 import { extractEventsFromToolResult } from "./session/extract.js";
 import { injectResumeSnapshot } from "./session/resume-inject.js";
-import { ContentStore } from "./store/index.js";
 import { PolyglotExecutor } from "./executor/executor.js";
 import { registerCommands } from "./commands/index.js";
 import { registerCompactorTools } from "./tools/register.js";
@@ -57,7 +56,6 @@ function isIndexTool(_name: string): boolean {
 
 export default function compactorExtension(pi: ExtensionAPI): void {
   let sessionDB: SessionDB | null = null;
-  let contentStore: ContentStore | null = null;
   let executor: PolyglotExecutor | null = null;
   let config = loadConfig();
   let cachedBlocks: NormalizedBlock[] = [];
@@ -101,19 +99,6 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       sessionDB = null;
     }
 
-    // Initialize ContentStore independently — its failure shouldn't
-    // prevent SessionDB commands from working.
-    if (config.fts5Index.enabled) {
-      try {
-        const cs = new ContentStore();
-        await cs.init();
-        contentStore = cs;
-      } catch {
-        // Silently ignore — ContentStore init failure is handled gracefully.
-        contentStore = null;
-      }
-    }
-
     executor = new PolyglotExecutor();
   };
 
@@ -127,7 +112,6 @@ export default function compactorExtension(pi: ExtensionAPI): void {
   // Commands registered inside session_start after init() when deps are ready
   const getCommandDeps = () => ({
     sessionDB,
-    contentStore,
     getSessionId: () => currentSessionId,
     getBlocks: () => cachedBlocks,
     getCounters,
@@ -144,6 +128,17 @@ export default function compactorExtension(pi: ExtensionAPI): void {
 
     debug("session_start", { sessionId: fullSessionId, projectDir });
 
+    // Seed runtime counters from DB so they reflect prior usage
+    if (sessionDB) {
+      try {
+        const allTime = sessionDB.getAllTimeStats();
+        counters.sandboxRuns = allTime.allSandboxRuns;
+        counters.searchQueries = allTime.allSearchQueries;
+      } catch {
+        // Non-fatal: counter seeding from DB failed
+      }
+    }
+
     // Reset runtime stats for new session
     runtimeStats.bytesReturned = {};
     runtimeStats.bytesIndexed = 0;
@@ -159,7 +154,6 @@ export default function compactorExtension(pi: ExtensionAPI): void {
     if (sessionDB) {
       registerCompactorTools(pi, {
         sessionDB,
-        contentStore,
         getSessionId: () => currentSessionId,
         getBlocks: () => cachedBlocks,
         getCounters,
@@ -170,7 +164,7 @@ export default function compactorExtension(pi: ExtensionAPI): void {
     registerCommands(pi, getCommandDeps());
 
     // Register info-screen group
-    const infoRegistry = (globalThis as any).__unipi_info_registry;
+    const infoRegistry = globalThis.__unipi_info_registry;
     if (infoRegistry && sessionDB) {
       const sdb = sessionDB;
       const sid = () => currentSessionId;
@@ -193,7 +187,7 @@ export default function compactorExtension(pi: ExtensionAPI): void {
         dataProvider: async () => {
           try {
             const { getInfoScreenData } = await import("./info-screen.js");
-            const data = await getInfoScreenData(sdb, sid(), runtimeStats);
+            const data = await getInfoScreenData(sdb, sid(), getCounters());
             return {
               tokensSaved: { value: data.tokensSaved.value, detail: data.tokensSaved.detail },
               costSaved: { value: data.costSaved.value, detail: data.costSaved.detail },
@@ -209,7 +203,7 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       });
     }
 
-    emitEvent(pi as any, UNIPI_EVENTS.MODULE_READY, {
+    emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
       name: MODULES.COMPACTOR,
       version: "0.1.0",
       commands: Object.values(COMPACTOR_COMMANDS),
@@ -218,10 +212,6 @@ export default function compactorExtension(pi: ExtensionAPI): void {
 
     debug("MODULE_READY", { commands: Object.values(COMPACTOR_COMMANDS), tools: Object.values(COMPACTOR_TOOLS) });
 
-    if (config.fts5Index.mode === "auto" && contentStore) {
-      // TODO: index project files
-    }
-
     ctx.ui.notify("🗜️  Compactor ready", "info");
   });
 
@@ -237,7 +227,6 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       const { join } = await import("node:path");
       const strategies: Array<{ key: string; config: CompactorStrategyConfig }> = [
         { key: "commits", config: config.commits },
-        { key: "fts5Index", config: config.fts5Index },
       ];
       for (const { key, config: strat } of strategies) {
         if ((strat as any).autoDetect === "git") {
@@ -315,44 +304,44 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       const compactionEntry = (event as any).compactionEntry;
       const tokensBefore = compactionEntry?.tokensBefore ?? 0;
 
-      // Use actual runtimeStats for byte measurement instead of heuristic
-      const totalBytesReturned = Object.values(runtimeStats.bytesReturned).reduce((s, b) => s + b, 0);
-      const totalBytesProcessed = runtimeStats.bytesIndexed + runtimeStats.bytesSandboxed + totalBytesReturned;
-
       if (tokensBefore > 0) {
-        // Use actual token count from Pi's compactionEntry
+        // Use actual token count from Pi's compactionEntry.
+        // Compaction typically keeps ~10-15% of original context.
         const charsBefore = tokensBefore * 4;
-        // Estimate kept chars: proportional to what remains after compaction
-        const tokensAfter = (event as any).tokensAfter ?? Math.round(tokensBefore * 0.15);
+        const tokensAfter = (event as any).tokensAfter ?? Math.round(tokensBefore * 0.12);
         const charsKept = tokensAfter * 4;
         const messagesSummarized = Math.max(1, Math.round(tokensBefore / 500));
         counters.totalTokensCompacted += tokensBefore - tokensAfter;
         sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, messagesSummarized);
       } else {
-        // Fallback: estimate from runtime byte stats when tokensBefore unavailable
-        if (totalBytesProcessed > 0) {
-          const charsBefore = totalBytesProcessed;
-          const charsKept = totalBytesReturned;
-          const messagesSummarized = Math.max(1, Math.round(totalBytesProcessed / 2000));
-          const estTokensBefore = Math.round(totalBytesProcessed / 4);
-          const estTokensAfter = Math.round(totalBytesReturned / 4);
-          counters.totalTokensCompacted += Math.max(0, estTokensBefore - estTokensAfter);
-          sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, messagesSummarized);
+        // tokensBefore unavailable — use session event count as a rough heuristic.
+        // This happens when Pi's compaction doesn't report tokensBefore.
+        // We estimate from the number of events stored in this session.
+        try {
+          const eventCount = sessionDB.getEventCount(sessionId);
+          if (eventCount > 0) {
+            // Rough estimate: ~500 tokens per event on average
+            const estTokensBefore = eventCount * 500;
+            const estTokensAfter = Math.round(estTokensBefore * 0.12);
+            const charsBefore = estTokensBefore * 4;
+            const charsKept = estTokensAfter * 4;
+            counters.totalTokensCompacted += estTokensBefore - estTokensAfter;
+            sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, eventCount);
+          }
+        } catch {
+          // Non-fatal: heuristic estimation failed
         }
       }
-      debug("session_compact", { sessionId, tokensBefore, totalBytesProcessed, hasCompactionEntry: !!compactionEntry });
+      debug("session_compact", { sessionId, tokensBefore, hasCompactionEntry: !!compactionEntry });
     }
   });
 
   pi.on("session_shutdown", async (_event, _ctx) => {
     debug("session_shutdown");
-    // WAL checkpoint: TRUNCATE on shutdown to keep DB file size down
-    contentStore?.checkpointWAL("TRUNCATE");
     if (sessionDB) {
       sessionDB.cleanupOldSessions(7);
     }
     executor?.cleanupBackgrounded();
-    contentStore?.close();
     sessionDB?.close();
   });
 

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(Math.max(report.continuity.compact_count, report.continuity.all_time_compact_count)),
+        value: String(compactionCount),
         detail: compactStats
-          ? `Last: ${compactStats.summarized} msgs summarized, ${compactStats.kept} kept (~${formatTokens(compactStats.keptTokensEst)} tok)`
-          : report.continuity.all_time_compact_count > 0
-            ? `${report.continuity.all_time_compact_count} compaction(s) across all sessions`
+          ? `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/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) {