@pi-unipi/unipi 2.6.0 → 2.6.2

package/packages/info-screen/registry.ts

@@ -6,7 +6,7 @@
  */
 
 import type { InfoGroup, GroupData } from "./types.js";
-import { getInfoSettings, isStatEnabled } from "./config.js";
+import { isStatEnabled } from "./config.js";
 
 /** Callback for reactive updates */
 type GroupUpdateCallback = (groupId: string, data: GroupData) => void;
@@ -24,9 +24,6 @@ class InfoRegistry {
   /** Cache TTL in ms */
   private cacheTtlMs = 5000;
 
-  /** Subscribers per group */
-  private subscribers = new Map<string, Set<GroupUpdateCallback>>();
-
   /** Global subscribers (any group update) */
   private globalSubscribers = new Set<GroupUpdateCallback>();
 
@@ -43,33 +40,6 @@ class InfoRegistry {
     this.notifyGroupRegistered(group.id);
   }
 
-  /**
-   * Unregister an info group.
-   */
-  unregisterGroup(groupId: string): void {
-    this.groups.delete(groupId);
-    this.dataCache.delete(groupId);
-    this.lastUpdated.delete(groupId);
-    this.subscribers.delete(groupId);
-  }
-
-  /**
-   * Get all registered groups, sorted by priority.
-   */
-  getGroups(): InfoGroup[] {
-    const settings = getInfoSettings();
-    const allGroups = Array.from(this.groups.values());
-
-    return allGroups
-      .filter((group) => {
-        const groupSettings = settings.groups[group.id];
-        if (groupSettings && !groupSettings.show) return false;
-        if (!groupSettings && !group.config.showByDefault) return false;
-        return true;
-      })
-      .sort((a, b) => a.priority - b.priority);
-  }
-
   /**
    * Get all registered groups (including hidden ones).
    */
@@ -100,13 +70,6 @@ class InfoRegistry {
     return this.lastUpdated.get(groupId) ?? 0;
   }
 
-  /**
-   * Synchronous: check if a group is currently fetching.
-   */
-  isFetching(groupId: string): boolean {
-    return this.inflight.has(groupId);
-  }
-
   /**
    * Get data for a group, using cache if fresh.
    * Returns immediately from cache if fresh, otherwise fetches in background
@@ -176,21 +139,6 @@ class InfoRegistry {
     }
   }
 
-  /**
-   * Subscribe to updates for a specific group.
-   * Returns unsubscribe function.
-   */
-  subscribe(groupId: string, callback: GroupUpdateCallback): () => void {
-    if (!this.subscribers.has(groupId)) {
-      this.subscribers.set(groupId, new Set());
-    }
-    this.subscribers.get(groupId)!.add(callback);
-
-    return () => {
-      this.subscribers.get(groupId)?.delete(callback);
-    };
-  }
-
   /**
    * Subscribe to all group updates.
    * Returns unsubscribe function.
@@ -203,14 +151,6 @@ class InfoRegistry {
   }
 
   private notifySubscribers(groupId: string, data: GroupData): void {
-    // Per-group subscribers
-    const groupSubs = this.subscribers.get(groupId);
-    if (groupSubs) {
-      for (const cb of groupSubs) {
-        try { cb(groupId, data); } catch { /* ignore */ }
-      }
-    }
-
     // Global subscribers
     for (const cb of this.globalSubscribers) {
       try { cb(groupId, data); } catch { /* ignore */ }
@@ -239,14 +179,6 @@ class InfoRegistry {
     this.lastUpdated.delete(groupId);
   }
 
-  /**
-   * Invalidate all caches.
-   */
-  invalidateAllCaches(): void {
-    this.dataCache.clear();
-    this.lastUpdated.clear();
-  }
-
   /**
    * Notify that a new group was registered.
    * Subscribers can use this to sync group lists.
@@ -266,6 +198,3 @@ export const infoRegistry = new InfoRegistry();
 if (!globalThis.__unipi_info_registry) {
   globalThis.__unipi_info_registry = infoRegistry;
 }
-export const getGlobalRegistry = (): InfoRegistry => {
-  return (globalThis.__unipi_info_registry as InfoRegistry | undefined) ?? infoRegistry;
-};

package/packages/info-screen/tui/info-overlay.ts

@@ -8,12 +8,12 @@
  */
 
 import type { Component } from "@earendil-works/pi-tui";
-import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { infoRegistry } from "../registry.js";
 import { getInfoSettings } from "../config.js";
 import type { InfoGroup, GroupData } from "../types.js";
-import { boxInnerWidth } from "@pi-unipi/core";
+import { boxInnerWidth, OverlayTheme } from "@pi-unipi/core";
 
 /**
  * How long to wait before warming the non-visible tabs.
@@ -63,11 +63,17 @@ export class InfoOverlay implements Component {
 
   onClose?: () => void;
   requestRender?: () => void;
+  /**
+   * Whether this overlay is the focused (topmost) entry in the TUI overlay
+   * stack. The boot auto-close timer only fires while this is true — see
+   * `startBootTimer` for why.
+   */
+  isTopmostOverlay?: () => boolean;
 
-  private theme: Theme | null = null;
+  private overlay = new OverlayTheme();
 
   setTheme(theme: Theme): void {
-    this.theme = theme;
+    this.overlay.setTheme(theme);
   }
 
   constructor() {
@@ -230,17 +236,36 @@ export class InfoOverlay implements Component {
    *
    * Used when the overlay is shown on boot: the dashboard is informational, so
    * it should get out of the way on its own rather than requiring a keypress.
+   *
+   * The close callback (`onClose` → `done`) pops the *topmost* overlay in the
+   * TUI stack, not this one specifically. When another overlay (e.g. the
+   * updater's "Update Available" prompt) is stacked on top, firing `done()`
+   * here would remove the covering overlay and strand this dashboard with a
+   * spent one-shot close the user can no longer trigger — leaving the starting
+   * screen stuck. So we defer the auto-close until we are actually the
+   * focused/topmost overlay; the user can still press q/Esc to dismiss it once
+   * the covering overlay is gone.
    */
   startBootTimer(ms: number): void {
     this.cancelBootTimer();
     if (!Number.isFinite(ms) || ms <= 0) return;
-    this.bootTimer = setTimeout(() => {
-      this.bootTimer = null;
-      if (this._destroyed) return;
-      this.destroy();
-      this.onClose?.();
-    }, ms);
-    this.bootTimer.unref?.();
+    const arm = (): void => {
+      this.bootTimer = setTimeout(() => {
+        this.bootTimer = null;
+        if (this._destroyed) return;
+        if (this.isTopmostOverlay && !this.isTopmostOverlay()) {
+          // Something is stacked on top of us — closing now would pop it
+          // instead of this dashboard. Retry shortly; once the covering
+          // overlay closes we'll be topmost and can auto-close safely.
+          arm();
+          return;
+        }
+        this.destroy();
+        this.onClose?.();
+      }, ms);
+      this.bootTimer.unref?.();
+    };
+    arm();
   }
 
   invalidate(): void {
@@ -251,17 +276,17 @@ export class InfoOverlay implements Component {
     // Any keypress means the user is driving; stop the boot auto-close.
     this.cancelBootTimer();
 
-    if (data === "\x1b[C" || data === "l") {
+    if (matchesKey(data, Key.right) || data === "l") {
       this.activeTabIndex = (this.activeTabIndex + 1) % this.groups.length;
       this.scrollOffset = 0;
       this.fetchActiveGroup();
-    } else if (data === "\x1b[D" || data === "h") {
+    } else if (matchesKey(data, Key.left) || data === "h") {
       this.activeTabIndex = (this.activeTabIndex - 1 + this.groups.length) % this.groups.length;
       this.scrollOffset = 0;
       this.fetchActiveGroup();
-    } else if (data === "\x1b[B" || data === "j") {
+    } else if (matchesKey(data, Key.down) || data === "j") {
       this.scrollOffset++;
-    } else if (data === "\x1b[A" || data === "k") {
+    } else if (matchesKey(data, Key.up) || data === "k") {
       this.scrollOffset = Math.max(0, this.scrollOffset - 1);
     } else if (data === "g") {
       this.scrollOffset = 0;
@@ -273,7 +298,7 @@ export class InfoOverlay implements Component {
     } else if (data === "R") {
       // Refresh all
       this.refreshAll();
-    } else if (data === "q" || matchesKey(data, "escape")) {
+    } else if (data === "q" || matchesKey(data, Key.escape)) {
       this.destroy();
       this.onClose?.();
     }
@@ -309,60 +334,20 @@ export class InfoOverlay implements Component {
     return this.renderDashboard(width);
   }
 
-  // ─── Theme helpers ───────────────────────────────────────────────────
-
-  private fg(color: string, text: string): string {
-    if (this.theme) return this.theme.fg(color as any, text);
-    const c: Record<string, string> = {
-      accent: "\x1b[36m", success: "\x1b[32m", warning: "\x1b[33m",
-      error: "\x1b[31m", dim: "\x1b[2m", borderMuted: "\x1b[90m",
-    };
-    return `${c[color] ?? ""}${text}\x1b[0m`;
-  }
-
-  private bold(text: string): string {
-    return this.theme ? this.theme.bold(text) : `\x1b[1m${text}\x1b[0m`;
-  }
-
-  private bg(color: string, text: string): string {
-    return this.theme ? this.theme.bg(color as any, text) : text;
-  }
-
-  private frameLine(content: string, innerWidth: number): string {
-    const truncated = truncateToWidth(content, innerWidth, "");
-    const padding = Math.max(0, innerWidth - visibleWidth(truncated));
-    return `${this.fg("borderMuted", "│")}${truncated}${" ".repeat(padding)}${this.fg("borderMuted", "│")}`;
-  }
-
-  private ruleLine(innerWidth: number): string {
-    return this.fg("borderMuted", `├${"─".repeat(innerWidth)}┤`);
-  }
-
-  private borderLine(innerWidth: number, edge: "top" | "bottom"): string {
-    const left = edge === "top" ? "┌" : "└";
-    const right = edge === "top" ? "┐" : "┘";
-    return this.fg("borderMuted", `${left}${"─".repeat(innerWidth)}${right}`);
-  }
-
-  private getDialogHeight(): number {
-    const terminalRows = process.stdout.rows ?? 30;
-    return Math.max(18, Math.min(32, Math.floor(terminalRows * 0.78)));
-  }
-
   // ─── State views ─────────────────────────────────────────────────────
 
   private renderEmpty(width: number): string[] {
     const innerWidth = boxInnerWidth(width);
     const lines: string[] = [];
-    lines.push(this.borderLine(innerWidth, "top"));
-    lines.push(this.frameLine(this.fg("accent", this.bold("📊 UniPi Info Screen")), innerWidth));
-    lines.push(this.ruleLine(innerWidth));
-    lines.push(this.frameLine(this.fg("dim", "No groups registered."), innerWidth));
-    lines.push(this.frameLine(this.fg("dim", "Modules will register groups on startup."), innerWidth));
-    for (let i = 0; i < 4; i++) lines.push(this.frameLine("", innerWidth));
-    lines.push(this.ruleLine(innerWidth));
-    lines.push(this.frameLine(this.fg("dim", "q/Esc close · r refresh"), innerWidth));
-    lines.push(this.borderLine(innerWidth, "bottom"));
+    lines.push(this.overlay.borderLine(innerWidth, "top"));
+    lines.push(this.overlay.frameLine(this.overlay.fg("accent", this.overlay.bold("📊 UniPi Info Screen")), innerWidth));
+    lines.push(this.overlay.ruleLine(innerWidth));
+    lines.push(this.overlay.frameLine(this.overlay.fg("dim", "No groups registered."), innerWidth));
+    lines.push(this.overlay.frameLine(this.overlay.fg("dim", "Modules will register groups on startup."), innerWidth));
+    for (let i = 0; i < 4; i++) lines.push(this.overlay.frameLine("", innerWidth));
+    lines.push(this.overlay.ruleLine(innerWidth));
+    lines.push(this.overlay.frameLine(this.overlay.fg("dim", "q/Esc close · r refresh"), innerWidth));
+    lines.push(this.overlay.borderLine(innerWidth, "bottom"));
     return lines;
   }
 
@@ -377,19 +362,19 @@ export class InfoOverlay implements Component {
     const CONTENT_HEIGHT = 12;
     const lines: string[] = [];
 
-    lines.push(this.borderLine(innerWidth, "top"));
+    lines.push(this.overlay.borderLine(innerWidth, "top"));
 
     // Header: group name + loading indicator
     const loadingDot = isLoading
-      ? ` ${this.fg("warning", "●")}`
-      : ` ${this.fg("success", "●")}`;
-    const headerText = this.fg("accent", this.bold(` ${group.icon} ${group.name} `)) + loadingDot;
-    lines.push(this.frameLine(headerText, innerWidth));
-    lines.push(this.ruleLine(innerWidth));
+      ? ` ${this.overlay.fg("warning", "●")}`
+      : ` ${this.overlay.fg("success", "●")}`;
+    const headerText = this.overlay.fg("accent", this.overlay.bold(` ${group.icon} ${group.name} `)) + loadingDot;
+    lines.push(this.overlay.frameLine(headerText, innerWidth));
+    lines.push(this.overlay.ruleLine(innerWidth));
 
     // Tab bar
-    lines.push(this.frameLine(this.renderTabBar(innerWidth), innerWidth));
-    lines.push(this.ruleLine(innerWidth));
+    lines.push(this.overlay.frameLine(this.renderTabBar(innerWidth), innerWidth));
+    lines.push(this.overlay.ruleLine(innerWidth));
 
     // Content with scrolling
     const contentLines = this.renderGroupContent(innerWidth, group, data);
@@ -399,13 +384,13 @@ export class InfoOverlay implements Component {
 
     const visible = wrapped.slice(this.scrollOffset, this.scrollOffset + CONTENT_HEIGHT);
     for (let i = 0; i < CONTENT_HEIGHT; i++) {
-      lines.push(this.frameLine(visible[i] ?? "", innerWidth));
+      lines.push(this.overlay.frameLine(visible[i] ?? "", innerWidth));
     }
 
     // Footer
-    lines.push(this.ruleLine(innerWidth));
-    lines.push(this.frameLine(this.renderFooter(innerWidth, wrapped.length, CONTENT_HEIGHT), innerWidth));
-    lines.push(this.borderLine(innerWidth, "bottom"));
+    lines.push(this.overlay.ruleLine(innerWidth));
+    lines.push(this.overlay.frameLine(this.renderFooter(innerWidth, wrapped.length, CONTENT_HEIGHT), innerWidth));
+    lines.push(this.overlay.borderLine(innerWidth, "bottom"));
 
     return lines;
   }
@@ -414,7 +399,7 @@ export class InfoOverlay implements Component {
     if (this.groups.length === 0) return "";
 
     const tabWidths = this.groups.map(g => visibleWidth(` ${g.icon} ${g.name} `));
-    const sepW = visibleWidth(this.fg("borderMuted", "│"));
+    const sepW = visibleWidth(this.overlay.fg("borderMuted", "│"));
     const indicatorSpace = 3;
     let maxTabs = 0;
     let totalW = 0;
@@ -443,18 +428,18 @@ export class InfoOverlay implements Component {
       const color = TAB_FG[i % TAB_FG.length]!;
       // Per-tab loading indicator
       const isLoading = this.groupLoading.get(g.id) ?? false;
-      const dot = isLoading ? this.fg("warning", "●") : "";
+      const dot = isLoading ? this.overlay.fg("warning", "●") : "";
 
       if (isActive) {
-        tabs.push(this.fg(color, this.bold(` ${g.icon} ${g.name} ${dot}`)));
+        tabs.push(this.overlay.fg(color, this.overlay.bold(` ${g.icon} ${g.name} ${dot}`)));
       } else {
-        tabs.push(this.fg("dim", ` ${g.icon} ${g.name} ${dot}`));
+        tabs.push(this.overlay.fg("dim", ` ${g.icon} ${g.name} ${dot}`));
       }
     }
 
-    const tabStr = tabs.join(this.fg("borderMuted", "│"));
-    if (this.tabScrollOffset > 0) return `${this.fg("dim", "◀")} ${tabStr}`;
-    if (this.tabScrollOffset + maxTabs < this.groups.length) return `${tabStr} ${this.fg("dim", "▶")}`;
+    const tabStr = tabs.join(this.overlay.fg("borderMuted", "│"));
+    if (this.tabScrollOffset > 0) return `${this.overlay.fg("dim", "◀")} ${tabStr}`;
+    if (this.tabScrollOffset + maxTabs < this.groups.length) return `${tabStr} ${this.overlay.fg("dim", "▶")}`;
     return tabStr;
   }
 
@@ -465,15 +450,15 @@ export class InfoOverlay implements Component {
       const isActive = i === this.activeTabIndex;
       const color = TAB_FG[i % TAB_FG.length]!;
       const isLoading = this.groupLoading.get(g.id) ?? false;
-      const dot = isLoading ? this.fg("warning", "●") : "";
+      const dot = isLoading ? this.overlay.fg("warning", "●") : "";
 
       if (isActive) {
-        tabs.push(this.fg(color, this.bold(` ${g.icon} ${g.name} ${dot}`)));
+        tabs.push(this.overlay.fg(color, this.overlay.bold(` ${g.icon} ${g.name} ${dot}`)));
       } else {
-        tabs.push(this.fg("dim", ` ${g.icon} ${g.name} ${dot}`));
+        tabs.push(this.overlay.fg("dim", ` ${g.icon} ${g.name} ${dot}`));
       }
     }
-    return tabs.join(this.fg("borderMuted", "│"));
+    return tabs.join(this.overlay.fg("borderMuted", "│"));
   }
 
   private renderGroupContent(width: number, group: InfoGroup, data: GroupData): string[] {
@@ -482,14 +467,14 @@ export class InfoOverlay implements Component {
     const visibleStats = infoRegistry.getVisibleStats(group.id);
 
     if (visibleStats.length === 0) {
-      lines.push(`  ${this.fg("dim", "No stats configured for this group.")}`);
+      lines.push(`  ${this.overlay.fg("dim", "No stats configured for this group.")}`);
       return lines;
     }
 
     // If no data yet and loading, show placeholder per stat
     if (Object.keys(data).length === 0 && isLoading) {
       for (const stat of visibleStats) {
-        lines.push(`  ${this.fg("dim", `${stat.label}:`)} ${this.fg("warning", "···")}`);
+        lines.push(`  ${this.overlay.fg("dim", `${stat.label}:`)} ${this.overlay.fg("warning", "···")}`);
       }
       return lines;
     }
@@ -502,12 +487,12 @@ export class InfoOverlay implements Component {
       const detail = statData?.detail;
 
       const label = `${stat.label}:`.padEnd(maxLabelLen + 1);
-      let line = `  ${this.fg("dim", label)} ${this.bold(value)}`;
+      let line = `  ${this.overlay.fg("dim", label)} ${this.overlay.bold(value)}`;
 
       if (detail) {
         const detailLines = detail.split("\n");
         if (detailLines.length === 1) {
-          line += ` ${this.fg("dim", `(${detail})`)}`;
+          line += ` ${this.overlay.fg("dim", `(${detail})`)}`;
         } else {
           lines.push(line);
           for (const dLine of detailLines) {
@@ -536,7 +521,7 @@ export class InfoOverlay implements Component {
     const hasScroll = totalLines > visibleHeight;
     let scrollStr = "";
     if (hasScroll) {
-      scrollStr = this.fg("dim", `${this.scrollOffset + 1}-${Math.min(this.scrollOffset + visibleHeight, totalLines)}/${totalLines}`);
+      scrollStr = this.overlay.fg("dim", `${this.scrollOffset + 1}-${Math.min(this.scrollOffset + visibleHeight, totalLines)}/${totalLines}`);
     }
 
     // Last updated for active group
@@ -545,17 +530,17 @@ export class InfoOverlay implements Component {
     const age = lastUp > 0 ? humanizeAge(Date.now() - lastUp) : "loading…";
 
     const hints = [
-      `${this.fg("accent", "←/→")} tabs`,
-      `${this.fg("success", "↑/↓")} scroll`,
-      `${this.fg("warning", "r")} refresh`,
-      `${this.fg("error", "q/Esc")} close`,
+      `${this.overlay.fg("accent", "←/→")} tabs`,
+      `${this.overlay.fg("success", "↑/↓")} scroll`,
+      `${this.overlay.fg("warning", "r")} refresh`,
+      `${this.overlay.fg("error", "q/Esc")} close`,
     ];
 
-    const hintStr = hints.join(`  ${this.fg("borderMuted", "•")}  `);
+    const hintStr = hints.join(`  ${this.overlay.fg("borderMuted", "•")}  `);
 
     // Build right side: age + hints
-    const ageStr = this.fg("dim", `⏱ ${age}`);
-    const rightStr = `${ageStr}  ${this.fg("borderMuted", "│")}  ${hintStr}`;
+    const ageStr = this.overlay.fg("dim", `⏱ ${age}`);
+    const rightStr = `${ageStr}  ${this.overlay.fg("borderMuted", "│")}  ${hintStr}`;
 
     const scrollW = visibleWidth(scrollStr);
     const rightW = visibleWidth(rightStr);

package/packages/info-screen/usage-parser.ts

@@ -25,13 +25,10 @@ export interface UsageStats {
     today: number;
     week: number;
     month: number;
-    allTime: number;
   };
   /** Total cost by period (USD) */
   cost: {
     today: number;
-    week: number;
-    month: number;
     allTime: number;
   };
   /** Token counts by model (all time) */
@@ -44,8 +41,6 @@ export interface UsageStats {
   byModelMonth: Record<string, { tokens: number; cost: number; sessions: number }>;
   /** Total sessions */
   sessionCount: number;
-  /** Total messages */
-  messageCount: number;
 }
 
 /** Time period boundaries */
@@ -275,16 +270,8 @@ function collectSessionFiles(dir: string, files: string[]): void {
 }
 
 /**
- * Parse all session files and aggregate usage stats.
- * Matches tmustier's parsing logic.
- */
-export function parseUsageStats(): UsageStats {
-  const { stats } = collectStats(null);
-  return stats;
-}
-
-/**
- * Async variant that yields to the event loop while parsing.
+ * Parse all session files and aggregate usage stats, yielding to the event
+ * loop while parsing.
  *
  * A cold parse is several seconds of pure CPU. Running it synchronously starves
  * the event loop, so keystrokes queue up and the UI cannot repaint. Deferring
@@ -292,41 +279,34 @@ export function parseUsageStats(): UsageStats {
  * `yieldEvery` files, control returns to the loop.
  */
 export async function parseUsageStatsAsync(): Promise<UsageStats> {
-  const yielder = async (): Promise<void> => {
-    await new Promise<void>((resolve) => setImmediate(resolve));
-  };
-  const { stats, pending } = collectStats(yielder);
-  if (pending) await pending;
+  const { stats, pending } = collectStats();
+  await pending;
   return stats;
 }
 
 /** Empty stats accumulator. */
 function emptyStats(): UsageStats {
   return {
-    tokens: { today: 0, week: 0, month: 0, allTime: 0 },
-    cost: { today: 0, week: 0, month: 0, allTime: 0 },
+    tokens: { today: 0, week: 0, month: 0 },
+    cost: { today: 0, allTime: 0 },
     byModel: {},
     byModelToday: {},
     byModelWeek: {},
     byModelMonth: {},
     sessionCount: 0,
-    messageCount: 0,
   };
 }
 
 /**
- * Shared implementation for the sync and async entry points.
+ * Scan all session files and aggregate usage stats.
  *
- * When `yielder` is null the whole scan runs synchronously and `stats` is fully
- * populated on return. When provided, the returned `stats` object is filled in
- * as `pending` progresses, and the caller must await it.
+ * The returned `stats` object is filled in as `pending` progresses; the caller
+ * must await it.
  */
-function collectStats(
-  yielder: (() => Promise<void>) | null,
-): { stats: UsageStats; pending: Promise<void> | null } {
+function collectStats(): { stats: UsageStats; pending: Promise<void> } {
   const stats = emptyStats();
   const sessionsDir = getSessionsDir();
-  if (!existsSync(sessionsDir)) return { stats, pending: null };
+  if (!existsSync(sessionsDir)) return { stats, pending: Promise.resolve() };
 
   const sessionFiles: string[] = [];
   collectSessionFiles(sessionsDir, sessionFiles);
@@ -405,7 +385,6 @@ function collectStats(
       counted++;
       const model = models[modelIdx] ?? "unknown";
 
-      stats.tokens.allTime += countedTokens;
       stats.cost.allTime += cost;
       bump(stats.byModel, model, countedTokens, cost);
 
@@ -416,19 +395,16 @@ function collectStats(
       }
       if (timestamp >= weekStart) {
         stats.tokens.week += countedTokens;
-        stats.cost.week += cost;
         bump(stats.byModelWeek, model, countedTokens, cost);
       }
       if (timestamp >= monthStart) {
         stats.tokens.month += countedTokens;
-        stats.cost.month += cost;
         bump(stats.byModelMonth, model, countedTokens, cost);
       }
     }
 
     if (counted > 0) {
       stats.sessionCount++;
-      stats.messageCount += counted;
     }
   };
 
@@ -440,17 +416,6 @@ function collectStats(
 
   const YIELD_EVERY = 25;
 
-  if (!yielder) {
-    for (const item of work) {
-      const records = item.cached
-        ? item.cached.records
-        : (nextFiles[item.path].records = extractRecords(item.path, modelIndex, models));
-      aggregate(records);
-    }
-    finish();
-    return { stats, pending: null };
-  }
-
   const pending = (async () => {
     let sinceYield = 0;
     for (const item of work) {
@@ -467,7 +432,7 @@ function collectStats(
       aggregate(records);
       if (sinceYield >= YIELD_EVERY) {
         sinceYield = 0;
-        await yielder();
+        await new Promise<void>((resolve) => setImmediate(resolve));
       }
     }
     finish();

package/packages/input-shortcuts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/input-shortcuts",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "description": "Keyboard shortcuts for stash/restore, undo/redo, clipboard, and thinking toggle — chord-based overlay system",
   "type": "module",
   "main": "src/index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.6.0"
+    "@pi-unipi/core": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/input-shortcuts/src/index.ts

@@ -12,7 +12,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Key } from "@earendil-works/pi-tui";
+import { Key, matchesKey } from "@earendil-works/pi-tui";
 import { MODULES, emitEvent, UNIPI_EVENTS, INPUT_SHORTCUTS_COMMANDS } from "@pi-unipi/core";
 import { RegisterStore } from "./registers.ts";
 import { UndoRedoBuffer } from "./undo-redo.ts";
@@ -20,6 +20,7 @@ import { ChordOverlay, type ChordCallbacks } from "./chord-overlay.ts";
 import { SettingsOverlay } from "./settings-overlay.ts";
 import { loadConfig } from "./settings-overlay.ts";
 import { copyToClipboard } from "./clipboard.ts";
+import { THINKING_CYCLE } from "./types.ts";
 
 // ─── Status feedback ────────────────────────────────────────────────────────
 
@@ -111,7 +112,7 @@ export default function inputShortcutsExtension(pi: ExtensionAPI): void {
       if (!ui || suppressInputListener) return;
 
       // Only snapshot for edit keys (printable, backspace, delete, enter)
-      const isEditKey = data.length === 1 || data === "\x7f" || data === "\x1b[3~" || data === "\r" || data === "\n";
+      const isEditKey = data.length === 1 || data === "\x7f" || matchesKey(data, Key.delete) || data === "\r" || data === "\n";
       if (!isEditKey) return;
 
       // Capture text BEFORE the keypress is processed by the editor
@@ -254,7 +255,6 @@ export default function inputShortcutsExtension(pi: ExtensionAPI): void {
 
   function doToggleThinking(): void {
     const current = pi.getThinkingLevel();
-    const THINKING_CYCLE = ["off", "low", "medium", "high", "xhigh"] as const;
     const idx = THINKING_CYCLE.indexOf(current as any);
     const nextIdx = idx >= 0 ? (idx + 1) % THINKING_CYCLE.length : 0;
     const next = THINKING_CYCLE[nextIdx];

package/packages/input-shortcuts/src/registers.ts

@@ -44,14 +44,6 @@ export class RegisterStore {
     return this.data!.registers[index] ?? "";
   }
 
-  /** Set a numbered register (0-9) and persist. */
-  setRegister(index: number, text: string): void {
-    if (index < 0 || index > 9) return;
-    this.ensureLoaded();
-    this.data!.registers[index] = text;
-    this.save();
-  }
-
   /** Lazy load from disk on first access. */
   private ensureLoaded(): void {
     if (this.loaded) return;