@pi-vault/pi-dcp 0.1.0

package/src/messages/inject.ts

@@ -0,0 +1,149 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ContextUsage, SessionState } from "../state/types.ts";
+import type { DcpConfig } from "../config.ts";
+import { formatMessageRef, formatMessageIdTag } from "../utils/message-ids.ts";
+import type { PriorityMap } from "./priority.ts";
+import { appendText } from "../utils/message-content.ts";
+import {
+  CONTEXT_LIMIT_NUDGE,
+  TURN_NUDGE,
+  ITERATION_NUDGE,
+} from "../prompts/nudges.ts";
+
+/**
+ * Assign sequential message refs (m0001, m0002, ...) to messages.
+ * Refs are cached in state.messageIds.byIndex so re-runs don't reallocate.
+ * Also maintains a reverse map (byRef) for O(1) ref-to-index resolution.
+ */
+export function assignMessageRefs(
+  state: SessionState,
+  messages: AgentMessage[],
+): void {
+  for (let i = 0; i < messages.length; i++) {
+    if (state.messageIds.byIndex.has(i)) continue;
+
+    const ref = formatMessageRef(state.messageIds.nextRefIndex);
+    state.messageIds.byIndex.set(i, ref);
+    state.messageIds.byRef.set(ref, i);
+    state.messageIds.nextRefIndex++;
+  }
+}
+
+/**
+ * Inject <dcp-message-id> tags into message text content.
+ * Returns a new array. Idempotent: skips if tag is already present.
+ *
+ * Handles both array content and plain-string content (E9: UserMessage.content
+ * can be a plain string — normalize to array form before injecting).
+ */
+export function injectMessageIds(
+  state: SessionState,
+  messages: AgentMessage[],
+  priorityMap?: PriorityMap,
+): AgentMessage[] {
+  return messages.map((msg, i) => {
+    const ref = state.messageIds.byIndex.get(i);
+    if (!ref) return msg;
+
+    if (msg.role !== "user" && msg.role !== "assistant") return msg;
+
+    const priorityEntry = priorityMap?.get(i);
+    const tag = formatMessageIdTag(
+      ref,
+      priorityEntry ? { priority: priorityEntry.priority } : undefined,
+    );
+
+    // Idempotency marker uses "<dcp-message-id" (no closing >) to match both
+    // plain and priority-attribute variants.
+    return appendText(msg, `\n\n${tag}`, "<dcp-message-id");
+  });
+}
+
+/**
+ * Inject compress nudges into messages based on context usage.
+ * Three tiers:
+ * - Context limit nudge: percent >= maxContextPercent (urgent)
+ * - Turn nudge: percent >= minContextPercent and last message is a user message
+ * - Iteration nudge: percent >= minContextPercent and many consecutive assistant messages
+ *
+ * Nudge text is appended to the last message that has text content.
+ * Returns a new array. Idempotent: skips if <dcp-system-reminder> is already present.
+ *
+ * Handles plain-string user message content (E9).
+ *
+ * NOTE: config.compress.nudgeFrequency and state.nudges anchor tracking are
+ * reserved for Phase 4+ throttling — not yet implemented.
+ */
+export function injectCompressNudges(
+  state: SessionState,
+  config: DcpConfig,
+  messages: AgentMessage[],
+  contextUsage: ContextUsage | undefined,
+): AgentMessage[] {
+  if (!contextUsage) return messages;
+
+  // E5: percent can be null when unknown
+  if (contextUsage.percent == null) return messages;
+
+  const percent = contextUsage.percent;
+  const overMax = percent >= config.compress.maxContextPercent;
+  const overMin = percent >= config.compress.minContextPercent;
+
+  if (!overMin) return messages;
+
+  if (state.manualMode) return messages;
+  if (state.compressPermission === "deny") return messages;
+
+  if (messages.length === 0) return messages;
+
+  let nudgeText: string | undefined;
+
+  if (overMax) {
+    nudgeText = CONTEXT_LIMIT_NUDGE;
+  } else {
+    const lastMsg = messages[messages.length - 1];
+    if (lastMsg.role === "user") {
+      nudgeText = TURN_NUDGE;
+    } else {
+      // Count only assistant messages since the last user message
+      let messagesSinceUser = 0;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user") break;
+        if (messages[i].role === "assistant") messagesSinceUser++;
+      }
+      if (messagesSinceUser >= config.compress.iterationNudgeThreshold) {
+        nudgeText = ITERATION_NUDGE;
+      }
+    }
+  }
+
+  if (!nudgeText) return messages;
+
+  // Inject into the last message that has text content
+  const result = [...messages];
+  for (let i = result.length - 1; i >= 0; i--) {
+    const msg = result[i];
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+
+    // Check for existing marker — stop searching if found
+    if (typeof msg.content === "string") {
+      if (msg.content.includes("<dcp-system-reminder>")) break;
+    } else if (Array.isArray(msg.content)) {
+      const tp = msg.content.find(
+        (p) =>
+          typeof p === "object" &&
+          p !== null &&
+          (p as unknown as Record<string, unknown>).type === "text",
+      ) as unknown as { text: string } | undefined;
+      if (!tp) continue;
+      if (tp.text.includes("<dcp-system-reminder>")) break;
+    } else {
+      continue;
+    }
+
+    result[i] = appendText(msg, `\n\n${nudgeText}`);
+    break;
+  }
+
+  return result;
+}

