@pi-unipi/footer 0.1.2 → 0.1.4

package/src/events.ts

@@ -30,8 +30,8 @@ export function subscribeToEvents(
     pi.events.on(UNIPI_EVENTS.COMPACTOR_STATS_UPDATED, (event: unknown) => {
       try {
         registry.updateData("compactor", event);
-      } catch (err) {
-        console.error("[footer] Compactor stats handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -41,8 +41,8 @@ export function subscribeToEvents(
       try {
         const existing = registry.getGroupData("compactor") as Record<string, unknown> | undefined;
         registry.updateData("compactor", { ...existing, lastCompaction: event });
-      } catch (err) {
-        console.error("[footer] Compaction handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -54,8 +54,8 @@ export function subscribeToEvents(
       try {
         const existing = registry.getGroupData("memory") as Record<string, unknown> | undefined;
         registry.updateData("memory", { ...existing, lastStored: event });
-      } catch (err) {
-        console.error("[footer] Memory stored handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -65,8 +65,8 @@ export function subscribeToEvents(
       try {
         const existing = registry.getGroupData("memory") as Record<string, unknown> | undefined;
         registry.updateData("memory", { ...existing, lastDeleted: event });
-      } catch (err) {
-        console.error("[footer] Memory deleted handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -76,8 +76,8 @@ export function subscribeToEvents(
       try {
         const existing = registry.getGroupData("memory") as Record<string, unknown> | undefined;
         registry.updateData("memory", { ...existing, lastConsolidated: event });
-      } catch (err) {
-        console.error("[footer] Memory consolidated handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -94,8 +94,8 @@ export function subscribeToEvents(
         const serversActive = (typeof existing?.serversActive === "number" ? existing.serversActive : 0) + 1;
         const toolsTotal = (typeof existing?.toolsTotal === "number" ? existing.toolsTotal : 0) + toolCount;
         registry.updateData("mcp", { ...existing, serversTotal, serversActive, toolsTotal, lastServerStarted: event });
-      } catch (err) {
-        console.error("[footer] MCP server started handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -116,8 +116,8 @@ export function subscribeToEvents(
           toolsTotal = Math.max(0, toolsTotal - lastStartedCount);
         }
         registry.updateData("mcp", { ...existing, serversActive, toolsTotal, lastServerStopped: event });
-      } catch (err) {
-        console.error("[footer] MCP server stopped handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -129,8 +129,8 @@ export function subscribeToEvents(
         const serversTotal = (typeof existing?.serversTotal === "number" ? existing.serversTotal : 0) + 1;
         const serversFailed = (typeof existing?.serversFailed === "number" ? existing.serversFailed : 0) + 1;
         registry.updateData("mcp", { ...existing, serversTotal, serversFailed, lastServerError: event });
-      } catch (err) {
-        console.error("[footer] MCP server error handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -143,8 +143,8 @@ export function subscribeToEvents(
         const toolNames = Array.isArray(evt?.toolNames) ? evt.toolNames : [];
         const toolsTotal = (typeof existing?.toolsTotal === "number" ? existing.toolsTotal : 0) + toolNames.length;
         registry.updateData("mcp", { ...existing, toolsTotal, lastToolsRegistered: event });
-      } catch (err) {
-        console.error("[footer] MCP tools registered handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -157,8 +157,8 @@ export function subscribeToEvents(
         const toolNames = Array.isArray(evt?.toolNames) ? evt.toolNames : [];
         const toolsTotal = Math.max(0, (typeof existing?.toolsTotal === "number" ? existing.toolsTotal : 0) - toolNames.length);
         registry.updateData("mcp", { ...existing, toolsTotal, lastToolsUnregistered: event });
-      } catch (err) {
-        console.error("[footer] MCP tools unregistered handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -169,8 +169,8 @@ export function subscribeToEvents(
     pi.events.on(UNIPI_EVENTS.RALPH_LOOP_START, (event: unknown) => {
       try {
         registry.updateData("ralph", { ...(event as Record<string, unknown>), active: true });
-      } catch (err) {
-        console.error("[footer] Ralph loop start handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -179,8 +179,8 @@ export function subscribeToEvents(
     pi.events.on(UNIPI_EVENTS.RALPH_LOOP_END, (event: unknown) => {
       try {
         registry.updateData("ralph", { ...(event as Record<string, unknown>), active: false });
-      } catch (err) {
-        console.error("[footer] Ralph loop end handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -190,8 +190,8 @@ export function subscribeToEvents(
       try {
         const existing = registry.getGroupData("ralph") as Record<string, unknown> | undefined;
         registry.updateData("ralph", { ...existing, lastIteration: event });
-      } catch (err) {
-        console.error("[footer] Ralph iteration handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -202,8 +202,8 @@ export function subscribeToEvents(
     pi.events.on(UNIPI_EVENTS.WORKFLOW_START, (event: unknown) => {
       try {
         registry.updateData("workflow", { ...(event as Record<string, unknown>), active: true, startTime: Date.now() });
-      } catch (err) {
-        console.error("[footer] Workflow start handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -212,8 +212,8 @@ export function subscribeToEvents(
     pi.events.on(UNIPI_EVENTS.WORKFLOW_END, (event: unknown) => {
       try {
         registry.updateData("workflow", { ...(event as Record<string, unknown>), active: false });
-      } catch (err) {
-        console.error("[footer] Workflow end handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -224,8 +224,8 @@ export function subscribeToEvents(
     pi.events.on(UNIPI_EVENTS.NOTIFICATION_SENT, (event: unknown) => {
       try {
         registry.updateData("notify", event);
-      } catch (err) {
-        console.error("[footer] Notification handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );
@@ -237,8 +237,8 @@ export function subscribeToEvents(
       try {
         // Invalidate all caches when new modules load — they may bring fresh data
         registry.invalidateAll();
-      } catch (err) {
-        console.error("[footer] Module ready handler error:", err);
+      } catch {
+        // Silently ignore — event handler errors are non-blocking.
       }
     })
   );

package/src/help.ts

@@ -0,0 +1,160 @@
+/**
+ * @pi-unipi/footer — Footer help overlay
+ *
+ * Shows an overlay listing all enabled segments grouped by zone,
+ * with icons, short labels, and descriptions.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { FooterSegment, SegmentZone } from "./types.js";
+import { getIcon } from "./rendering/icons.js";
+import { loadFooterSettings, isSegmentEnabled } from "./config.js";
+import { getPreset } from "./presets.js";
+
+/** Zone display names and order */
+const ZONE_META: Record<SegmentZone, { title: string; order: number }> = {
+  left: { title: "LEFT ZONE (Identity)", order: 0 },
+  center: { title: "CENTER ZONE (Metrics)", order: 1 },
+  right: { title: "RIGHT ZONE (Time)", order: 2 },
+};
+
+/** Build the help content lines */
+function buildHelpLines(
+  segments: FooterSegment[],
+  presetName: string,
+): string[] {
+  const settings = loadFooterSettings();
+  const preset = getPreset(presetName);
+  const enabledIds = new Set([
+    ...preset.leftSegments,
+    ...preset.rightSegments,
+    ...preset.secondarySegments,
+  ]);
+
+  // Filter to enabled segments only
+  const enabled = segments.filter(seg => {
+    if (!enabledIds.has(seg.id)) return false;
+    return isSegmentEnabled(getGroupForSegment(seg.id), seg.id);
+  });
+
+  if (enabled.length === 0) {
+    return ["No segments enabled."];
+  }
+
+  // Group by zone
+  const zones: Record<SegmentZone, FooterSegment[]> = { left: [], center: [], right: [] };
+  for (const seg of enabled) {
+    zones[seg.zone].push(seg);
+  }
+
+  const lines: string[] = [];
+
+  for (const zoneKey of (["left", "center", "right"] as SegmentZone[])) {
+    const zoneSegs = zones[zoneKey];
+    if (zoneSegs.length === 0) continue;
+
+    const meta = ZONE_META[zoneKey];
+    lines.push(`  ${meta.title}`);
+    lines.push("");
+
+    for (const seg of zoneSegs) {
+      const icon = getIcon(seg.id);
+      const label = seg.shortLabel;
+      const desc = seg.description;
+      const iconStr = icon ? `${icon} ` : "  ";
+      lines.push(`    ${iconStr}${label.padEnd(6)} ${desc}`);
+    }
+
+    lines.push("");
+  }
+
+  return lines;
+}
+
+/** Simple group lookup for help */
+function getGroupForSegment(segId: string): string {
+  const coreIds = ["model", "api_state", "tool_count", "git", "context_pct", "cost", "tokens_total", "tokens_in", "tokens_out", "session", "hostname", "time", "tps", "clock", "duration", "thinking_level"];
+  if (coreIds.includes(segId)) return "core";
+  const compactorIds = ["session_events", "compactions", "tokens_saved", "compression_ratio", "indexed_docs", "sandbox_runs", "search_queries"];
+  if (compactorIds.includes(segId)) return "compactor";
+  if (["project_count", "total_count", "consolidations"].includes(segId)) return "memory";
+  if (["servers_total", "servers_active", "tools_total", "servers_failed"].includes(segId)) return "mcp";
+  if (["active_loops", "total_iterations", "loop_status"].includes(segId)) return "ralph";
+  if (["current_command", "sandbox_level", "command_duration"].includes(segId)) return "workflow";
+  if (["docs_count", "tasks_done", "tasks_total", "task_pct"].includes(segId)) return "kanboard";
+  if (["platforms_enabled", "last_sent"].includes(segId)) return "notify";
+  if (segId === "extension_statuses") return "status_ext";
+  return "core";
+}
+
+/**
+ * Show the footer help overlay.
+ * Lists all enabled segments grouped by zone with descriptions.
+ */
+export function showFooterHelp(
+  pi: ExtensionAPI,
+  segments: FooterSegment[],
+  presetName: string,
+): void {
+  const lines = buildHelpLines(segments, presetName);
+
+  // Use pi's custom UI overlay
+  const ctx = (pi as any)._ctx;
+  if (ctx?.ui?.custom) {
+    ctx.ui.custom((tui: any) => {
+      let scrollOffset = 0;
+
+      return {
+        dispose() {},
+        render(width: number, height: number): string[] {
+          const maxVisible = height - 2; // border lines
+          const visibleLines = lines.slice(scrollOffset, scrollOffset + maxVisible);
+
+          const result: string[] = [];
+
+          // Top border
+          const title = " ? Footer Segment Guide ";
+          const borderLen = Math.max(width - 2, title.length + 4);
+          result.push(`\x1b[2m┌${"─".repeat(borderLen)}┐\x1b[0m`);
+
+          // Title
+          result.push(`\x1b[2m│\x1b[0m \x1b[1m${title}\x1b[0m${" ".repeat(Math.max(0, borderLen - title.length - 1))}\x1b[2m│\x1b[0m`);
+
+          // Content
+          for (const line of visibleLines) {
+            const padded = line.length > borderLen - 2
+              ? line.slice(0, borderLen - 2)
+              : line + " ".repeat(Math.max(0, borderLen - 2 - line.length));
+            result.push(`\x1b[2m│\x1b[0m ${padded} \x1b[2m│\x1b[0m`);
+          }
+
+          // Bottom border
+          result.push(`\x1b[2m├${"─".repeat(borderLen)}┤\x1b[0m`);
+          result.push(`\x1b[2m│\x1b[0m \x1b[2m↑↓ scroll · q close\x1b[0m${" ".repeat(Math.max(0, borderLen - 20))} \x1b[2m│\x1b[0m`);
+          result.push(`\x1b[2m└${"─".repeat(borderLen)}┘\x1b[0m`);
+
+          return result;
+        },
+        handleInput(key: string): boolean {
+          if (key === "q" || key === "Escape" || key === "Enter") {
+            return false; // Close overlay
+          }
+          if (key === "ArrowUp" || key === "k") {
+            scrollOffset = Math.max(0, scrollOffset - 1);
+            return true;
+          }
+          if (key === "ArrowDown" || key === "j") {
+            scrollOffset = Math.min(Math.max(0, lines.length - 5), scrollOffset + 1);
+            return true;
+          }
+          return true; // Consume all other keys
+        },
+      };
+    });
+  } else {
+    // Fallback: print to console
+    for (const line of lines) {
+      console.log(line);
+    }
+  }
+}

package/src/index.ts

@@ -26,7 +26,8 @@ import { NOTIFY_SEGMENTS } from "./segments/notify.js";
 import { STATUS_EXT_SEGMENTS } from "./segments/status-ext.js";
 
 import type { FooterGroup, FooterSegment } from "./types.js";
-import { getThinkingLevel, rainbowBorder } from "./segments/core.js";
+import { rainbowBorder } from "./segments/core.js";
+import { tpsTracker } from "./tps-tracker.js";
 
 /** All segment groups */
 const ALL_GROUPS: FooterGroup[] = [
@@ -53,7 +54,7 @@ function buildSegmentLookup(): Map<string, FooterSegment> {
 }
 
 /** Extension state */
-interface FooterState {
+export interface FooterState {
   enabled: boolean;
   registry: FooterRegistry;
   renderer: FooterRenderer;
@@ -62,6 +63,9 @@ interface FooterState {
   piContext: unknown;
   footerData: unknown;
   tuiRef: any;
+  refreshTimer: ReturnType<typeof setInterval> | null;
+  /** Re-register footer + widgets with pi UI (for live enable) */
+  setupUI: ((pi: ExtensionAPI, ctx: any) => void) | null;
 }
 
 export default function footerExtension(pi: ExtensionAPI): void {
@@ -82,6 +86,8 @@ export default function footerExtension(pi: ExtensionAPI): void {
     piContext: null,
     footerData: null,
     tuiRef: null,
+    refreshTimer: null,
+    setupUI: null,
   };
 
   // Register all groups in the registry
@@ -105,6 +111,7 @@ export default function footerExtension(pi: ExtensionAPI): void {
 
     // Setup footer + widgets
     setupFooterUI(pi, ctx, state);
+    state.setupUI = (p: ExtensionAPI, c: any) => setupFooterUI(p, c, state);
   });
 
   pi.on("session_shutdown", async () => {
@@ -113,7 +120,12 @@ export default function footerExtension(pi: ExtensionAPI): void {
     state.unsubscribeEvents = null;
     state.piContext = null;
     state.footerData = null;
+    if (state.refreshTimer) {
+      clearInterval(state.refreshTimer);
+      state.refreshTimer = null;
+    }
     state.tuiRef = null;
+    tpsTracker.reset();
   });
 
   // ─── Register commands ──────────────────────────────────────────────────
@@ -126,7 +138,7 @@ export default function footerExtension(pi: ExtensionAPI): void {
     emitEvent(pi as any, UNIPI_EVENTS.MODULE_READY, {
       name: "@pi-unipi/footer",
       version: "0.1.0",
-      commands: [`${UNIPI_PREFIX}${FOOTER_COMMANDS.FOOTER}`, `${UNIPI_PREFIX}${FOOTER_COMMANDS.FOOTER_SETTINGS}`],
+      commands: [`${UNIPI_PREFIX}${FOOTER_COMMANDS.FOOTER}`, `${UNIPI_PREFIX}${FOOTER_COMMANDS.FOOTER_SETTINGS}`, `${UNIPI_PREFIX}${FOOTER_COMMANDS.FOOTER_HELP}`],
       tools: [],
     });
   });
@@ -138,6 +150,36 @@ function setupFooterUI(pi: ExtensionAPI, ctx: any, state: FooterState): void {
   // Register footer (minimal — handles branch changes)
   ctx.ui.setFooter((tui: any, _theme: Theme, footerData: any) => {
     state.tuiRef = tui;
+
+    // Start periodic refresh for time-sensitive segments (e.g. clock)
+    if (!state.refreshTimer) {
+      state.refreshTimer = setInterval(() => {
+        // Feed TPS tracker with per-message data
+        try {
+          const piCtx = state.piContext as Record<string, unknown> | undefined;
+          if (piCtx?.sessionManager) {
+            const sm = (piCtx as any).sessionManager;
+            const events = sm?.getBranch?.() ?? [];
+            let msgIndex = 0;
+            for (const e of events) {
+              if (!e || typeof e !== "object") continue;
+              if (e.type !== "message") continue;
+              const m = e.message;
+              if (!m || m.role !== "assistant") continue;
+              if (m.stopReason === "error" || m.stopReason === "aborted") continue;
+              const output = m.usage?.output ?? 0;
+              const hasStop = !!m.stopReason;
+              tpsTracker.onMessageUpdate(msgIndex, output, hasStop);
+              msgIndex++;
+            }
+          }
+        } catch {
+          // Silently ignore — TPS is best-effort
+        }
+        state.renderer.resetLayoutCache();
+        state.tuiRef?.requestRender();
+      }, 1_000);
+    }
     state.footerData = footerData;
     state.renderer.setContext(state.piContext, footerData);
 
@@ -178,7 +220,7 @@ function setupFooterUI(pi: ExtensionAPI, ctx: any, state: FooterState): void {
     };
   }, { placement: "aboveEditor" });
 
-  // Secondary row widget + rainbow input border for xhigh thinking
+  // Secondary row widget
   ctx.ui.setWidget("footer-secondary", (_tui: any, _theme: Theme) => {
     return {
       dispose() {},
@@ -190,12 +232,6 @@ function setupFooterUI(pi: ExtensionAPI, ctx: any, state: FooterState): void {
 
         const lines: string[] = [];
 
-        // Rainbow border for input bar when thinking level is xhigh
-        const thinkingLevel = getThinkingLevel(state.piContext);
-        if (thinkingLevel === "xhigh") {
-          lines.push(rainbowBorder(width));
-        }
-
         const layout = state.renderer.computeLayout(width);
         if (layout.secondaryContent) {
           lines.push(layout.secondaryContent);

package/src/presets.ts

@@ -2,8 +2,11 @@
  * @pi-unipi/footer — Presets system
  *
  * Preset definitions: default, minimal, compact, full, nerd, ascii.
- * Each preset defines which segments appear on left, right, and secondary rows,
+ * Each preset defines which segments appear (left/center/right/secondary),
  * plus separator style and color scheme.
+ *
+ * Segments are grouped by their zone field regardless of which array they're
+ * listed in. The arrays define ordering within the preset.
  */
 
 import type { PresetDef, SeparatorStyle, ColorScheme } from "./types.js";
@@ -12,100 +15,106 @@ import { getDefaultColors } from "./rendering/theme.js";
 /** Default preset — balanced view */
 const DEFAULT_PRESET: PresetDef = {
   leftSegments: [
-    "model", "thinking", "path", "git", "context_pct", "cost",
+    "model", "api_state", "tool_count", "git",
   ],
   rightSegments: [
-    "compactions", "tokens_saved", "project_count", "loop_status",
+    "tps", "context_pct", "cost",
+    "compactions", "tokens_saved", "project_count",
+    "current_command", "loop_status", "extension_statuses",
+    "clock", "duration",
   ],
   secondarySegments: [
-    "current_command", "session_events",
+    "session",
   ],
-  separator: "powerline-thin",
   colors: getDefaultColors(),
 };
 
 /** Minimal preset — just the essentials */
 const MINIMAL_PRESET: PresetDef = {
   leftSegments: [
-    "path", "git", "context_pct",
+    "model", "git",
+  ],
+  rightSegments: [
+    "context_pct",
+    "clock",
   ],
-  rightSegments: [],
   secondarySegments: [],
-  separator: "pipe",
   colors: getDefaultColors(),
 };
 
 /** Compact preset — core + key stats */
 const COMPACT_PRESET: PresetDef = {
   leftSegments: [
-    "model", "git", "cost", "context_pct",
+    "model", "git",
   ],
   rightSegments: [
-    "compactions", "total_count",
+    "tps", "context_pct", "cost",
+    "clock", "duration",
   ],
   secondarySegments: [],
-  separator: "dot",
   colors: getDefaultColors(),
 };
 
 /** Full preset — everything */
 const FULL_PRESET: PresetDef = {
   leftSegments: [
-    "model", "thinking", "path", "git", "context_pct", "cost",
-    "tokens_total", "tokens_in", "tokens_out",
+    "model", "api_state", "tool_count", "git", "current_command", "session",
   ],
   rightSegments: [
-    "session_events", "compactions", "tokens_saved", "compression_ratio",
-    "indexed_docs", "sandbox_runs", "search_queries",
-    "project_count", "total_count", "consolidations",
-    "servers_total", "servers_active", "tools_total", "servers_failed",
-    "active_loops", "total_iterations", "loop_status",
-    "current_command", "command_duration",
-    "docs_count", "tasks_done", "tasks_total", "task_pct",
+    "tps", "context_pct", "cost", "tokens_total",
+    "session_events", "compactions", "tokens_saved",
+    "project_count", "total_count",
+    "servers_total", "servers_active", "tools_total",
+    "active_loops", "loop_status",
+    "docs_count", "tasks_done", "task_pct",
     "extension_statuses",
+    "clock", "duration",
   ],
   secondarySegments: [
-    "hostname", "time",
+    "hostname",
+    "tokens_in", "tokens_out",
+    "compression_ratio", "indexed_docs",
     "platforms_enabled", "last_sent",
+    "thinking_level",
   ],
-  separator: "powerline-thin",
   colors: getDefaultColors(),
 };
 
 /** Nerd preset — maximum detail for Nerd Font users */
 const NERD_PRESET: PresetDef = {
   leftSegments: [
-    "model", "thinking", "path", "git", "context_pct", "cost",
-    "tokens_total",
+    "model", "api_state", "tool_count", "git", "current_command", "session",
   ],
   rightSegments: [
+    "tps", "context_pct", "cost", "tokens_total",
     "session_events", "compactions", "tokens_saved",
     "project_count", "total_count",
     "servers_total", "servers_active", "tools_total",
     "active_loops", "loop_status",
-    "current_command",
-    "docs_count", "tasks_done", "tasks_total", "task_pct",
+    "docs_count", "tasks_done", "task_pct",
     "extension_statuses",
+    "clock", "duration",
   ],
   secondarySegments: [
-    "hostname", "time",
+    "hostname",
+    "tokens_in", "tokens_out",
     "compression_ratio", "indexed_docs",
     "platforms_enabled", "last_sent",
+    "thinking_level",
   ],
-  separator: "powerline",
   colors: getDefaultColors(),
 };
 
 /** ASCII preset — safe for any terminal */
 const ASCII_PRESET: PresetDef = {
   leftSegments: [
-    "model", "path", "git", "context_pct", "cost",
+    "model", "git",
   ],
   rightSegments: [
-    "compactions", "tokens_saved", "project_count",
+    "tps", "context_pct", "cost",
+    "clock", "duration",
   ],
   secondarySegments: [],
-  separator: "ascii",
   colors: getDefaultColors(),
 };
 

package/src/registry/index.ts

@@ -115,19 +115,17 @@ export class FooterRegistry {
     for (const callback of this.subscribers) {
       try {
         callback();
-      } catch (err) {
-        console.error("[footer] Subscriber error:", err);
+      } catch {
+        // Silently ignore — subscriber errors are non-blocking.
       }
     }
   }
 
   // ─── Debug ────────────────────────────────────────────────────────────────
 
-  private log(event: string, ...args: unknown[]): void {
-    if (!this.debug) return;
-    const ts = new Date().toISOString().slice(11, 23);
-    const details = args.length > 0 ? " " + JSON.stringify(args) : "";
-    console.error(`[footer-registry:${ts}] ${event}${details}`);
+  private log(_event: string, ..._args: unknown[]): void {
+    // Debug logging disabled — was writing to stdout causing TUI rendering issues.
+    return;
   }
 }