@pi-unipi/unipi 0.1.15 → 0.1.16

package/README.md

@@ -27,6 +27,7 @@ pi install npm:@pi-unipi/ask-user
 pi install npm:@pi-unipi/milestone
 pi install npm:@pi-unipi/kanboard
 pi install npm:@pi-unipi/footer
+pi install npm:@pi-unipi/updater
 ```
 
 ## Packages
@@ -49,6 +50,7 @@ pi install npm:@pi-unipi/footer
 | `@pi-unipi/milestone` | Milestone tracking and project progress management |
 | `@pi-unipi/kanboard` | Kanboard visualization server with TUI overlay |
 | `@pi-unipi/footer` | Persistent status bar with live stats from all packages |
+| `@pi-unipi/updater` | Auto-updater, changelog browser, and readme browser |
 
 ## Commands
 
@@ -227,6 +229,14 @@ pi install npm:@pi-unipi/footer
 | `/unipi:footer` | Toggle footer or switch preset |
 | `/unipi:footer-settings` | Open footer settings — toggle groups and segments |
 
+### Updater (`/unipi:updater*`)
+
+| Command | Description |
+|---------|-------------|
+| `/unipi:readme [package]` | Browse package README files in TUI overlay |
+| `/unipi:changelog` | Browse CHANGELOG.md with version list and detail view |
+| `/unipi:updater-settings` | Configure check interval and auto-update mode |
+
 ### Name Badge
 
 ## How It Works

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -51,7 +51,9 @@
       "node_modules/@pi-unipi/milestone/index.ts",
       "node_modules/@pi-unipi/kanboard/index.ts",
       "node_modules/@pi-unipi/command-enchantment/src/index.ts",
-      "node_modules/@pi-unipi/footer/index.ts"
+      "node_modules/@pi-unipi/footer/src/index.ts",
+      "node_modules/@pi-unipi/updater/src/index.ts",
+      "node_modules/@pi-unipi/input-shortcuts/src/index.ts"
     ],
     "skills": [
       "node_modules/@pi-unipi/workflow/skills",
@@ -64,7 +66,8 @@
       "node_modules/@pi-unipi/compactor/skills",
       "node_modules/@pi-unipi/notify/skills",
       "node_modules/@pi-unipi/milestone/skills",
-      "node_modules/@pi-unipi/kanboard/skills"
+      "node_modules/@pi-unipi/kanboard/skills",
+      "node_modules/@pi-unipi/updater/skills"
     ]
   },
   "peerDependencies": {
@@ -90,7 +93,9 @@
     "@pi-unipi/kanboard": "*",
     "@pi-unipi/web-api": "*",
     "@pi-unipi/workflow": "*",
-    "@pi-unipi/footer": "*"
+    "@pi-unipi/footer": "*",
+    "@pi-unipi/updater": "*",
+    "@pi-unipi/input-shortcuts": "*"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/packages/autocomplete/src/constants.ts

@@ -30,6 +30,8 @@ export const PACKAGE_ORDER: string[] = [
   "notify",
   "kanboard",
   "footer",
+  "updater",
+  "input-shortcuts",
 ];
 
 // ─── Package Colors ──────────────────────────────────────────────────
@@ -48,6 +50,8 @@ export const PACKAGE_COLORS: Record<string, string> = {
   notify:    `${ESC}[96m`, // Bright Cyan
   kanboard:  `${ESC}[92m`, // Bright Green
   footer:    `${ESC}[34m`, // Blue
+  updater:   `${ESC}[93m`, // Bright Yellow
+  "input-shortcuts": `${ESC}[95m`, // Bright Magenta
 };
 
 // ─── Command Registry ────────────────────────────────────────────────
@@ -149,6 +153,14 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   // footer (2 commands)
   "unipi:footer":            "footer",
   "unipi:footer-settings":   "footer",
+
+  // updater (3 commands)
+  "unipi:readme":            "updater",
+  "unipi:changelog":         "updater",
+  "unipi:updater-settings":  "updater",
+
+  // input-shortcuts (1 command)
+  "unipi:stash-settings":   "input-shortcuts",
 };
 
 // ─── Description Map ─────────────────────────────────────────────────
@@ -236,6 +248,12 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
 
   "unipi:footer":            "Toggle footer or switch preset",
   "unipi:footer-settings":   "Open footer settings — toggle groups and segments",
+
+  "unipi:readme":            "Browse package README files",
+  "unipi:changelog":         "Browse changelog (Keep a Changelog format)",
+  "unipi:updater-settings":  "Configure updater — check interval and auto-update",
+
+  "unipi:stash-settings":   "Open input shortcuts settings — customize keybindings",
 };
 
 // ─── Package Display Names ───────────────────────────────────────────
@@ -254,4 +272,6 @@ export const PACKAGE_LABELS: Record<string, string> = {
   notify:    "notify",
   kanboard:  "kanboard",
   footer:    "footer",
+  updater:   "updater",
+  "input-shortcuts": "input-shortcuts",
 };

package/packages/autocomplete/src/settings.ts

@@ -52,8 +52,8 @@ export function loadConfig(): CommandEnchantmentConfig {
         ...config,
       };
     }
-  } catch (error) {
-    console.error("[command-enchantment] Failed to load config:", error);
+  } catch {
+    // Silently ignore — config load failure falls back to defaults.
   }
   return DEFAULT_CONFIG;
 }

package/packages/compactor/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/packages/compactor/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/packages/compactor/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/packages/compactor/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/packages/compactor/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/packages/compactor/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/packages/compactor/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/packages/compactor/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) => {