package/src/messages/priority.ts

@@ -0,0 +1,75 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { SessionState } from "../state/types.ts";
+import { countMessageTokens } from "../utils/tokens.ts";
+
+export interface MessagePriorityEntry {
+  index: number;
+  ref: string;
+  priority: number;
+  tokens: number;
+}
+
+export type PriorityMap = Map<number, MessagePriorityEntry>;
+
+/**
+ * Build a priority map for message-mode compression.
+ * Priority 1 = highest (compress first), 5 = lowest (keep).
+ *
+ * Ranking factors:
+ * - Position: earlier messages get higher priority (compress first)
+ * - Token count: larger messages get higher priority (compress first)
+ * - Role: tool results are resolved content, slightly prioritized for compression
+ */
+export function buildPriorityMap(
+  state: SessionState,
+  messages: AgentMessage[],
+): PriorityMap {
+  if (messages.length === 0) return new Map();
+
+  const entries: Array<{ index: number; score: number; tokens: number }> = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const ref = state.messageIds.byIndex.get(i);
+    if (!ref) continue;
+
+    // Skip messages already covered by active blocks
+    const pruneEntry = state.prune.messages.byMessageIndex.get(i);
+    if (pruneEntry && pruneEntry.activeBlockIds.length > 0) continue;
+
+    const tokens = countMessageTokens(msg);
+
+    // Score: higher = compress first
+    // Position weight: earlier messages score higher
+    const positionScore = (messages.length - i) / messages.length;
+    // Token weight: larger messages score higher
+    const tokenScore = Math.min(tokens / 500, 1);
+    // Role weight
+    const roleWeight = msg.role === "toolResult" ? 0.2 : 0;
+
+    const score = positionScore * 0.6 + tokenScore * 0.3 + roleWeight;
+    entries.push({ index: i, score, tokens });
+  }
+
+  // Sort by score descending (highest score = highest priority)
+  entries.sort((a, b) => b.score - a.score);
+
+  // Assign priorities 1-5 based on quintiles
+  const map: PriorityMap = new Map();
+  const quintileSize = Math.max(1, Math.ceil(entries.length / 5));
+
+  for (let rank = 0; rank < entries.length; rank++) {
+    const entry = entries[rank];
+    const priority = Math.min(5, Math.floor(rank / quintileSize) + 1);
+    const ref = state.messageIds.byIndex.get(entry.index)!;
+
+    map.set(entry.index, {
+      index: entry.index,
+      ref,
+      priority,
+      tokens: entry.tokens,
+    });
+  }
+
+  return map;
+}

package/src/messages/prune.ts

