@pi-unipi/compactor 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/compactor",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Context engine for Pi — zero-LLM compaction, session continuity, sandbox execution, FTS5 search, and tool display optimization",
   "type": "module",
   "license": "MIT",
@@ -38,7 +38,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "*"
+    "@pi-unipi/core": "*",
+    "@pi-unipi/info-screen": "*"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*",

package/src/commands/index.ts

@@ -34,8 +34,8 @@ export interface CommandDeps {
   getCounters?: () => RuntimeCounters;
 }
 
-function deprecationLog(oldName: string, newName: string): void {
-  console.error(`[compactor] DEPRECATED: Command "${oldName}" used — use "${newName}" instead.`);
+function deprecationLog(_oldName: string, _newName: string): void {
+  // Deprecation logging disabled — was writing to stdout causing TUI rendering issues.
 }
 
 export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {

package/src/compaction/hooks.ts

@@ -21,11 +21,9 @@ const formatTokens = (n: number): string => {
   return String(n);
 };
 
-const dbg = (debug: boolean, event: string, data?: Record<string, unknown>) => {
-  if (!debug) return;
-  const ts = new Date().toISOString().slice(11, 23);
-  const details = data ? " " + JSON.stringify(data) : "";
-  console.error(`[compactor:${ts}] ${event}${details}`);
+const dbg = (_debug: boolean, _event: string, _data?: Record<string, unknown>) => {
+  // Debug logging disabled — was writing to stdout causing TUI rendering issues.
+  return;
 };
 
 const previewContent = (content: unknown): string => {

package/src/config/schema.ts

@@ -58,7 +58,7 @@ export const DEFAULT_COMPACTOR_CONFIG: CompactorConfig = {
     mmapPragma: false,
     customNoisePatterns: [],
   },
-  overrideDefaultCompaction: false,
+  overrideDefaultCompaction: true,
   debug: false,
   showTruncationHints: true,
 };

package/src/display/diff-presentation.ts

@@ -3,6 +3,7 @@
  */
 
 import type { DiffLayout } from "../types.js";
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
 
 export function selectDiffLayout(
   terminalWidth: number,
@@ -12,9 +13,13 @@ export function selectDiffLayout(
   return terminalWidth >= 100 ? "split" : "unified";
 }
 
+/** Clamp text to maxWidth visible columns, ANSI-aware */
 export function clampWidth(text: string, maxWidth: number): string {
   return text
     .split("\n")
-    .map((line) => (line.length > maxWidth ? line.slice(0, maxWidth - 3) + "..." : line))
+    .map((line) => {
+      if (visibleWidth(line) <= maxWidth) return line;
+      return truncateToWidth(line, maxWidth, "…");
+    })
     .join("\n");
 }

package/src/display/diff-renderer.ts

@@ -3,6 +3,8 @@
  * syntax highlighting, and Nerd Font detection
  */
 
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
+
 export type DiffLayout = "auto" | "split" | "unified";
 export type DiffIndicator = "bars" | "classic" | "nerd" | "none";
 
@@ -150,16 +152,28 @@ function indicatorChar(type: DiffLine["type"], style: DiffIndicator): string {
   return type === "add" ? "+ " : type === "remove" ? "- " : "  ";
 }
 
-function renderUnified(diff: DiffLine[], indicator: DiffIndicator): string {
+function renderUnified(
+  diff: DiffLine[],
+  indicator: DiffIndicator,
+  maxWidth?: number,
+): string {
   return diff.map((line) => {
     const prefix = indicator === "bars"
       ? (line.type === "add" ? "│ " : line.type === "remove" ? "│ " : "  ")
       : indicatorChar(line.type, indicator);
-    return prefix + line.text;
+    const rendered = prefix + line.text;
+    if (maxWidth && visibleWidth(rendered) > maxWidth) {
+      return truncateToWidth(rendered, maxWidth, "…");
+    }
+    return rendered;
   }).join("\n");
 }
 
-function renderSplit(diff: DiffLine[], indicator: DiffIndicator): string {
+function renderSplit(
+  diff: DiffLine[],
+  indicator: DiffIndicator,
+  maxW?: number,
+): string {
   const left: string[] = [];
   const right: string[] = [];
 
@@ -176,12 +190,24 @@ function renderSplit(diff: DiffLine[], indicator: DiffIndicator): string {
     }
   }
 
-  const maxWidth = Math.max(...left.map((l) => l.length), 40);
+  const halfW = maxW ? Math.floor(maxW / 2) - 2 : 40;
+  const colW = Math.max(
+    ...left.map((l) => visibleWidth(l)),
+    ...right.map((l) => visibleWidth(l)),
+    Math.min(halfW, 40),
+  );
   const result: string[] = [];
   for (let i = 0; i < left.length; i++) {
-    const l = left[i].padEnd(maxWidth);
+    const lTrunc = visibleWidth(left[i]) > colW
+      ? truncateToWidth(left[i], colW, "…")
+      : left[i].padEnd(colW);
     const sep = left[i] && right[i] ? " │ " : "   ";
-    result.push(l + sep + right[i]);
+    let rLine = right[i];
+    if (maxW && visibleWidth(lTrunc + sep + rLine) > maxW) {
+      const rBudget = maxW - visibleWidth(lTrunc + sep);
+      rLine = truncateToWidth(rLine, Math.max(1, rBudget), "…");
+    }
+    result.push(lTrunc + sep + rLine);
   }
 
   return result.join("\n");
@@ -229,10 +255,10 @@ export function renderDiff(
   }
 
   if (effectiveLayout === "split") {
-    return renderSplit(highlightedDiff, effectiveIndicator);
+    return renderSplit(highlightedDiff, effectiveIndicator, maxWidth);
   }
 
-  return renderUnified(highlightedDiff, effectiveIndicator);
+  return renderUnified(highlightedDiff, effectiveIndicator, maxWidth);
 }
 
 export function renderEditDiffResult(

package/src/display/diff-width-safety.ts

@@ -0,0 +1,83 @@
+/**
+ * Diff width safety — truncate diff lines to terminal width
+ *
+ * Pi's renderDiff() in diff.js produces lines without width
+ * truncation. When a diff line's visible content exceeds the
+ * terminal width, the TUI crashes with:
+ *   "Rendered line N exceeds terminal width (X > Y)"
+ *
+ * This module provides clampDiffToWidth() which truncates
+ * each diff line to a safe width, preventing TUI crashes.
+ *
+ * The diff format from pi's generateDiffString() is:
+ *   [+/-/ ]LINE_NUM CONTENT
+ * e.g.: "+       38 │ The root cause is a **compound failure**..."
+ *
+ * We detect the terminal width from process.stdout and clamp
+ * each line, accounting for the rendering overhead of the
+ * edit tool's Box nesting (approx 4-6 chars of padding).
+ */
+
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
+
+/** Rendering overhead from Box nesting in edit tool components */
+const RENDER_OVERHEAD = 6;
+
+/** Minimum useful line width (don't clamp below this) */
+const MIN_LINE_WIDTH = 20;
+
+/**
+ * Get the terminal width with fallback.
+ * Uses process.stdout.columns (updated on resize).
+ */
+function getTerminalWidth(): number {
+  return process.stdout?.columns ?? 80;
+}
+
+/**
+ * Clamp a diff string so every line fits within terminal width.
+ * Preserves the diff prefix (+/-/ ) and line number while
+ * truncating the content portion.
+ *
+ * @param diff - The diff string from generateDiffString()
+ * @param maxWidth - Override for terminal width (for testing)
+ * @returns The clamped diff string (may be same reference if no clamping needed)
+ */
+export function clampDiffToWidth(
+  diff: string,
+  maxWidth?: number,
+): string {
+  const termW = maxWidth ?? getTerminalWidth();
+  const safeW = Math.max(MIN_LINE_WIDTH, termW - RENDER_OVERHEAD);
+
+  const lines = diff.split("\n");
+  let changed = false;
+
+  const result = lines.map((line) => {
+    const vw = visibleWidth(line);
+    if (vw <= safeW) return line;
+
+    changed = true;
+
+    // Try to preserve the diff prefix (+/-/ ) and line number
+    // Format: [+/-/ ]LINE_NUM CONTENT
+    // The prefix and line number are critical for readability
+    const prefixMatch = line.match(/^([+\- ])\s*(\d*)\s/);
+    if (prefixMatch) {
+      const prefixLen = prefixMatch[0].length;
+      // Calculate how much content we can keep
+      const contentBudget = safeW - prefixLen;
+      if (contentBudget >= MIN_LINE_WIDTH) {
+        const prefix = line.slice(0, prefixLen);
+        const content = line.slice(prefixLen);
+        const truncated = truncateToWidth(content, contentBudget, "…");
+        return prefix + truncated;
+      }
+    }
+
+    // Fallback: truncate the entire line
+    return truncateToWidth(line, safeW, "…");
+  });
+
+  return changed ? result.join("\n") : diff;
+}

package/src/display/line-width-safety.ts

@@ -1,11 +1,23 @@
 /**
  * Line width safety — width clamping with collapsed hints
+ *
+ * Uses ANSI-aware visibleWidth measurement from pi-tui to properly
+ * handle lines containing escape codes. Falls back to raw-length
+ * measurement when pi-tui is unavailable.
  */
 
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
+
+/**
+ * Clamp each line to maxWidth visible columns.
+ * Uses pi-tui's visibleWidth() for ANSI-aware measurement and
+ * truncateToWidth() for ANSI-safe truncation.
+ */
 export function clampLineWidth(lines: string[], maxWidth: number): string[] {
   return lines.map((line) => {
-    if (line.length <= maxWidth) return line;
-    return line.slice(0, maxWidth - 3) + "...";
+    const vw = visibleWidth(line);
+    if (vw <= maxWidth) return line;
+    return truncateToWidth(line, maxWidth, "…");
   });
 }
 

package/src/index.ts

@@ -16,17 +16,45 @@ import { registerCompactorTools } from "./tools/register.js";
 import { normalizeMessages } from "./compaction/normalize.js";
 import { filterNoise } from "./compaction/filter-noise.js";
 import type { NormalizedBlock, CompactorStrategyConfig, RuntimeCounters } from "./types.js";
+import type { RuntimeStats } from "./session/analytics.js";
 
 /** Debug logger — only logs when config.debug === true */
 function createDebugLogger(getConfig: () => { debug: boolean }) {
-  return (event: string, data?: Record<string, unknown>) => {
-    if (!getConfig().debug) return;
-    const ts = new Date().toISOString().slice(11, 23);
-    const details = data ? " " + JSON.stringify(data) : "";
-    console.error(`[compactor:${ts}] ${event}${details}`);
+  return (_event: string, _data?: Record<string, unknown>) => {
+    // Debug logging disabled — was writing to stdout causing TUI rendering issues.
+    return;
   };
 }
 
+/** Measure byte size of a tool_result event's response content. */
+function measureResponseBytes(event: any): number {
+  try {
+    const content = event.content;
+    if (typeof content === "string") return Buffer.byteLength(content, "utf-8");
+    if (Array.isArray(content)) {
+      return content.reduce((sum: number, block: any) => {
+        if (typeof block?.text === "string") return sum + Buffer.byteLength(block.text, "utf-8");
+        if (typeof block === "string") return sum + Buffer.byteLength(block, "utf-8");
+        return sum;
+      }, 0);
+    }
+    if (event.output && typeof event.output === "string") return Buffer.byteLength(event.output, "utf-8");
+  } catch {
+    // Non-blocking: byte measurement errors silently skipped
+  }
+  return 0;
+}
+
+/** Check if a tool is a sandbox tool (output stays in sandbox, not context). */
+function isSandboxTool(name: string): boolean {
+  return name === "bash" || name === "Bash";
+}
+
+/** Check if a tool is an index tool (content goes to FTS5, not context). Future-proofing. */
+function isIndexTool(_name: string): boolean {
+  return false;
+}
+
 export default function compactorExtension(pi: ExtensionAPI): void {
   let sessionDB: SessionDB | null = null;
   let contentStore: ContentStore | null = null;
@@ -43,6 +71,16 @@ export default function compactorExtension(pi: ExtensionAPI): void {
   };
   const getCounters = () => counters;
 
+  const runtimeStats: RuntimeStats = {
+    bytesReturned: {},
+    bytesIndexed: 0,
+    bytesSandboxed: 0,
+    calls: {},
+    sessionStart: Date.now(),
+    cacheHits: 0,
+    cacheBytesSaved: 0,
+  };
+
   const debug = createDebugLogger(() => config);
 
   const init = async () => {
@@ -58,8 +96,8 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       const db = new SessionDB();
       await db.init();
       sessionDB = db;
-    } catch (err) {
-      console.error(`[compactor] SessionDB init failed: ${String(err)}`);
+    } catch {
+      // Silently ignore — SessionDB init failure is handled gracefully.
       sessionDB = null;
     }
 
@@ -70,8 +108,8 @@ export default function compactorExtension(pi: ExtensionAPI): void {
         const cs = new ContentStore();
         await cs.init();
         contentStore = cs;
-      } catch (err) {
-        console.error(`[compactor] ContentStore init failed: ${String(err)}`);
+      } catch {
+        // Silently ignore — ContentStore init failure is handled gracefully.
         contentStore = null;
       }
     }
@@ -101,6 +139,15 @@ export default function compactorExtension(pi: ExtensionAPI): void {
 
     debug("session_start", { sessionId: fullSessionId, projectDir });
 
+    // Reset runtime stats for new session
+    runtimeStats.bytesReturned = {};
+    runtimeStats.bytesIndexed = 0;
+    runtimeStats.bytesSandboxed = 0;
+    runtimeStats.calls = {};
+    runtimeStats.sessionStart = Date.now();
+    runtimeStats.cacheHits = 0;
+    runtimeStats.cacheBytesSaved = 0;
+
     sessionDB?.ensureSession(fullSessionId, projectDir);
 
     // Register all compactor tools with Pi (deps now have live sessionDB)
@@ -119,9 +166,8 @@ export default function compactorExtension(pi: ExtensionAPI): void {
 
     // Register info-screen group
     const infoRegistry = (globalThis as any).__unipi_info_registry;
-    if (infoRegistry && sessionDB && contentStore) {
+    if (infoRegistry && sessionDB) {
       const sdb = sessionDB;
-      const cs = contentStore;
       const sid = () => currentSessionId;
       infoRegistry.registerGroup({
         id: "compactor",
@@ -131,23 +177,25 @@ export default function compactorExtension(pi: ExtensionAPI): void {
         config: {
           showByDefault: true,
           stats: [
-            { id: "sessionEvents", label: "Session events", show: true },
+            { id: "tokensSaved", label: "Tokens saved", show: true },
+            { id: "costSaved", label: "Cost saved", show: true },
+            { id: "pctReduction", label: "% Reduction", show: true },
+            { id: "topTools", label: "Top tools", show: true },
             { id: "compactions", label: "Compactions", show: true },
-            { id: "tokensSaved", label: "Tokens compacted", show: true },
-            { id: "compressionRatio", label: "Compression ratio", show: true },
-            { id: "indexedDocs", label: "Indexed docs", show: true },
+            { id: "toolCalls", label: "Tool calls", show: true },
           ],
         },
         dataProvider: async () => {
           try {
             const { getInfoScreenData } = await import("./info-screen.js");
-            const data = await getInfoScreenData(sdb, cs, sid(), counters);
+            const data = await getInfoScreenData(sdb, sid(), runtimeStats);
             return {
-              sessionEvents: { value: data.sessionEvents.value, detail: data.sessionEvents.detail },
-              compactions: { value: data.compactions.value, detail: data.compactions.detail },
               tokensSaved: { value: data.tokensSaved.value, detail: data.tokensSaved.detail },
-              compressionRatio: { value: data.compressionRatio.value, detail: data.compressionRatio.detail },
-              indexedDocs: { value: data.indexedDocs.value, detail: data.indexedDocs.detail },
+              costSaved: { value: data.costSaved.value, detail: data.costSaved.detail },
+              pctReduction: { value: data.pctReduction.value, detail: data.pctReduction.detail },
+              topTools: { value: data.topTools.value, detail: data.topTools.detail },
+              compactions: { value: data.compactions.value, detail: data.compactions.detail },
+              toolCalls: { value: data.toolCalls.value, detail: data.toolCalls.detail },
             };
           } catch {
             return {};
@@ -252,11 +300,29 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       const sessionId = `${(event as any).sessionId ?? "default"}${getWorktreeSuffix()}`;
       sessionDB.incrementCompactCount(sessionId);
       counters.compactions++;
+
+      // 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;
+      // charsBefore = total bytes processed by all tools (proxy for context window usage)
+      // charsKept = bytes that stayed in context (bytesReturned, minus what compaction removed)
       const tokensBefore = (event as any).tokensBefore ?? 0;
-      if (tokensBefore > 0) {
-        counters.totalTokensCompacted += Math.round(tokensBefore * 0.85); // rough estimate
+      if (totalBytesProcessed > 0 && tokensBefore > 0) {
+        // Use actual token count from Pi, estimate chars from it
+        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 charsKept = tokensAfter * 4;
+        const messagesSummarized = Math.max(1, Math.round(tokensBefore / 500));
+        counters.totalTokensCompacted += tokensBefore - tokensAfter;
+        sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, messagesSummarized);
+      } else if (tokensBefore > 0) {
+        // Fallback: only tokensBefore available, use conservative estimate
+        const tokensAfter = (event as any).tokensAfter ?? Math.round(tokensBefore * 0.15);
+        counters.totalTokensCompacted += tokensBefore - tokensAfter;
+        sessionDB.addCompactionStats(sessionId, tokensBefore * 4, tokensAfter * 4, 1);
       }
-      debug("session_compact", { sessionId });
+      debug("session_compact", { sessionId, tokensBefore, totalBytesProcessed });
     }
   });
 
@@ -365,6 +431,24 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       debug("event_stored", { category: ev.category, type: ev.type });
     }
 
+    // Track byte consumption per tool for analytics
+    try {
+      const responseBytes = measureResponseBytes(event);
+      if (responseBytes > 0) {
+        const tName = (event as any).toolName ?? "unknown";
+        runtimeStats.calls[tName] = (runtimeStats.calls[tName] || 0) + 1;
+        runtimeStats.bytesReturned[tName] = (runtimeStats.bytesReturned[tName] || 0) + responseBytes;
+        if (isSandboxTool(tName)) {
+          runtimeStats.bytesSandboxed += responseBytes;
+        }
+        if (isIndexTool(tName)) {
+          runtimeStats.bytesIndexed += responseBytes;
+        }
+      }
+    } catch {
+      // Non-blocking: byte tracking errors silently skipped
+    }
+
     // Apply display overrides for built-in tools
     const toolName = (event as any).toolName ?? "";
     const td = config.toolDisplay;
@@ -385,6 +469,30 @@ export default function compactorExtension(pi: ExtensionAPI): void {
     } catch {
       // Non-fatal: display override failed
     }
+
+    // Width-safe diff truncation for edit/write tool results.
+    // Pi's renderDiff() does not truncate lines to terminal width,
+    // causing TUI crashes on narrow terminals. We truncate the
+    // diff string in details.diff before it reaches the TUI.
+    const diffToolNames = ["edit", "Edit", "write", "Write"];
+    if (diffToolNames.includes(toolName)) {
+      try {
+        const details = (event as any).details as
+          { diff?: string } | undefined;
+        if (details?.diff) {
+          const { clampDiffToWidth } = await import(
+            "./display/diff-width-safety.js"
+          );
+          const clamped = clampDiffToWidth(details.diff);
+          if (clamped !== details.diff) {
+            debug("diff_width_clamped", { toolName });
+            return { details: { ...details, diff: clamped } } as any;
+          }
+        }
+      } catch (err) {
+        debug("diff_width_clamp_error", { error: String(err) });
+      }
+    }
   });
 
   pi.on("message_update", async (event, _ctx) => {

package/src/info-screen.ts

@@ -1,66 +1,151 @@
 /**
  * Info-screen integration for @pi-unipi/compactor
+ *
+ * Budget-focused stats: tokensSaved, costSaved, pctReduction,
+ * topTools, compactions, toolCalls.
  */
 
 import type { SessionDB } from "./session/db.js";
-import type { ContentStore } from "./store/index.js";
-import type { RuntimeCounters } from "./types.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";
 
-export interface InfoScreenData {
-  sessionEvents: { value: string; detail: string };
-  compactions: { value: string; detail: string };
+export interface CompactorInfoData {
   tokensSaved: { value: string; detail: string };
-  compressionRatio: { value: string; detail: string };
-  indexedDocs: { value: string; detail: string };
-  sandboxExecutions: { value: string; detail: string };
-  searchQueries: { value: string; detail: string };
+  costSaved: { value: string; detail: string };
+  pctReduction: { value: string; detail: string };
+  topTools: { value: string; detail: string };
+  compactions: { value: string; detail: string };
+  toolCalls: { value: string; detail: string };
+}
+
+/** Format token count for display (e.g., "12.4k", "1.2M"). */
+function formatTokens(n: number): string {
+  if (n < 1000) return String(n);
+  if (n < 10_000) return `${(n / 1000).toFixed(1)}k`;
+  if (n < 1_000_000) return `${Math.round(n / 1000)}k`;
+  if (n < 10_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  return `${Math.round(n / 1_000_000)}M`;
+}
+
+/** Format cost for display (e.g., "$0.34", "<$0.01"). */
+function formatCost(n: number): string {
+  if (n === 0) return "$0.00";
+  if (n < 0.01) return "<$0.01";
+  if (n < 1) return `$${n.toFixed(2)}`;
+  return `$${n.toFixed(2)}`;
+}
+
+/** Estimate cost per token for the most-used model in the current session. */
+function estimateCostPerToken(): number | null {
+  try {
+    const usage = parseUsageStats();
+    // Use today's most-used model if available, otherwise all-time
+    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) {
+        return entry.cost / entry.tokens;
+      }
+    }
+    // Fall back to all-time model data
+    const allKeys = Object.keys(usage.byModel);
+    if (allKeys.length > 0) {
+      const topModel = allKeys.reduce((a, b) => usage.byModel[a].tokens > usage.byModel[b].tokens ? a : b);
+      const entry = usage.byModel[topModel];
+      if (entry.tokens > 0 && entry.cost > 0) {
+        return entry.cost / entry.tokens;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
 }
 
 export async function getInfoScreenData(
   sessionDB: SessionDB,
-  contentStore: ContentStore,
   sessionId: string,
-  counters?: RuntimeCounters,
-): Promise<InfoScreenData> {
-  const stats = sessionDB.getSessionStats(sessionId);
-  const compactStats = getLastCompactionStats();
-  const storeStats = await contentStore.getStats();
+  runtimeStats: RuntimeStats,
+): Promise<CompactorInfoData> {
+  try {
+    const db = sessionDB.getDb();
+    const adapter = db ?? createMinimalDb();
+    const engine = new AnalyticsEngine(adapter);
+    const report = engine.queryAll(runtimeStats);
+    const compactStats = getLastCompactionStats();
+
+    // 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")
+      : "No tool calls yet";
+
+    // Cost saved: tokensSaved × cost per token
+    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";
 
-  return {
-    sessionEvents: {
-      value: String(stats?.event_count ?? 0),
-      detail: "Session events tracked",
-    },
-    compactions: {
-      value: String(counters?.compactions ?? stats?.compact_count ?? 0),
-      detail: compactStats ? `Last: ${compactStats.summarized} msgs` : "No compactions yet",
-    },
-    tokensSaved: {
-      value: counters?.totalTokensCompacted
-        ? `~${counters.totalTokensCompacted}`
-        : compactStats
-          ? `~${compactStats.keptTokensEst}`
-          : "0",
-      detail: "Estimated tokens kept",
-    },
-    compressionRatio: {
-      value: compactStats && compactStats.summarized > 0
-        ? `${Math.round(compactStats.summarized / Math.max(compactStats.kept, 1))}:1`
-        : "N/A",
-      detail: "Compression ratio",
-    },
-    indexedDocs: {
-      value: String(storeStats.sources),
-      detail: `${storeStats.chunks} chunks indexed`,
-    },
-    sandboxExecutions: {
-      value: String(counters?.sandboxRuns ?? 0),
-      detail: "Sandbox runs this session",
-    },
-    searchQueries: {
-      value: String(counters?.searchQueries ?? 0),
-      detail: "Search queries this session",
-    },
-  };
+    return {
+      tokensSaved: {
+        value: formatTokens(tokensSaved),
+        detail: toolBreakdown,
+      },
+      costSaved: {
+        value: costSaved !== null ? formatCost(costSaved) : "N/A",
+        detail: costSaved !== null
+          ? `~${formatTokens(tokensSaved)} tokens × $${(costPerToken! * 1_000_000).toFixed(2)}/M tokens`
+          : "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`,
+      },
+      topTools: {
+        value: topTool ? `${topTool.tool}: ${formatTokens(topTool.tokens)}` : "N/A",
+        detail: top5Detail,
+      },
+      compactions: {
+        value: String(report.continuity.compact_count),
+        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`
+            : "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" : ""}`,
+      },
+    };
+  } catch {
+    // Never throw from dataProvider — return zeroed stats
+    return {
+      tokensSaved: { value: "0", detail: "No data" },
+      costSaved: { value: "N/A", detail: "No data" },
+      pctReduction: { value: "0%", detail: "No data" },
+      topTools: { value: "N/A", detail: "No data" },
+      compactions: { value: "0", detail: "No data" },
+      toolCalls: { value: "0", detail: "No data" },
+    };
+  }
 }

package/src/session/analytics.ts

@@ -0,0 +1,198 @@
+/**
+ * AnalyticsEngine — Runtime savings + session continuity reporting.
+ *
+ * Ported from context-mode's AnalyticsEngine, trimmed to budget-focused stats.
+ * Omits: formatReport(), categoryLabels, categoryHints, ThinkInCodeComparison,
+ * SandboxIO, dataBar(), visual formatting helpers.
+ *
+ * Usage:
+ *   const engine = new AnalyticsEngine(sessionDb);
+ *   const report = engine.queryAll(runtimeStats);
+ */
+
+// ─────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────
+
+/** Database adapter — anything with a prepare() method (better-sqlite3, bun:sqlite, etc.) */
+export interface DatabaseAdapter {
+  prepare(sql: string): {
+    run(...params: unknown[]): unknown;
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+  };
+}
+
+/** Context savings result */
+export interface ContextSavings {
+  rawBytes: number;
+  contextBytes: number;
+  savedBytes: number;
+  savedPercent: number;
+}
+
+/** Runtime stats tracked during a live session. */
+export interface RuntimeStats {
+  bytesReturned: Record<string, number>;
+  bytesIndexed: number;
+  bytesSandboxed: number;
+  calls: Record<string, number>;
+  sessionStart: number;
+  cacheHits: number;
+  cacheBytesSaved: number;
+}
+
+/** Unified report combining runtime stats, DB analytics, and continuity data. */
+export interface FullReport {
+  /** Runtime context savings */
+  savings: {
+    processed_kb: number;
+    entered_kb: number;
+    saved_kb: number;
+    pct: number;
+    savings_ratio: number;
+    by_tool: Array<{ tool: string; calls: number; context_kb: number; tokens: number }>;
+    total_calls: number;
+    total_bytes_returned: number;
+    kept_out: number;
+    total_processed: number;
+  };
+  /** Session metadata from SessionDB */
+  session: {
+    id: string;
+    uptime_min: string;
+  };
+  /** Session continuity data */
+  continuity: {
+    total_events: number;
+    compact_count: number;
+    resume_ready: boolean;
+  };
+  /** Persistent project memory — all events across all sessions */
+  projectMemory: {
+    total_events: number;
+    session_count: number;
+  };
+}
+
+// ─────────────────────────────────────────────────────────
+// AnalyticsEngine
+// ─────────────────────────────────────────────────────────
+
+export class AnalyticsEngine {
+  private readonly db: DatabaseAdapter;
+
+  constructor(db: DatabaseAdapter) {
+    this.db = db;
+  }
+
+  /**
+   * Build a FullReport by merging runtime stats (passed in)
+   * with continuity data from the DB.
+   */
+  queryAll(runtimeStats: RuntimeStats): FullReport {
+    // ── Resolve latest session ID ──
+    const latestSession = this.db.prepare(
+      "SELECT session_id FROM session_meta ORDER BY started_at DESC LIMIT 1",
+    ).get() as { session_id: string } | undefined;
+    const sid = latestSession?.session_id ?? "";
+
+    // ── Runtime savings ──
+    const totalBytesReturned = Object.values(runtimeStats.bytesReturned).reduce(
+      (sum, b) => sum + b, 0,
+    );
+    const totalCalls = Object.values(runtimeStats.calls).reduce(
+      (sum, c) => sum + c, 0,
+    );
+    const keptOut = runtimeStats.bytesIndexed + runtimeStats.bytesSandboxed;
+    const totalProcessed = keptOut + totalBytesReturned;
+    const savingsRatio = totalProcessed / Math.max(totalBytesReturned, 1);
+    const reductionPct = totalProcessed > 0
+      ? Math.round((1 - totalBytesReturned / totalProcessed) * 100)
+      : 0;
+
+    const toolNames = new Set([
+      ...Object.keys(runtimeStats.calls),
+      ...Object.keys(runtimeStats.bytesReturned),
+    ]);
+    const byTool = Array.from(toolNames).sort().map((tool) => ({
+      tool,
+      calls: runtimeStats.calls[tool] || 0,
+      context_kb: Math.round((runtimeStats.bytesReturned[tool] || 0) / 1024 * 10) / 10,
+      tokens: Math.round((runtimeStats.bytesReturned[tool] || 0) / 4),
+    }));
+
+    const uptimeMs = Date.now() - runtimeStats.sessionStart;
+    const uptimeMin = (uptimeMs / 60_000).toFixed(1);
+
+    // ── Continuity data (scoped to current session) ──
+    const eventTotal = (this.db.prepare(
+      "SELECT COUNT(*) as cnt FROM session_events WHERE session_id = ?",
+    ).get(sid) as { cnt: number }).cnt;
+
+    const meta = this.db.prepare(
+      "SELECT compact_count FROM session_meta WHERE session_id = ?",
+    ).get(sid) as { compact_count: number } | undefined;
+    const compactCount = meta?.compact_count ?? 0;
+
+    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;
+    const resumeReady = resume ? !resume.consumed : false;
+
+    // ── Project-wide persistent memory (all sessions, no session_id filter) ──
+    const projectTotals = this.db.prepare(
+      "SELECT COUNT(*) as cnt, COUNT(DISTINCT session_id) as sessions FROM session_events",
+    ).get() as { cnt: number; sessions: number };
+
+    return {
+      savings: {
+        processed_kb: Math.round(totalProcessed / 1024 * 10) / 10,
+        entered_kb: Math.round(totalBytesReturned / 1024 * 10) / 10,
+        saved_kb: Math.round(keptOut / 1024 * 10) / 10,
+        pct: reductionPct,
+        savings_ratio: Math.round(savingsRatio * 10) / 10,
+        by_tool: byTool,
+        total_calls: totalCalls,
+        total_bytes_returned: totalBytesReturned,
+        kept_out: keptOut,
+        total_processed: totalProcessed,
+      },
+      session: {
+        id: sid,
+        uptime_min: uptimeMin,
+      },
+      continuity: {
+        total_events: eventTotal,
+        compact_count: compactCount,
+        resume_ready: resumeReady,
+      },
+      projectMemory: {
+        total_events: projectTotals.cnt,
+        session_count: projectTotals.sessions,
+      },
+    };
+  }
+}
+
+// ─────────────────────────────────────────────────────────
+// createMinimalDb — in-memory SQLite fallback
+// ─────────────────────────────────────────────────────────
+
+/**
+ * Create a minimal in-memory DatabaseAdapter for when SessionDB is unavailable.
+ * Returns zeroed/empty results for all queries.
+ */
+export function createMinimalDb(): DatabaseAdapter {
+  // Use an in-memory SQLite database with the expected schema
+  // 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 }),
+    all: (..._params: unknown[]) => [] as unknown[],
+  };
+
+  return {
+    prepare: (_sql: string) => emptyStmt,
+  };
+}

package/src/session/db.ts

@@ -293,6 +293,9 @@ export class SessionDB {
     return oldSessions.length;
   }
 
+  /** Expose the underlying db for AnalyticsEngine (read-only queries). Returns null if init failed. */
+  getDb(): any { return this.db ?? null; }
+
   close(): void {
     try { this.db.close(); } catch { /* ignore */ }
   }

package/src/tools/register.ts

@@ -137,8 +137,8 @@ function jsonResult(data: unknown, label?: string): any {
 }
 
 /** Log a deprecation warning when old tool names are used. */
-function deprecationLog(oldName: string, newName: string): void {
-  console.error(`[compactor] DEPRECATED: Tool "${oldName}" used — use "${newName}" instead.`);
+function deprecationLog(_oldName: string, _newName: string): void {
+  // Deprecation logging disabled — was writing to stdout causing TUI rendering issues.
 }
 
 // --- Old schema names for backward compat aliases ---

package/src/types.ts

@@ -283,11 +283,10 @@ export interface RuntimeCounters {
 // ─────────────────────────────────────────────────────────
 
 export interface CompactorInfoData {
-  sessionEvents: { value: string; detail: string };
-  compactions: { value: string; detail: string };
   tokensSaved: { value: string; detail: string };
-  compressionRatio: { value: string; detail: string };
-  indexedDocs: { value: string; detail: string };
-  sandboxExecutions: { value: string; detail: string };
-  searchQueries: { value: string; detail: string };
+  costSaved: { value: string; detail: string };
+  pctReduction: { value: string; detail: string };
+  topTools: { value: string; detail: string };
+  compactions: { value: string; detail: string };
+  toolCalls: { value: string; detail: string };
 }