@pi-unipi/info-screen 0.1.1 → 0.1.3

package/core-groups.ts

@@ -173,6 +173,59 @@ function discoverExtensions(): Array<{ name: string; source: string; version: st
   return extensions;
 }
 
+/**
+ * Load time tracking.
+ */
+const loadTimes: Array<{ name: string; type: string; ms: number }> = [];
+let totalLoadTimeMs = 0;
+let loadTrackingStarted = false;
+let loadTrackingStartMs = 0;
+
+/** Start load time tracking */
+export function startLoadTracking(): void {
+  if (!loadTrackingStarted) {
+    loadTrackingStartMs = Date.now();
+    loadTrackingStarted = true;
+  }
+}
+
+/** Record a load time */
+export function recordLoadTime(name: string, type: string, ms: number): void {
+  loadTimes.push({ name, type, ms });
+  totalLoadTimeMs += ms;
+}
+
+/** Finish load tracking */
+export function finishLoadTracking(): void {
+  if (loadTrackingStarted) {
+    totalLoadTimeMs = Date.now() - loadTrackingStartMs;
+  }
+}
+
+/** Get load times */
+export function getLoadTimes(): Array<{ name: string; type: string; ms: number }> {
+  return [...loadTimes];
+}
+
+/** Get total load time */
+export function getTotalLoadTime(): number {
+  return totalLoadTimeMs;
+}
+
+/**
+ * Additional skill directories registered by extensions.
+ */
+const extraSkillDirs: string[] = [];
+
+/**
+ * Register an additional skill directory (from extensions).
+ */
+export function registerSkillDir(dir: string): void {
+  if (!extraSkillDirs.includes(dir)) {
+    extraSkillDirs.push(dir);
+  }
+}
+
 /**
  * Discover loaded skills by scanning filesystem.
  */
@@ -185,6 +238,8 @@ function discoverSkills(): Array<{ name: string; source: string }> {
   const skillDirs = [
     join(homeDir, ".pi", "agent", "skills"),
     join(cwd, ".pi", "skills"),
+    // Add extra dirs from extensions
+    ...extraSkillDirs,
   ];
 
   const counted = new Set<string>();
@@ -204,10 +259,14 @@ function discoverSkills(): Array<{ name: string; source: string }> {
         const skillPath = join(dir, name, "SKILL.md");
         if (existsSync(skillPath)) {
           counted.add(name);
-          skills.push({
-            name,
-            source: dir.includes(homeDir) ? "global" : "project",
-          });
+          // Determine source based on path
+          let source = "extension";
+          if (dir.includes(join(homeDir, ".pi"))) {
+            source = "global";
+          } else if (dir === join(cwd, ".pi", "skills")) {
+            source = "project";
+          }
+          skills.push({ name, source });
         }
       }
     } catch {
@@ -228,6 +287,18 @@ const announcedModules: Array<{ name: string; version: string }> = [];
  */
 const registeredTools: Array<{ name: string; source: string }> = [];
 
+/**
+ * Reference to pi API for getting tools.
+ */
+let piApi: any = null;
+
+/**
+ * Set the pi API reference.
+ */
+export function setPiApi(api: any): void {
+  piApi = api;
+}
+
 /**
  * Add a module to the announced list.
  */
@@ -299,6 +370,43 @@ export function registerCoreGroups(): void {
     },
   });
 