@@ -0,0 +1,103 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { SessionState } from "../state/types.ts";
+
+/**
+ * Filter out compressed message ranges and inject summaries.
+ * Messages covered by active blocks are removed and replaced with
+ * a synthetic user message containing the summary at the anchor position.
+ */
+export function filterCompressedRanges(
+  state: SessionState,
+  messages: AgentMessage[],
+): AgentMessage[] {
+  if (state.prune.messages.activeBlockIds.size === 0) return messages;
+
+  const result: AgentMessage[] = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    // Check if there's a summary to inject at this anchor point
+    const blockId = state.prune.messages.activeByAnchorIndex.get(i);
+    if (blockId !== undefined) {
+      const block = state.prune.messages.blocksById.get(blockId);
+      if (block?.active && block.summary) {
+        result.push({
+          role: "user",
+          content: [{ type: "text", text: block.summary }],
+          timestamp: Date.now(),
+        } as AgentMessage);
+      }
+    }
+
+    // Skip messages that are covered by active blocks
+    const entry = state.prune.messages.byMessageIndex.get(i);
+    if (entry && entry.activeBlockIds.length > 0) {
+      continue;
+    }
+
+    result.push(messages[i]);
+  }
+
+  return result;
+}
+
+const PRUNED_OUTPUT_TEXT =
+  "[Output removed to save context - information superseded or no longer needed]";
+const PRUNED_ERROR_INPUT_TEXT = "[input removed due to failed tool call]";
+
+/**
+ * Replace outputs of pruned tool results with placeholder text.
+ * Returns a new array (does not mutate input).
+ */
+export function pruneToolOutputs(
+  state: SessionState,
+  messages: AgentMessage[],
+): AgentMessage[] {
+  if (state.prune.tools.size === 0) return messages;
+
+  return messages.map((msg) => {
+    if (msg.role !== "toolResult") return msg;
+    if (!state.prune.tools.has(msg.toolCallId)) return msg;
+    if (msg.isError) return msg;
+
+    return {
+      ...msg,
+      content: [{ type: "text" as const, text: PRUNED_OUTPUT_TEXT }],
+    };
+  });
+}
+
+/**
+ * Replace content of pruned error tool results with placeholder text.
+ * Returns a new array (does not mutate input).
+ */
+export function pruneToolErrors(
+  state: SessionState,
+  messages: AgentMessage[],
+): AgentMessage[] {
+  if (state.prune.tools.size === 0) return messages;
+
+  return messages.map((msg) => {
+    if (msg.role !== "toolResult") return msg;
+    if (!state.prune.tools.has(msg.toolCallId)) return msg;
+    if (!msg.isError) return msg;
+
+    return {
+      ...msg,
+      content: [{ type: "text" as const, text: PRUNED_ERROR_INPUT_TEXT }],
+    };
+  });
+}
+
+/**
+ * Apply all pruning passes to a message array.
+ * Returns a new array.
+ */
+export function applyPruning(
+  state: SessionState,
+  messages: AgentMessage[],
+): AgentMessage[] {
+  let result = filterCompressedRanges(state, messages);
+  result = pruneToolOutputs(state, result);
+  result = pruneToolErrors(state, result);
+  return result;
+}

package/src/messages/strip.ts

@@ -0,0 +1,23 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { mapText } from "../utils/message-content.ts";
+
+const DCP_PAIRED_TAG_REGEX = /<dcp[^>]*>[\s\S]*?<\/dcp[^>]*>/gi;
+const DCP_UNPAIRED_TAG_REGEX = /<\/?dcp[^>]*>/gi;
+
+/**
+ * Strip hallucinated DCP tags from a string.
+ */
+export function stripHallucinationsFromString(text: string): string {
+  return text.replace(DCP_PAIRED_TAG_REGEX, "").replace(DCP_UNPAIRED_TAG_REGEX, "");
+}
+
+/**
+ * Strip hallucinated DCP tags from assistant messages.
+ * Returns a new array. Messages without changes are returned by reference.
+ */
+export function stripHallucinations(messages: AgentMessage[]): AgentMessage[] {
+  return messages.map((msg) => {
+    if (msg.role !== "assistant") return msg;
+    return mapText(msg, stripHallucinationsFromString);
+  });
+}

package/src/messages/sync.ts

