@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/compactor/src/info-screen.ts

@@ -1,201 +1,55 @@
-import { formatTokens } from "@pi-unipi/core";
 /**
- * Info-screen integration for @pi-unipi/compactor
- *
- * 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)
+ * Info-screen Compactor tab: the settings in force and this session's
+ * compactions, read from the session branch.
  */
 
-import type { SessionDB } from "./session/db.js";
-import { getLastCompactionStats, formatCompactionStats } from "./compaction/hooks.js";
-import { parseUsageStatsAsync } from "@pi-unipi/info-screen/usage-parser.js";
-import type { RuntimeCounters } from "./types.js";
+import { formatTokens } from "@pi-unipi/core";
+import { loadConfig } from "./config/manager.js";
+import { methodBreakdown, sessionCompactionStats } from "./stats.js";
+
+type Stat = { value: string; detail: string };
 
 export interface CompactorInfoData {
-  tokensSaved: { 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 };
+  settings: Stat;
+  compactions: Stat;
+  tokens: Stat;
+  last: Stat;
 }
 
-/** Format token count for display (e.g., "12.4k", "1.2M"). */
-/** 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)}`;
-}
+const METHOD_NAME = { vcc: "lossless", llm: "model summary" } as const;
 
-/** Estimate cost per token for the most-used model in the current session. */
-async function estimateCostPerToken(): Promise<number | null> {
-  try {
-    const usage = await parseUsageStatsAsync();
-    // Use today's most-used model if available, otherwise all-time
-    const models = usage.byModelToday;
-    const todayKeys = Object.keys(models);
-    if (todayKeys.length > 0) {
-      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;
-  }
+function ago(ms: number): string {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.round(s / 60)}m ago`;
+  if (s < 86400) return `${Math.round(s / 3600)}h ago`;
+  return `${Math.round(s / 86400)}d ago`;
 }
 
-export async function getInfoScreenData(
-  sessionDB: SessionDB,
-  sessionId: string,
-  counters?: RuntimeCounters,
-): Promise<CompactorInfoData> {
-  try {
-    // ── 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);
-      }
-    }
-
-    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";
-
-    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 = await estimateCostPerToken();
-    const costSaved = costPerToken !== null ? tokensSaved * costPerToken : null;
-
-    // ── Last compaction details ──
-    const compactStats = getLastCompactionStats();
-
-    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: `${pctReduction}%`,
-        detail: charsBefore > 0
-          ? `${formatTokens(Math.round(charsBefore / 4))} before → ${formatTokens(Math.round(charsKept / 4))} after compaction`
-          : "No compaction data yet",
-      },
-      topTools: {
-        value: topCategory ? `${topCategory.category}: ${topCategory.cnt}` : "N/A",
-        detail: top5Detail,
-      },
-      compactions: {
-        value: String(compactionCount),
-        detail: compactStats
-          ? `Last: ${formatCompactionStats(compactStats)}`
-          : compactionCount > 0
-            ? `${compactionCount} compaction(s) across all sessions`
-            : "No compactions yet",
-      },
-      toolCalls: {
-        value: String(totalToolCalls),
-        detail: `${totalToolCalls} events across ${toolCountRows.length} categor${toolCountRows.length !== 1 ? "ies" : "y"}`,
-      },
-    };
-  } 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" },
-    };
-  }
+export function getInfoScreenData(branch: readonly any[], cwd: string = process.cwd(), now = Date.now()): CompactorInfoData {
+  const config = loadConfig(cwd);
+  const stats = sessionCompactionStats(branch);
+  const count = stats.compactions.length;
+  const last = stats.compactions[count - 1];
+  const pct = stats.tokensBefore > 0 ? Math.round((stats.tokensSaved / stats.tokensBefore) * 100) : 0;
+  return {
+    settings: {
+      value: METHOD_NAME[config.method],
+      detail: `when: ${config.trigger === "pi" ? "Pi's context limit" : `${config.thresholdPercent}% of context`} · Pi's /compact: ${config.piCompact === "follow" ? "same as method" : METHOD_NAME[config.piCompact]}`,
+    },
+    compactions: {
+      value: String(count),
+      detail: count > 0 ? methodBreakdown(stats) : "none this session",
+    },
+    tokens: {
+      value: count > 0 ? `${formatTokens(stats.tokensBefore)} → ${formatTokens(stats.tokensAfter)}` : "—",
+      detail: count > 0 ? `−${formatTokens(stats.tokensSaved)} (${pct}%) across all compactions` : "nothing compacted yet",
+    },
+    last: {
+      value: last ? `${formatTokens(last.tokensBefore)} → ${formatTokens(last.tokensAfter)}` : "—",
+      detail: last
+        ? [METHOD_NAME[last.method], last.jevDropped ? `${last.jevDropped} stale dropped` : "", last.at ? ago(now - last.at) : ""].filter(Boolean).join(" · ")
+        : "no compaction yet",
+    },
+  };
 }