+  // 1b. Load time group
+  infoRegistry.registerGroup({
+    id: "loadtime",
+    name: "Load Time",
+    icon: "⏱️",
+    priority: 15,
+    config: {
+      showByDefault: true,
+      stats: [
+        { id: "total", label: "Total Load Time", show: true },
+        { id: "count", label: "Items Loaded", show: true },
+        { id: "list", label: "Load Times", show: true },
+      ],
+    },
+    dataProvider: async () => {
+      const times = getLoadTimes();
+      const total = getTotalLoadTime();
+      
+      // Sort by load time descending
+      const sorted = [...times].sort((a, b) => b.ms - a.ms);
+      
+      // Build list as comma-separated values
+      const listStr = sorted.length > 0 
+        ? sorted.map(t => `${t.name} (${t.ms}ms)`).join(", ") 
+        : "none";
+
+      return {
+        total: { value: `${total}ms` },
+        count: { value: String(times.length) },
+        list: {
+          value: sorted.length > 0 ? `${sorted[0].name} (${sorted[0].ms}ms)` : "none",
+          detail: sorted.length > 1 ? sorted.slice(1).map(t => `${t.name} (${t.ms}ms)`).join(", ") : undefined,
+        },
+      };
+    },
+  });
+
   // 2. Usage group
   infoRegistry.registerGroup({
     id: "usage",
@@ -374,20 +482,44 @@ export function registerCoreGroups(): void {
       ],
     },
     dataProvider: async () => {
-      const tools = getRegisteredTools();
-      const builtin = tools.filter((t) => t.source === "builtin");
-      const custom = tools.filter((t) => t.source === "registered");
+      // Use pi.getAllTools() to get actual tools with source info
+      let tools: Array<{ name: string; source?: string; sourceInfo?: any }> = [];
+      
+      if (piApi && typeof piApi.getAllTools === "function") {
+        try {
+          tools = piApi.getAllTools();
+        } catch {
+          // Fallback to tracked tools
+          tools = getRegisteredTools();
+        }
+      } else {
+        tools = getRegisteredTools();
+      }
 
-      // Build tool list - show all
+      // Categorize by source
+      const builtin = tools.filter((t) => {
+        const source = t.sourceInfo?.source || t.source;
+        return source === "builtin";
+      });
+      const extension = tools.filter((t) => {
+        const source = t.sourceInfo?.source || t.source;
+        return source !== "builtin" && source !== "sdk";
+      });
+      const sdk = tools.filter((t) => {
+        const source = t.sourceInfo?.source || t.source;
+        return source === "sdk";
+      });
+
+      // Build tool list as comma-separated values
       const toolNames = tools.map((t) => `${t.name}`);
+      const toolListStr = toolNames.join(", ");
 
       return {
         total: { value: String(tools.length) },
         builtin: { value: String(builtin.length) },
-        registered: { value: String(custom.length) },
+        registered: { value: String(extension.length + sdk.length) },
         list: {
-          value: toolNames.length > 0 ? toolNames[0] : "none",
-          detail: toolNames.length > 1 ? toolNames.slice(1).join("\n") : undefined,
+          value: toolListStr.length > 0 ? toolListStr : "none",
         },
       };
     },
@@ -453,16 +585,16 @@ export function registerCoreGroups(): void {
       const global = skills.filter((s) => s.source === "global");
       const project = skills.filter((s) => s.source === "project");
 
-      // Build skill list - show all
+      // Build skill list as comma-separated values
       const skillNames = skills.map((s) => `${s.name} (${s.source})`);
+      const skillListStr = skillNames.join(", ");
 
       return {
         count: { value: String(skills.length) },
         global: { value: String(global.length) },
         project: { value: String(project.length) },
         list: {
-          value: skillNames.length > 0 ? skillNames[0] : "none",
-          detail: skillNames.length > 1 ? skillNames.slice(1).join("\n") : undefined,
+          value: skillListStr.length > 0 ? skillListStr : "none",
         },
       };
     },

package/index.ts

@@ -12,10 +12,10 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { UNIPI_EVENTS, MODULES, UNIPI_PREFIX, emitEvent, getPackageVersion } from "@pi-unipi/core";
 import { infoRegistry } from "./registry.js";
-import { registerCoreGroups, trackModule, trackTool } from "./core-groups.js";
+import { registerCoreGroups, trackModule, trackTool, setPiApi, registerSkillDir, startLoadTracking, recordLoadTime, finishLoadTracking } from "./core-groups.js";
 
-/** Re-export infoRegistry for external use */
-export { infoRegistry };
+/** Re-export infoRegistry, registerSkillDir, and load tracking for external use */
+export { infoRegistry, registerSkillDir, startLoadTracking, recordLoadTime, finishLoadTracking };
 import { getInfoSettings } from "./config.js";
 import { InfoOverlay } from "./tui/info-overlay.js";
 import { SettingsOverlay } from "./settings/settings-tui.js";
@@ -31,33 +31,38 @@ const moduleReadyPromise = new Promise<void>((resolve) => {
 });
 
 /** Timeout for waiting for modules */
-const MODULE_WAIT_TIMEOUT_MS = 2000;
+const MODULE_WAIT_TIMEOUT_MS = 5000;
 
 /**
- * Wait for all modules to announce, then return.
+ * Wait for modules to announce, then return.
  */
 async function waitForModules(): Promise<void> {
   const settings = getInfoSettings();
-  const timeoutMs = settings.bootTimeoutMs;
+  const timeoutMs = settings.bootTimeoutMs || MODULE_WAIT_TIMEOUT_MS;
 
-  // Wait for module ready or timeout
-  await Promise.race([
-    moduleReadyPromise,
-    new Promise<void>((resolve) => setTimeout(resolve, timeoutMs)),
-  ]);
+  // Wait a bit for modules to announce
+  // We wait for the full timeout to give all modules time to emit MODULE_READY
+  await new Promise<void>((resolve) => setTimeout(resolve, timeoutMs));
 }
 
 export default function (pi: ExtensionAPI) {
+  // Set pi API reference for tools access
+  setPiApi(pi);
+
   // Register core groups on load
   registerCoreGroups();
 
 
 
+  // Start load tracking
+  startLoadTracking();
+
   // Listen for module announcements
   pi.events.on(UNIPI_EVENTS.MODULE_READY, (event: any) => {
     if (event.name && event.name !== MODULES.INFO_SCREEN) {
       // Track the module
       trackModule(event.name, event.version || "unknown");
+      recordLoadTime(event.name, "module", event.loadTimeMs || 0);
 
       // Track tools from this module
       if (event.tools && Array.isArray(event.tools)) {
@@ -99,18 +104,20 @@ export default function (pi: ExtensionAPI) {
       // Wait for other modules to announce
       await waitForModules();
 
-      // Show the overlay
+      // Show the overlay using three-method object pattern
       ctx.ui.custom(
         (tui, _theme, _keybindings, done) => {
           const overlay = new InfoOverlay();
           overlay.onClose = () => done(undefined);
-          // Wrap handleInput to trigger re-render after state changes
-          const originalHandleInput = overlay.handleInput?.bind(overlay);
-          overlay.handleInput = (data: string) => {
-            originalHandleInput?.(data);
-            tui.requestRender();
+          // Return three-method object as per pi-tui docs
+          return {
+            render: (w: number) => overlay.render(w),
+            invalidate: () => overlay.invalidate(),
+            handleInput: (data: string) => {
+              overlay.handleInput?.(data);
+              tui.requestRender();
+            },
           };
-          return overlay;
         },
         {
           overlay: true,
@@ -124,6 +131,9 @@ export default function (pi: ExtensionAPI) {
       );
     }
 
+    // Finish load tracking
+    finishLoadTracking();
+
     // Announce module
     emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
       name: MODULES.INFO_SCREEN,
@@ -141,12 +151,14 @@ export default function (pi: ExtensionAPI) {
         (tui, _theme, _keybindings, done) => {
           const overlay = new InfoOverlay();
           overlay.onClose = () => done(undefined);
-          const originalHandleInput = overlay.handleInput?.bind(overlay);
-          overlay.handleInput = (data: string) => {
-            originalHandleInput?.(data);
-            tui.requestRender();
+          return {
+            render: (w: number) => overlay.render(w),
+            invalidate: () => overlay.invalidate(),
+            handleInput: (data: string) => {
+              overlay.handleInput?.(data);
+              tui.requestRender();
+            },
           };
-          return overlay;
         },
         {
           overlay: true,
@@ -169,12 +181,14 @@ export default function (pi: ExtensionAPI) {
         (tui, _theme, _keybindings, done) => {
           const overlay = new SettingsOverlay();
           overlay.onClose = () => done(undefined);
-          const originalHandleInput = overlay.handleInput?.bind(overlay);
-          overlay.handleInput = (data: string) => {
-            originalHandleInput?.(data);
-            tui.requestRender();
+          return {
+            render: (w: number) => overlay.render(w),
+            invalidate: () => overlay.invalidate(),
+            handleInput: (data: string) => {
+              overlay.handleInput?.(data);
+              tui.requestRender();
+            },
           };
-          return overlay;
         },
         {
           overlay: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
   "type": "module",
   "license": "MIT",

package/settings/settings-tui.ts

@@ -47,6 +47,15 @@ export class SettingsOverlay implements Component {
       name: g.name,
       icon: g.icon,
     }));
+    // Apply saved order if exists
+    if (this.settings.groupOrder) {
+      const order = this.settings.groupOrder;
+      this.groups.sort((a, b) => {
+        const ai = order.indexOf(a.id);
+        const bi = order.indexOf(b.id);
+        return (ai === -1 ? 999 : ai) - (bi === -1 ? 999 : bi);
+      });
+    }
   }
 
   /**
@@ -88,6 +97,12 @@ export class SettingsOverlay implements Component {
       case "l":
         this.enterStatsMode(this.groups[this.selectedIndex].id);
         break;
+      case "J": // Shift+J - move group down
+        this.moveGroupDown();
+        break;
+      case "K": // Shift+K - move group up
+        this.moveGroupUp();
+        break;
       case "q": // Quit
       case "\x1b": // Escape
         this.onClose?.();
@@ -166,6 +181,42 @@ export class SettingsOverlay implements Component {
     this.selectedIndex = 0;
   }
 
+  /**
+   * Move selected group up in order.
+   */
+  private moveGroupUp(): void {
+    if (this.selectedIndex <= 0) return;
+    const i = this.selectedIndex;
+    // Swap with previous
+    const temp = this.groups[i]!;
+    this.groups[i] = this.groups[i - 1]!;
+    this.groups[i - 1] = temp;
+    this.selectedIndex--;
+    this.saveGroupOrder();
+  }
+
+  /**
+   * Move selected group down in order.
+   */
+  private moveGroupDown(): void {
+    if (this.selectedIndex >= this.groups.length - 1) return;
+    const i = this.selectedIndex;
+    // Swap with next
+    const temp = this.groups[i]!;
+    this.groups[i] = this.groups[i + 1]!;
+    this.groups[i + 1] = temp;
+    this.selectedIndex++;
+    this.saveGroupOrder();
+  }
+
+  /**
+   * Save group order to settings.
+   */
+  private saveGroupOrder(): void {
+    this.settings.groupOrder = this.groups.map((g) => g.id);
+    saveInfoSettings(this.settings);
+  }
+
   /**
    * Render the component.
    */
@@ -218,7 +269,7 @@ export class SettingsOverlay implements Component {
     // Footer
     lines.push("");
     lines.push(ansi.dim + "─".repeat(width) + ansi.reset);
-    lines.push(this.renderCentered(`${ansi.dim}↑↓ select  Space toggle  → stats  q close${ansi.reset}`, width));
+    lines.push(this.renderCentered(`${ansi.dim}↑↓ select  Space toggle  → stats  J/K reorder  q close${ansi.reset}`, width));
     lines.push("");
 
     return lines;

package/tui/info-overlay.ts

@@ -8,7 +8,8 @@
 import type { Component } from "@mariozechner/pi-tui";
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { infoRegistry } from "../registry.js";
-import type { InfoGroup, GroupData, StatData } from "../types.js";
+import { getInfoSettings } from "../config.js";
+import type { InfoGroup, GroupData } from "../types.js";
 
 /** ANSI escape codes */
 const ansi = {
@@ -25,6 +26,7 @@ const ansi = {
   white: "\x1b[37m",
   red: "\x1b[31m",
   gray: "\x1b[90m",
+
 };
 
 /** Tab color palette */
@@ -46,6 +48,8 @@ export class InfoOverlay implements Component {
   private loading = true;
   private error: string | null = null;
   private scrollOffset = 0;
+  /** Tab scroll offset for windowed scrolling */
+  private tabScrollOffset = 0;
   /** Callback when overlay should close */
   onClose?: () => void;
 
@@ -67,6 +71,17 @@ export class InfoOverlay implements Component {
     this.loading = true;
     // Always re-fetch ALL groups to catch late registrations
     this.groups = infoRegistry.getAllGroups();
+    
+    // Apply saved order from settings
+    const settings = getInfoSettings();
+    if (settings.groupOrder && settings.groupOrder.length > 0) {
+      const order = settings.groupOrder;
+      this.groups.sort((a, b) => {
+        const ai = order.indexOf(a.id);
+        const bi = order.indexOf(b.id);
+        return (ai === -1 ? 999 : ai) - (bi === -1 ? 999 : bi);
+      });
+    }
 
     try {
       // Load data for all groups in parallel
@@ -94,10 +109,12 @@ export class InfoOverlay implements Component {
       // Right arrow - switch tab
       this.activeTabIndex = (this.activeTabIndex + 1) % this.groups.length;
       this.scrollOffset = 0; // Reset scroll on tab switch
+      this.ensureTabVisible();
     } else if (data === "\x1b[D" || data === "h") {
       // Left arrow - switch tab
       this.activeTabIndex = (this.activeTabIndex - 1 + this.groups.length) % this.groups.length;
       this.scrollOffset = 0; // Reset scroll on tab switch
+      this.ensureTabVisible();
     } else if (data === "\x1b[B" || data === "j") {
       // Down arrow - scroll down
       this.scrollOffset++;
@@ -116,6 +133,14 @@ export class InfoOverlay implements Component {
     }
   }
 
+  /**
+   * Ensure active tab is visible in the tab bar (horizontal scroll).
+   */
+  private ensureTabVisible(): void {
+    // Tab bar shows ~maxTabsVisible tabs, centered around active
+    // This is handled in renderTabBar
+  }
+
   /**
    * Render the component.
    */
@@ -135,6 +160,16 @@ export class InfoOverlay implements Component {
     
     if (groupIds !== currentIds) {
       this.groups = allGroups;
+      // Apply saved order
+      const settings = getInfoSettings();
+      if (settings.groupOrder && settings.groupOrder.length > 0) {
+        const order = settings.groupOrder;
+        this.groups.sort((a, b) => {
+          const ai = order.indexOf(a.id);
+          const bi = order.indexOf(b.id);
+          return (ai === -1 ? 999 : ai) - (bi === -1 ? 999 : bi);
+        });
+      }
       // Load data for any new groups (non-blocking)
       this.loadDataForNewGroups(allGroups);
     }
@@ -169,11 +204,9 @@ export class InfoOverlay implements Component {
     const lines: string[] = [];
     const padding = " ".repeat(Math.max(0, Math.floor((width - 20) / 2)));
 
-    lines.push("");
     lines.push(`${padding}${ansi.cyan}${ansi.bold}📊 UniPi Info Screen${ansi.reset}`);
     lines.push("");
     lines.push(`${padding}${ansi.dim}Loading dashboard...${ansi.reset}`);
-    lines.push("");
 
     return lines;
   }
@@ -185,10 +218,8 @@ export class InfoOverlay implements Component {
     const lines: string[] = [];
     const padding = " ".repeat(Math.max(0, Math.floor((width - 20) / 2)));
 
-    lines.push("");
     lines.push(`${padding}${ansi.yellow}${ansi.bold}⚠️ Error${ansi.reset}`);
     lines.push(`${padding}${ansi.dim}${this.error ?? "Unknown error"}${ansi.reset}`);
-    lines.push("");
 
     return lines;
   }
@@ -200,22 +231,23 @@ export class InfoOverlay implements Component {
     const lines: string[] = [];
     const padding = " ".repeat(Math.max(0, Math.floor((width - 30) / 2)));
 
-    lines.push("");
     lines.push(`${padding}${ansi.cyan}${ansi.bold}📊 UniPi Info Screen${ansi.reset}`);
     lines.push("");
     lines.push(`${padding}${ansi.dim}No groups registered.${ansi.reset}`);
     lines.push(`${padding}${ansi.dim}Modules will register groups on startup.${ansi.reset}`);
-    lines.push("");
 
     return lines;
   }
 
   /**
-   * Pad a line to fill a target visual width.
+   * Pad a line to fill a target visual width with background.
    */
-  private padToWidth(line: string, targetWidth: number): string {
+  private padToWidth(line: string, targetWidth: number, bg?: string): string {
     const visLen = visibleWidth(line);
     const pad = Math.max(0, targetWidth - visLen);
+    if (bg) {
+      return bg + line + " ".repeat(pad) + ansi.reset;
+    }
     return line + " ".repeat(pad);
   }
 
@@ -227,46 +259,42 @@ export class InfoOverlay implements Component {
     const group = this.groups[this.activeTabIndex];
     const data = this.groupData.get(group.id) ?? {};
     // Inner width for content (subtract 2 for left+right borders)
-    // Subtract extra 1 to prevent right border clipping on some terminals
-    const innerWidth = width - 3;
+    const innerWidth = width - 2;
+
+    // Fixed content height for stability
+    const CONTENT_HEIGHT = 12;
 
     // Top border
-    lines.push(`${ansi.dim}╭${"─".repeat(innerWidth + 1)}╮${ansi.reset}`);
+    lines.push(`${ansi.dim}╭${"─".repeat(innerWidth)}╮${ansi.reset}`);
 
     // Header
-    lines.push(`${ansi.dim}│${ansi.reset}${this.padToWidth(this.renderHeader(innerWidth, group), innerWidth)}${ansi.dim} │${ansi.reset}`);
-    lines.push(`${ansi.dim}├${"─".repeat(innerWidth + 1)}┤${ansi.reset}`);
+    lines.push(`${ansi.dim}│${ansi.reset}${this.padToWidth(this.renderHeader(innerWidth, group), innerWidth)}${ansi.dim}│${ansi.reset}`);
+    lines.push(`${ansi.dim}├${"─".repeat(innerWidth)}┤${ansi.reset}`);
 
-    // Tab bar
-    lines.push(`${ansi.dim}│${ansi.reset}${this.padToWidth(this.renderTabBar(innerWidth), innerWidth)}${ansi.dim} │${ansi.reset}`);
-    lines.push(`${ansi.dim}├${"─".repeat(innerWidth + 1)}┤${ansi.reset}`);
+    // Tab bar with horizontal scrolling
+    lines.push(`${ansi.dim}│${ansi.reset}${this.padToWidth(this.renderTabBar(innerWidth), innerWidth)}${ansi.dim}│${ansi.reset}`);
+    lines.push(`${ansi.dim}├${"─".repeat(innerWidth)}┤${ansi.reset}`);
 
-    // Content with scrolling
+    // Content with scrolling (fixed height)
     const contentLines = this.renderGroupContent(innerWidth, group, data);
-    const maxVisibleLines = 15; // Max content lines visible
     
     // Clamp scroll offset
-    const maxScroll = Math.max(0, contentLines.length - maxVisibleLines);
+    const maxScroll = Math.max(0, contentLines.length - CONTENT_HEIGHT);
     this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
     
     // Get visible slice
-    const visibleContent = contentLines.slice(this.scrollOffset, this.scrollOffset + maxVisibleLines);
-    
-    for (const line of visibleContent) {
-      lines.push(`${ansi.dim}│${ansi.reset}${this.padToWidth(line, innerWidth)}${ansi.dim} │${ansi.reset}`);
-    }
+    const visibleContent = contentLines.slice(this.scrollOffset, this.scrollOffset + CONTENT_HEIGHT);
     
-    // Show scroll indicator if needed
-    if (contentLines.length > maxVisibleLines) {
-      const scrollInfo = ` ${this.scrollOffset + 1}-${Math.min(this.scrollOffset + maxVisibleLines, contentLines.length)}/${contentLines.length} `;
-      lines.push(`${ansi.dim}│${ansi.reset}${this.padToWidth(scrollInfo, innerWidth)}${ansi.dim} │${ansi.reset}`);
+    // Render content lines (pad to fixed height)
+    for (let i = 0; i < CONTENT_HEIGHT; i++) {
+      const line = visibleContent[i] ?? "";
+      lines.push(`${ansi.dim}│${ansi.reset}${this.padToWidth(line, innerWidth)}${ansi.dim}│${ansi.reset}`);
     }
 
-    // Footer
-    const hasScroll = contentLines.length > maxVisibleLines;
-    lines.push(`${ansi.dim}├${"─".repeat(innerWidth + 1)}┤${ansi.reset}`);
-    lines.push(`${ansi.dim}│${ansi.reset}${this.padToWidth(this.renderFooter(innerWidth, hasScroll), innerWidth)}${ansi.dim} │${ansi.reset}`);
-    lines.push(`${ansi.dim}╰${"─".repeat(innerWidth + 1)}╯${ansi.reset}`);
+    // Footer with scroll indicator inline
+    lines.push(`${ansi.dim}├${"─".repeat(innerWidth)}┤${ansi.reset}`);
+    lines.push(`${ansi.dim}│${ansi.reset}${this.renderFooterWithScroll(innerWidth, contentLines.length, CONTENT_HEIGHT)}${ansi.dim}│${ansi.reset}`);
+    lines.push(`${ansi.dim}╰${"─".repeat(innerWidth)}╯${ansi.reset}`);
 
     return lines;
   }
@@ -290,15 +318,93 @@ export class InfoOverlay implements Component {
   }
 
   /**
-   * Render tab bar.
+   * Render tab bar with windowed scrolling.
+   * Window slides only when active tab reaches the edge.
+   * Example: abcde → user on 'e' presses right → efghi
    */
   private renderTabBar(width: number): string {
+    if (this.groups.length === 0) return "";
+
+    // Calculate tab widths
+    const tabWidths = this.groups.map(g => visibleWidth(` ${g.icon} ${g.name} `));
+    const separatorWidth = visibleWidth(`${ansi.dim}│${ansi.reset}`);
+    
+    // Find how many tabs fit (account for potential scroll indicators)
+    const indicatorSpace = 3; // Space for ◀ or ▶
+    let maxTabs = 0;
+    let totalWidth = 0;
+    for (let i = 0; i < this.groups.length; i++) {
+      const tabW = tabWidths[i]!;
+      const sepW = i > 0 ? separatorWidth : 0;
+      // Reserve space for scroll indicator on one side
+      if (totalWidth + sepW + tabW > width - 2 - indicatorSpace) break;
+      totalWidth += sepW + tabW;
+      maxTabs = i + 1;
+    }
+
+    // If all tabs fit, show all
+    if (maxTabs >= this.groups.length) {
+      return this.renderAllTabs(width);
+    }
+
+    // Windowed scrolling: slide only when active tab reaches edge
+    // Initialize tabScrollOffset if needed
+    if (this.tabScrollOffset === undefined) {
+      this.tabScrollOffset = 0;
+    }
+
+    // Ensure active tab is visible within the window
+    if (this.activeTabIndex < this.tabScrollOffset) {
+      // Active tab is before window - slide left
+      this.tabScrollOffset = this.activeTabIndex;
+    } else if (this.activeTabIndex >= this.tabScrollOffset + maxTabs) {
+      // Active tab is after window - slide right
+      this.tabScrollOffset = this.activeTabIndex - maxTabs + 1;
+    }
+
+    // Clamp scroll offset
+    this.tabScrollOffset = Math.max(0, Math.min(this.tabScrollOffset, this.groups.length - maxTabs));
+    
+    // Build visible tabs
+    const tabs: string[] = [];
+    for (let i = this.tabScrollOffset; i < this.tabScrollOffset + maxTabs && i < this.groups.length; i++) {
+      const group = this.groups[i]!;
+      const isActive = i === this.activeTabIndex;
+      const color = TAB_COLORS[i % TAB_COLORS.length]!;
+
+      if (isActive) {
+        tabs.push(`${color}${ansi.bold} ${group.icon} ${group.name} ${ansi.reset}`);
+      } else {
+        tabs.push(`${ansi.dim} ${group.icon} ${group.name} ${ansi.reset}`);
+      }
+    }
+
+    const tabStr = tabs.join(`${ansi.dim}│${ansi.reset}`);
+    
+    // Add scroll indicators
+    const hasLeft = this.tabScrollOffset > 0;
+    const hasRight = this.tabScrollOffset + maxTabs < this.groups.length;
+    
+    if (hasLeft) {
+      return `${ansi.dim}◀${ansi.reset} ${tabStr}`;
+    }
+    if (hasRight) {
+      return `${tabStr} ${ansi.dim}▶${ansi.reset}`;
+    }
+    
+    return tabStr;
+  }
+
+  /**
+   * Render all tabs (when they all fit).
+   */
+  private renderAllTabs(width: number): string {
     const tabs: string[] = [];
 
     for (let i = 0; i < this.groups.length; i++) {
-      const group = this.groups[i];
+      const group = this.groups[i]!;
       const isActive = i === this.activeTabIndex;
-      const color = TAB_COLORS[i % TAB_COLORS.length];
+      const color = TAB_COLORS[i % TAB_COLORS.length]!;
 
       if (isActive) {
         tabs.push(`${color}${ansi.bold} ${group.icon} ${group.name} ${ansi.reset}`);
@@ -310,7 +416,7 @@ export class InfoOverlay implements Component {
     const tabStr = tabs.join(`${ansi.dim}│${ansi.reset}`);
     const visLen = visibleWidth(tabStr);
 
-    // Truncate if too wide
+    // Truncate if too wide (shouldn't happen if maxTabs calculation is correct)
     if (visLen > width - 2) {
       return truncateToWidth(tabStr, width - 2);
     }
@@ -318,13 +424,6 @@ export class InfoOverlay implements Component {
     return tabStr;
   }
 
-  /**
-   * Render a separator line.
-   */
-  private renderSeparator(width: number): string {
-    return ansi.dim + "─".repeat(width) + ansi.reset;
-  }
-
   /**
    * Render group content.
    */
@@ -381,26 +480,37 @@ export class InfoOverlay implements Component {
   }
 
   /**
-   * Render footer with navigation hints.
+   * Render footer with navigation hints and scroll indicator.
    */
-  private renderFooter(width: number, hasScroll?: boolean): string {
+  private renderFooterWithScroll(width: number, totalLines: number, visibleHeight: number): string {
+    // Left side: scroll indicator
+    const hasScroll = totalLines > visibleHeight;
+    let scrollStr = "";
+    if (hasScroll) {
+      scrollStr = `${ansi.dim}${this.scrollOffset + 1}-${Math.min(this.scrollOffset + visibleHeight, totalLines)}/${totalLines}${ansi.reset}`;
+    }
+
+    // Right side: navigation hints
     const hints = [
       `${ansi.cyan}←/→${ansi.reset} tabs`,
+      `${ansi.green}↑/↓${ansi.reset} scroll`,
+      `${ansi.red}q/Esc${ansi.reset} close`,
     ];
-    
-    hints.push(`${ansi.green}↑/↓${ansi.reset} scroll`);
-    hints.push(`${ansi.yellow}g/G${ansi.reset} top/bottom`);
-    hints.push(`${ansi.red}q/Esc${ansi.reset} close`);
 
     const hintStr = hints.join(`  ${ansi.dim}•${ansi.reset}  `);
-    const visLen = visibleWidth(hintStr);
+    const hintWidth = visibleWidth(hintStr);
+    const scrollWidth = visibleWidth(scrollStr);
 
-    if (visLen >= width - 4) {
-      return truncateToWidth(hintStr, width - 4);
+    // Calculate spacing
+    const gap = 4;
+    const totalWidth = scrollWidth + gap + hintWidth;
+    
+    if (totalWidth >= width - 2) {
+      // Too wide, just show hints
+      return truncateToWidth(hintStr, width - 2);
     }
 
-    const leftPad = Math.floor((width - visLen) / 2);
-
-    return " ".repeat(leftPad) + hintStr;
+    const padding = " ".repeat(width - 2 - totalWidth);
+    return scrollStr + padding + hintStr;
   }
 }

package/types.ts

@@ -55,6 +55,8 @@ export interface InfoScreenSettings {
   bootTimeoutMs: number;
   /** Per-group settings */
   groups: Record<string, GroupSettings>;
+  /** Group display order (array of group ids) */
+  groupOrder?: string[];
 }
 
 /** Settings for a single group */
@@ -68,6 +70,7 @@ export interface GroupSettings {
 /** Default settings */
 export const DEFAULT_SETTINGS: InfoScreenSettings = {
   showOnBoot: true,
-  bootTimeoutMs: 2000,
+  bootTimeoutMs: 5000,
   groups: {},
+  groupOrder: [],
 };