@@ -0,0 +1,55 @@
+import type { SessionState } from "../state/types.ts";
+
+/**
+ * Reconcile compression block state with current message count.
+ * Blocks whose compressMessageIndex exceeds the message array length
+ * are deactivated (the compress tool call was compacted away).
+ */
+export function syncCompressionBlocks(
+  state: SessionState,
+  messageCount: number,
+): void {
+  const messagesState = state.prune.messages;
+  if (messagesState.blocksById.size === 0) return;
+
+  const now = Date.now();
+
+  // Sort blocks by creation order for deterministic processing
+  const blocks = Array.from(messagesState.blocksById.values()).sort(
+    (a, b) => a.createdAt - b.createdAt || a.blockId - b.blockId,
+  );
+
+  messagesState.activeBlockIds.clear();
+  messagesState.activeByAnchorIndex.clear();
+
+  for (const block of blocks) {
+    // If the compress tool call message no longer exists, deactivate
+    if (block.compressMessageIndex >= messageCount) {
+      block.active = false;
+      block.deactivatedAt = now;
+      continue;
+    }
+
+    if (block.deactivatedByUser) {
+      block.active = false;
+      if (block.deactivatedAt === undefined) {
+        block.deactivatedAt = now;
+      }
+      continue;
+    }
+
+    // Reactivate if the compress message still exists
+    block.active = true;
+    block.deactivatedAt = undefined;
+    block.deactivatedByBlockId = undefined;
+    messagesState.activeBlockIds.add(block.blockId);
+    messagesState.activeByAnchorIndex.set(block.anchorIndex, block.blockId);
+  }
+
+  // Update per-message entries
+  for (const entry of messagesState.byMessageIndex.values()) {
+    entry.activeBlockIds = entry.blockIds.filter((id) =>
+      messagesState.activeBlockIds.has(id),
+    );
+  }
+}

package/src/pipeline.ts

@@ -0,0 +1,64 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { SessionState, ContextUsage } from "./state/types.ts";
+import type { DcpConfig } from "./config.ts";
+import { syncCompressionBlocks } from "./messages/sync.ts";
+import { stripHallucinations } from "./messages/strip.ts";
+import { syncToolCache, buildToolIdList } from "./state/tool-cache.ts";
+import { runStrategies, type StrategyResult } from "./strategies/runner.ts";
+import {
+  assignMessageRefs,
+  injectCompressNudges,
+  injectMessageIds,
+} from "./messages/inject.ts";
+import { buildPriorityMap, type PriorityMap } from "./messages/priority.ts";
+import { applyPruning } from "./messages/prune.ts";
+
+export interface PipelineResult {
+  messages: AgentMessage[];
+  strategyResult: StrategyResult;
+}
+
+/**
+ * Run the full DCP context processing pipeline.
+ * Pure function of (state, config, messages, usage) → transformed messages.
+ * State is mutated (tool cache, pruning marks, stats) as a side effect.
+ */
+export function runPipeline(
+  state: SessionState,
+  config: DcpConfig,
+  messages: AgentMessage[],
+  contextUsage: ContextUsage | undefined,
+): PipelineResult {
+  // Step 0.5: Sync compression blocks (handle stale anchors)
+  syncCompressionBlocks(state, messages.length);
+
+  // Step 1: Strip hallucinated DCP tags from assistant messages
+  let result = stripHallucinations(messages);
+
+  // Step 2: Sync tool parameter cache and rebuild ordered tool ID list
+  syncToolCache(state, result);
+  buildToolIdList(state, result);
+
+  // Step 3: Run strategies (deduplication + purge errors)
+  const strategyResult = runStrategies(state, config);
+
+  // Step 4: Assign message refs (stable raw indices)
+  assignMessageRefs(state, result);
+
+  // Step 4.5: Build priority map for message-mode compression
+  let priorityMap: PriorityMap | undefined;
+  if (config.compress.mode === "message") {
+    priorityMap = buildPriorityMap(state, result);
+  }
+
+  // Step 5: Inject message IDs (with priority attrs if message mode)
+  result = injectMessageIds(state, result, priorityMap);
+
+  // Step 6: Apply pruning (compressed ranges removed, tool outputs pruned)
+  result = applyPruning(state, result);
+
+  // Step 7: Inject nudges based on context usage
+  result = injectCompressNudges(state, config, result, contextUsage);
+
+  return { messages: result, strategyResult };
+}