package/packages/compactor/src/session/recall-blocks.ts

@@ -19,7 +19,7 @@ function block(kind: "user" | "assistant", text: string, sourceIndex?: number):
   return clean ? [{ kind, text: clean, sourceIndex }] : [];
 }
 
-function normalizeAgentMessage(message: AgentMessage, sourceIndex: number): NormalizedBlock[] {
+export function normalizeAgentMessage(message: AgentMessage, sourceIndex: number): NormalizedBlock[] {
   const role = (message as { role?: string }).role;
 
   // Standard LLM message roles are handled by the existing normalizer.

package/packages/compactor/src/stats.ts

@@ -0,0 +1,76 @@
+/**
+ * Compaction stats read straight from the session branch — no database.
+ *
+ * tokensAfter comes from our own compaction details when present; otherwise
+ * (Pi's summaries, older entries) it is estimated as summary + kept tail.
+ */
+
+import { estimateMessageContentChars } from "./compaction/token-estimate.js";
+import type { CompactionMethod } from "./types.js";
+
+export interface CompactionRecord {
+  tokensBefore: number;
+  tokensAfter: number;
+  method: CompactionMethod;
+  /** Epoch ms, when the entry records it. */
+  at?: number;
+  /** Items jev dropped (jev method only). */
+  jevDropped?: number;
+}
+
+export interface SessionCompactionStats {
+  compactions: CompactionRecord[];
+  tokensSaved: number;
+  tokensBefore: number;
+  tokensAfter: number;
+}
+
+const CHARS_PER_TOKEN = 4;
+
+function methodOf(details: any): CompactionMethod {
+  if (details?.compactor !== "@pi-unipi/compactor") return "llm";
+  return details.method === "llm" ? "llm" : "vcc";
+}
+
+export function sessionCompactionStats(branch: readonly any[]): SessionCompactionStats {
+  const compactions: CompactionRecord[] = [];
+  for (let i = 0; i < branch.length; i++) {
+    const entry = branch[i];
+    if (entry?.type !== "compaction") continue;
+    const before = Number(entry.tokensBefore ?? 0);
+    const details = entry.details ?? {};
+    let after = Number(details.tokensAfter ?? 0);
+    if (!after) {
+      const keptIdx = entry.firstKeptEntryId ? branch.findIndex((e) => e?.id === entry.firstKeptEntryId) : -1;
+      let chars = typeof entry.summary === "string" ? entry.summary.length : 0;
+      if (keptIdx >= 0 && keptIdx < i) {
+        for (let k = keptIdx; k < i; k++) {
+          if (branch[k]?.type === "message") chars += estimateMessageContentChars(branch[k].message?.content);
+        }
+      }
+      after = Math.ceil(chars / CHARS_PER_TOKEN);
+    }
+    const at = Date.parse(entry.timestamp ?? "");
+    const method = methodOf(details);
+    compactions.push({
+      tokensBefore: before,
+      tokensAfter: after,
+      method,
+      ...(Number.isFinite(at) ? { at } : {}),
+      ...(typeof details.jev?.dropped === "number" ? { jevDropped: details.jev.dropped } : {}),
+    });
+  }
+
+  const tokensBefore = compactions.reduce((s, c) => s + c.tokensBefore, 0);
+  const tokensAfter = compactions.reduce((s, c) => s + Math.min(c.tokensAfter, c.tokensBefore || c.tokensAfter), 0);
+  return { compactions, tokensBefore, tokensAfter, tokensSaved: Math.max(0, tokensBefore - tokensAfter) };
+}
+
+const METHOD_WORD: Record<CompactionMethod, string> = { vcc: "lossless", llm: "model" };
+
+/** "3 lossless, 1 jev" — only the methods that occurred. */
+export function methodBreakdown(stats: SessionCompactionStats): string {
+  const counts = new Map<CompactionMethod, number>();
+  for (const c of stats.compactions) counts.set(c.method, (counts.get(c.method) ?? 0) + 1);
+  return [...counts.entries()].map(([m, n]) => `${n} ${METHOD_WORD[m]}`).join(", ");
+}

package/packages/compactor/src/tools/context-budget.ts

@@ -2,7 +2,7 @@
  * context_budget tool — estimate remaining context window
  */
 
-import type { AutoCompactionConfig } from "../types.js";
+import type { CompactorConfig } from "../types.js";
 
 export interface ContextBudgetResult {
   percentFull: number;
@@ -13,54 +13,37 @@ export interface ContextBudgetResult {
 }
 
 export function estimateContextBudget(
-  tokensBefore?: number,
+  tokensUsed?: number,
   contextWindowSize?: number,
-  autoCompaction?: Pick<AutoCompactionConfig, "enabled" | "thresholdPercent">,
+  config?: Pick<CompactorConfig, "trigger" | "thresholdPercent">,
 ): ContextBudgetResult | null {
-  const windowSize = contextWindowSize ?? 200000; // Default 200K context
-  const used = tokensBefore ?? 0;
-
-  if (used <= 0 && tokensBefore === undefined) return null;
-
+  if (tokensUsed === undefined) return null;
+  const windowSize = contextWindowSize ?? 200000;
+  const used = Math.max(0, tokensUsed);
   const remaining = Math.max(0, windowSize - used);
   const percentFull = windowSize > 0 ? Math.round((used / windowSize) * 100) : 0;
 
   let advice: string;
-  if (percentFull >= 90) {
-    advice = "CRITICAL: Compact immediately. Very little room for complex tasks.";
-  } else if (percentFull >= 75) {
-    advice = "Context is filling up. Compact before starting complex work.";
-  } else if (percentFull >= 50) {
-    advice = "Moderate context usage. Compact before large multi-step tasks.";
+  if (config?.trigger === "percent") {
+    advice = percentFull >= config.thresholdPercent
+      ? `Context will be compacted automatically at the next turn boundary (threshold ${config.thresholdPercent}%). Keep working.`
+      : `Context compacts automatically at ${config.thresholdPercent}%. Keep working.`;
   } else {
-    advice = "Context has plenty of room. No compaction needed yet.";
-  }
-
-  if (autoCompaction?.enabled) {
-    const threshold = autoCompaction.thresholdPercent;
-    if (percentFull >= threshold) {
-      advice += ` UniPi percentage auto-compaction is enabled at ${threshold}% and usage is above that threshold, subject to cooldown/repeat safeguards.`;
-    } else {
-      advice += ` UniPi percentage auto-compaction is enabled at ${threshold}%.`;
-    }
+    advice = percentFull >= 85
+      ? "Context is nearly full; Pi compacts automatically near the limit and the work continues. Keep working."
+      : "Plenty of room. Pi compacts automatically near the limit.";
   }
 
   const message = `Context: ~${percentFull}% full (estimated ${remaining.toLocaleString()} tokens remaining)`;
-
   return { percentFull, remainingTokens: remaining, totalTokens: windowSize, message, advice };
 }
 
-/**
- * The context_budget tool handler.
- * Called from the tool registration — receives tokensBefore from Pi context.
- */
 export function contextBudgetTool(
-  tokensBefore?: number,
+  tokensUsed?: number,
   contextWindowSize?: number,
-  autoCompaction?: Pick<AutoCompactionConfig, "enabled" | "thresholdPercent">,
+  config?: Pick<CompactorConfig, "trigger" | "thresholdPercent">,
 ): string {
-  const budget = estimateContextBudget(tokensBefore, contextWindowSize, autoCompaction);
-  if (!budget) return "Context budget: Unknown (no token data available from session).";
-
+  const budget = estimateContextBudget(tokensUsed, contextWindowSize, config);
+  if (!budget) return "Context budget: unknown (no token data available yet).";
   return `${budget.message}\nAdvice: ${budget.advice}`;
 }

package/packages/compactor/src/tools/ctx-doctor.ts

@@ -1,10 +1,11 @@
 /**
- * ctx_doctor tool — diagnostics checklist
+ * Compactor diagnostics — settings, Pi's compaction switch, leftovers.
  */
 
-import { existsSync } from "node:fs";
-import { COMPACTOR_CONFIG_PATH } from "../config/manager.js";
-import type { SessionDB } from "../session/db.js";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { CompactorConfig } from "../types.js";
 
 export interface DoctorResult {
   healthy: boolean;
@@ -15,46 +16,54 @@ export interface DoctorResult {
   }>;
 }
 
-export async function ctxDoctor(
-  sessionDB: SessionDB,
-): Promise<DoctorResult> {
-  const checks: DoctorResult["checks"] = [];
+export const LEGACY_DB_DIR = join(homedir(), ".unipi", "db", "compactor");
 
-  // Config check
-  checks.push({
-    name: "Config file",
-    status: existsSync(COMPACTOR_CONFIG_PATH) ? "pass" : "warn",
-    message: existsSync(COMPACTOR_CONFIG_PATH) ? "Config found" : "Using defaults (no config file)",
-  });
+function piCompactionEnabled(): boolean | null {
+  try {
+    const raw = JSON.parse(readFileSync(join(homedir(), ".pi", "agent", "settings.json"), "utf-8"));
+    const enabled = raw?.compaction?.enabled;
+    return typeof enabled === "boolean" ? enabled : true;
+  } catch {
+    return null;
+  }
+}
 
-  // Session DB check
+function dirSizeMb(dir: string): number {
   try {
-    const count = sessionDB.getEventCount("test");
-    checks.push({
-      name: "Session DB",
-      status: "pass",
-      message: "SQLite connection OK",
-    });
-  } catch (err) {
+    return readdirSync(dir).reduce((sum, name) => sum + statSync(join(dir, name)).size, 0) / (1024 * 1024);
+  } catch {
+    return 0;
+  }
+}
+
+export function ctxDoctor(config: CompactorConfig, opts: { hasModel: boolean }): DoctorResult {
+  const checks: DoctorResult["checks"] = [];
+  const method = config.method === "vcc" ? "lossless" : "model summary";
+  const when = config.trigger === "pi" ? "Pi's context limit" : `${config.thresholdPercent}% of context`;
+  checks.push({ name: "Settings", status: "pass", message: `method: ${method} · when: ${when} · Pi's /compact: ${config.piCompact}` });
+
+  const piAuto = piCompactionEnabled();
+  if (config.trigger === "pi" && piAuto === false) {
     checks.push({
-      name: "Session DB",
+      name: "Pi auto-compaction",
       status: "fail",
-      message: `Connection failed: ${err}`,
+      message: "compaction.enabled is false in ~/.pi/agent/settings.json, so nothing compacts automatically. Enable it or set When = at a percentage.",
     });
+  } else {
+    checks.push({ name: "Pi auto-compaction", status: "pass", message: piAuto === null ? "Pi settings unreadable (defaults apply)" : "enabled" });
   }
 
-  // Runtime checks
-  const runtimes = ["node", "python3", "bash"];
-  for (const rt of runtimes) {
-    try {
-      const { execSync } = await import("node:child_process");
-      execSync(`command -v ${rt}`, { stdio: "ignore" });
-      checks.push({ name: `Runtime: ${rt}`, status: "pass", message: "Available" });
-    } catch {
-      checks.push({ name: `Runtime: ${rt}`, status: "warn", message: "Not found" });
-    }
+  if (config.method === "llm" && !opts.hasModel) {
+    checks.push({ name: "Model", status: "warn", message: "model summaries need a selected model" });
+  }
+
+  if (existsSync(LEGACY_DB_DIR)) {
+    checks.push({
+      name: "Old continuity database",
+      status: "warn",
+      message: `${LEGACY_DB_DIR} (${dirSizeMb(LEGACY_DB_DIR).toFixed(1)} MB) is no longer used and can be deleted.`,
+    });
   }
 
-  const healthy = checks.every((c) => c.status !== "fail");
-  return { healthy, checks };
+  return { healthy: checks.every((c) => c.status !== "fail"), checks };
 }