package/src/prompts/compress-message.ts

@@ -0,0 +1,19 @@
+/**
+ * Message-mode compress tool description.
+ * Used when config.compress.mode === "message".
+ */
+export const COMPRESS_MESSAGE_PROMPT = `Compress specific messages identified by their priority tags.
+
+Messages are tagged with <dcp-message-id priority="N"> where N is 1-5:
+- Priority 1-2: Highest compression value (old, large, resolved content)
+- Priority 3: Moderate compression value
+- Priority 4-5: Low compression value (recent, small, active content)
+
+TARGET SELECTION
+Focus on priority 1-2 messages first. These are the best candidates for compression.
+Only compress priority 3+ messages when context pressure is severe.
+
+SUMMARY REQUIREMENTS
+Each summary must be self-contained and capture all essential information from the target message.
+Preserve exact error messages, file paths, function names, and user instructions.
+`;

package/src/prompts/nudges.ts

@@ -0,0 +1,44 @@
+/**
+ * Nudge prompts injected into messages when context usage exceeds thresholds.
+ * All wrapped in <dcp-system-reminder> tags — the model is trained to strip these.
+ */
+
+/** Injected when context exceeds maxContextPercent. Urgent. */
+export const CONTEXT_LIMIT_NUDGE = `<dcp-system-reminder>
+CRITICAL WARNING: MAX CONTEXT LIMIT REACHED
+
+You are at or beyond the configured max context threshold. This is an emergency context-recovery moment.
+
+You MUST use the \`compress\` tool now. Do not continue normal exploration until compression is handled.
+
+If you are in the middle of a critical atomic operation, finish that atomic step first, then compress immediately.
+
+SELECTION PROCESS
+Start from older, resolved history and capture as much stale context as safely possible in one pass.
+Avoid the newest active working messages unless it is clearly closed.
+
+SUMMARY REQUIREMENTS
+Your summary MUST cover all essential details from the selected messages so work can continue.
+If the compressed range includes user messages, preserve user intent exactly. Prefer direct quotes for short user messages to avoid semantic drift.
+</dcp-system-reminder>
+`;
+
+/** Injected on user turns when context is between minContextPercent and maxContextPercent. Moderate. */
+export const TURN_NUDGE = `<dcp-system-reminder>
+Evaluate the conversation for compressible ranges.
+
+If any messages are cleanly closed and unlikely to be needed again, use the compress tool on them.
+If direction has shifted, compress earlier ranges that are now less relevant.
+
+The goal is to filter noise and distill key information so context accumulation stays under control.
+Keep active context uncompressed.
+</dcp-system-reminder>
+`;
+
+/** Injected after many assistant iterations without a user message. Moderate. */
+export const ITERATION_NUDGE = `<dcp-system-reminder>
+You've been iterating for a while after the last user message.
+
+If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation), use the compress tool on it now.
+</dcp-system-reminder>
+`;

package/src/prompts/system.ts

@@ -0,0 +1,37 @@
+/**
+ * DCP system prompt appended to Pi's system prompt via before_agent_start.
+ * Teaches the model about context management and the compress tool.
+ */
+export const DCP_SYSTEM_PROMPT = `
+You operate in a context-constrained environment. Manage context continuously to avoid buildup and preserve retrieval quality. Efficient context management is paramount for your agentic performance.
+
+The ONLY tool you have for context management is \`compress\`. It replaces older conversation content with technical summaries you produce.
+
+\`<dcp-message-id>\` and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
+
+THE PHILOSOPHY OF COMPRESS
+\`compress\` transforms conversation content into dense, high-fidelity summaries. This is not cleanup - it is crystallization. Your summary becomes the authoritative record of what transpired.
+
+Think of compression as phase transitions: raw exploration becomes refined understanding. The original context served its purpose; your summary now carries that understanding forward.
+
+COMPRESS WHEN
+
+A section is genuinely closed and the raw conversation has served its purpose:
+
+- Research concluded and findings are clear
+- Implementation finished and verified
+- Exploration exhausted and patterns understood
+- Dead-end noise can be discarded without waiting for a whole chapter to close
+
+DO NOT COMPRESS IF
+
+- Raw context is still relevant and needed for edits or precise references
+- The target content is still actively in progress
+- You may need exact code, error messages, or file contents in the immediate next steps
+
+Before compressing, ask: _"Is this section closed enough to become summary-only right now?"_
+
+Evaluate conversation signal-to-noise REGULARLY. Use \`compress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window that supports your agency.
+
+It is of your responsibility to keep a sharp, high-quality context window for optimal performance.
+`;

package/src/state/persistence.ts

@@ -0,0 +1,111 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { SessionState, SessionStats } from "./types.ts";
+
+/**
+ * Serializable subset of session state for persistence.
+ */
+interface SerializedState {
+  sessionId: string | null;
+  currentTurn: number;
+  stats: SessionStats;
+  lastCompaction: number;
+}
+
+/**
+ * Save session state to {sessionDir}/dcp/state.json.
+ * No-op if state.sessionId is null.
+ */
+export function saveSessionState(state: SessionState, sessionDir: string): void {
+  if (!state.sessionId) return;
+
+  const dcpDir = path.join(sessionDir, "dcp");
+  fs.mkdirSync(dcpDir, { recursive: true });
+
+  const serialized: SerializedState = {
+    sessionId: state.sessionId,
+    currentTurn: state.currentTurn,
+    stats: { ...state.stats },
+    lastCompaction: state.lastCompaction,
+  };
+
+  fs.writeFileSync(
+    path.join(dcpDir, "state.json"),
+    JSON.stringify(serialized, null, 2),
+  );
+}
+
+/**
+ * Load session state from {sessionDir}/dcp/state.json.
+ * Returns undefined if the file doesn't exist or is corrupt.
+ */
+export function loadSessionState(
+  sessionDir: string,
+): Pick<SessionState, "currentTurn" | "stats" | "lastCompaction"> | undefined {
+  const filePath = path.join(sessionDir, "dcp", "state.json");
+
+  try {
+    if (!fs.existsSync(filePath)) return undefined;
+    const content = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content) as SerializedState;
+
+    return {
+      currentTurn: parsed.currentTurn ?? 0,
+      stats: {
+        pruneTokenCounter: parsed.stats?.pruneTokenCounter ?? 0,
+        totalPruneTokens: parsed.stats?.totalPruneTokens ?? 0,
+        toolsPruned: parsed.stats?.toolsPruned ?? 0,
+        messagesCompressed: parsed.stats?.messagesCompressed ?? 0,
+      },
+      lastCompaction: parsed.lastCompaction ?? 0,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Load aggregate stats from all saved sessions under a parent directory.
+ * Expects structure: {parentDir}/{sessionName}/dcp/state.json
+ * Used by dcp:lifetime command.
+ */
+export function loadAllSessionStats(parentDir: string): {
+  totalTokensSaved: number;
+  totalToolsPruned: number;
+  totalMessagesCompressed: number;
+  sessionCount: number;
+} {
+  const result = {
+    totalTokensSaved: 0,
+    totalToolsPruned: 0,
+    totalMessagesCompressed: 0,
+    sessionCount: 0,
+  };
+
+  try {
+    if (!fs.existsSync(parentDir)) return result;
+    const entries = fs.readdirSync(parentDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const stateFile = path.join(parentDir, entry.name, "dcp", "state.json");
+      try {
+        if (!fs.existsSync(stateFile)) continue;
+        const content = fs.readFileSync(stateFile, "utf-8");
+        const parsed = JSON.parse(content) as SerializedState;
+        if (parsed.stats) {
+          result.totalTokensSaved += parsed.stats.totalPruneTokens ?? 0;
+          result.totalToolsPruned += parsed.stats.toolsPruned ?? 0;
+          result.totalMessagesCompressed += parsed.stats.messagesCompressed ?? 0;
+          result.sessionCount++;
+        }
+      } catch {
+        // Skip corrupt files
+      }
+    }
+  } catch {
+    // Dir not accessible
+  }
+
+  return result;
+}