@agentdeck/bridge 0.2.2 → 0.2.3

package/dist/tui/renderer.js

@@ -92,6 +92,11 @@ function typeIcon(type) {
             case 'scheduled': return 's';
             case 'user_action': return 'u';
             case 'eval_result': return '#';
+            // Task hierarchy -- mirrors timelineIconKey() (shared/src/timeline-icons.ts):
+            // task_start/task_end -> task, task_milestone -> success.
+            case 'task_start':
+            case 'task_end': return '=';
+            case 'task_milestone': return '+';
             default: return '*';
         }
     }
@@ -108,6 +113,10 @@ function typeIcon(type) {
         case 'model_response': return '\u25C8';
         case 'memory_recall': return '\u25CC';
         case 'scheduled': return '\u25D1';
+        // Task hierarchy -- mirrors timelineIconKey() (shared/src/timeline-icons.ts).
+        case 'task_start':
+        case 'task_end': return '\u25A3'; // white square w/ centre
+        case 'task_milestone': return '\u2713'; // check mark
         case 'eval_result': return '\u2605'; // ★
         default: return '\u25C6';
     }
@@ -140,20 +149,24 @@ function creatureEmoji(agentType) {
             return 'D';
         if (agentType === 'openclaw')
             return 'C';
-        if (agentType === 'codex-cli')
+        if (agentType === 'codex-cli' || agentType === 'codex-app')
             return 'X';
         if (agentType === 'opencode')
             return 'O';
+        if (agentType === 'antigravity')
+            return 'A';
         return '*';
     }
     if (agentType === 'daemon')
         return '\u2699\uFE0F'; // ⚙️
     if (agentType === 'openclaw')
         return '\uD83E\uDD9E'; // 🦞
-    if (agentType === 'codex-cli')
+    if (agentType === 'codex-cli' || agentType === 'codex-app')
         return '\u2601'; // ☁ (cloud — matches creature)
     if (agentType === 'opencode')
         return '\u25A3'; // ▣ (nested square — matches creature)
+    if (agentType === 'antigravity')
+        return '\u25B2'; // ▲ (Antigravity peak)
     return '\u273B'; // ✻ (teardrop-spoked asterisk — Claude sparkle)
 }
 function creatureBrandColor(agentType) {
@@ -162,8 +175,10 @@ function creatureBrandColor(agentType) {
     switch (agentType) {
         case 'claude-code': return fg(192, 112, 88); // terracotta
         case 'openclaw': return fg(255, 77, 77); // red
-        case 'codex-cli': return fg(177, 167, 255); // indigo
+        case 'codex-cli':
+        case 'codex-app': return fg(177, 167, 255); // indigo
         case 'opencode': return fg(241, 236, 236); // warm gray (#F1ECEC)
+        case 'antigravity': return fg(210, 214, 220); // Google gray
         default: return '';
     }
 }
@@ -197,8 +212,129 @@ function sessionHotkeyLabel(index) {
         return '·';
     return String(index + 1);
 }
-function sessionHotkeyIndex(session, nextIndex) {
-    if (!session.port || session.controlMode === 'observed')
+/**
+ * Build the unified left-HUD entry list shared with macOS / iOS / Android.
+ *
+ * Collapses primary + siblings + virtual OpenClaw into one array, sorts via
+ * the shared sortSessions (agentType → projectName → startedAt → id), and
+ * applies #N suffix via assignDisplayNames so the display order and #N
+ * numbering match every other surface.
+ *
+ * Primary handling mirrors apple/AgentDeck/UI/Monitor/SessionListPanel.swift:
+ *   - if a sibling matches our connected port, that sibling becomes the
+ *     primary anchor (its startedAt anchors the sort position)
+ *   - otherwise primary is appended only when no sibling shares its
+ *     agentType (duplicatePrimaryWithoutId guard)
+ *   - daemon / openclaw primaries are never appended (they're virtual)
+ */
+export function buildHudEntries(state) {
+    const items = [];
+    const portToItem = new Map();
+    for (const s of state.sessions) {
+        const ri = s;
+        const item = {
+            id: s.id,
+            projectName: s.projectName ?? 'unknown',
+            agentType: s.agentType ?? undefined,
+            state: s.state ?? 'idle',
+            modelName: s.modelName ?? undefined,
+            startedAt: s.startedAt ?? undefined,
+            port: s.port ?? undefined,
+            controlMode: ri.controlMode,
+            currentTask: ri.currentTask,
+            contextPercent: ri.contextPercent,
+            totalTokens: ri.totalTokens,
+            isPrimary: false,
+            isVirtualOpenClaw: false,
+        };
+        items.push(item);
+        if (item.port !== undefined)
+            portToItem.set(item.port, item);
+    }
+    if (state.agentType && state.agentType !== 'daemon' && state.agentType !== 'openclaw' && state.state) {
+        const anchor = state.currentPort != null ? portToItem.get(state.currentPort) : undefined;
+        if (anchor) {
+            // Patch anchor with primary's live fields. macOS / Android compose
+            // SessionEntry from primary state and only borrow the anchor sibling's
+            // startedAt; if we left the sibling's snapshot in place the row would
+            // render stale modelName / state / currentTask whenever the sibling
+            // payload lagged the primary state_update. startedAt, port, id, and
+            // controlMode stay with the anchor so sort position and hotkey
+            // identity match every other surface.
+            anchor.isPrimary = true;
+            anchor.projectName = state.projectName ?? anchor.projectName;
+            anchor.agentType = state.agentType;
+            anchor.state = state.state;
+            anchor.modelName = state.modelName ?? undefined;
+            anchor.currentTask = state.currentTool ?? undefined;
+        }
+        else {
+            const duplicateAgentType = state.sessions.some(s => s.agentType === state.agentType);
+            if (!duplicateAgentType) {
+                items.push({
+                    id: '__self__',
+                    projectName: state.projectName ?? 'unknown',
+                    agentType: state.agentType,
+                    state: state.state,
+                    modelName: state.modelName ?? undefined,
+                    startedAt: undefined,
+                    port: state.currentPort ?? undefined,
+                    controlMode: undefined,
+                    currentTask: state.currentTool ?? undefined,
+                    contextPercent: undefined,
+                    totalTokens: undefined,
+                    isPrimary: true,
+                    isVirtualOpenClaw: false,
+                });
+            }
+        }
+    }
+    const hasOpenClaw = items.some(it => it.agentType === 'openclaw' || it.agentType === 'gateway');
+    if (state.gatewayAvailable && !hasOpenClaw) {
+        items.push({
+            id: '__virtual_openclaw__',
+            projectName: 'OpenClaw',
+            agentType: 'openclaw',
+            state: state.crayfishRouting ? 'processing' : 'idle',
+            modelName: undefined,
+            startedAt: undefined,
+            port: undefined,
+            controlMode: undefined,
+            currentTask: undefined,
+            contextPercent: undefined,
+            totalTokens: undefined,
+            isPrimary: false,
+            isVirtualOpenClaw: true,
+        });
+    }
+    const sorted = sortSessions(items);
+    const named = assignDisplayNames(sorted.map(it => ({
+        id: it.id,
+        projectName: it.projectName,
+        agentType: it.agentType,
+        state: it.state,
+    })));
+    return sorted.map((it, i) => ({
+        id: it.id,
+        displayName: named[i].displayName,
+        projectName: it.projectName,
+        agentType: it.agentType,
+        state: it.state,
+        modelName: it.modelName,
+        startedAt: it.startedAt,
+        port: it.port,
+        controlMode: it.controlMode,
+        currentTask: it.currentTask,
+        contextPercent: it.contextPercent,
+        totalTokens: it.totalTokens,
+        isPrimary: it.isPrimary,
+        isVirtualOpenClaw: it.isVirtualOpenClaw,
+    }));
+}
+function hudHotkeyIndex(entry, nextIndex) {
+    if (entry.isPrimary || entry.isVirtualOpenClaw)
+        return null;
+    if (!entry.port || entry.controlMode === 'observed')
         return null;
     return nextIndex;
 }
@@ -214,6 +350,85 @@ function observedDetailParts(session) {
         parts.push(session.currentTask);
     return parts;
 }
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function moduleStatusIcon(ok, warning = false) {
+    if (!terminalCaps.unicode)
+        return ok ? 'o' : warning ? '!' : 'x';
+    return ok ? '\u25CF' : warning ? '\u25C6' : '\u25CB';
+}
+function renderModuleHealthLines(moduleHealth, width) {
+    const lines = [];
+    if (!moduleHealth)
+        return lines;
+    const push = (label, detail, ok, warning = false) => {
+        const color = ok ? colors.idle : warning ? colors.awaiting : colors.dim;
+        lines.push(` ${color}${moduleStatusIcon(ok, warning)}${RESET} ${truncText(`${label} ${detail}`.trim(), width - 4)}`);
+    };
+    const serial = asRecord(moduleHealth.serial);
+    if (serial) {
+        const connections = asArray(serial.connections).map(asRecord).filter(Boolean);
+        const connected = connections.filter((c) => c.connected === true || c.transportOpen === true);
+        const boards = connected
+            .map((c) => asRecord(c.deviceInfo)?.board)
+            .filter((b) => typeof b === 'string' && b.length > 0);
+        const count = asNumber(serial.connectionCount) ?? connected.length;
+        const shown = boards.slice(0, 3).join(', ');
+        const more = boards.length > 3 ? ` +${boards.length - 3}` : '';
+        const detail = count > 0 ? `${count}${shown ? `: ${shown}${more}` : ''}` : 'none';
+        push('Serial', detail, count > 0, Boolean(serial.lastError));
+    }
+    const pixoo = asRecord(moduleHealth.pixoo);
+    if (pixoo) {
+        const devices = asArray(pixoo.devices).map(asRecord).filter(Boolean);
+        const configured = asNumber(pixoo.configuredDeviceCount) ?? devices.length;
+        const online = devices.filter((d) => d.online === true && d.backedOff !== true).length;
+        const dimmed = pixoo.displayDimmed === true ? ' dim' : '';
+        push('Pixoo', `${online}/${configured}${dimmed}`, configured > 0 && online > 0, configured > 0);
+    }
+    // BLE matrix panels — Divoom Timebox Mini + iDotMatrix. The Swift daemon
+    // reports a live `connected`/`statusReason`; the Node daemon only knows a
+    // panel is configured (the Python BLE sync subprocess owns the link), so a
+    // configured-but-state-unknown panel reads as amber "cfg" rather than a red
+    // offline, which would be a false negative for a working Node-driven panel.
+    for (const [key, label] of [['timebox', 'Timebox'], ['idotmatrix', 'iDotMatrix']]) {
+        const m = asRecord(moduleHealth[key]);
+        if (!m)
+            continue;
+        const configured = asNumber(m.configuredDeviceCount) ?? asArray(m.devices).length;
+        if (configured <= 0)
+            continue;
+        const connected = m.connected === true;
+        const dimmed = m.displayDimmed === true ? ' dim' : '';
+        const reason = typeof m.statusReason === 'string' ? m.statusReason : '';
+        const detail = connected ? `ready${dimmed}` : (reason || `${configured} cfg`);
+        push(label, detail, connected, !connected);
+    }
+    const d200h = asRecord(moduleHealth.d200h);
+    if (d200h) {
+        const connected = d200h.connected === true || d200h.managerOpened === true;
+        const owner = d200h.externalOwner === true ? ' plugin' : '';
+        const detail = connected ? `ready${owner}` : 'offline';
+        push('D200H', detail, connected, Boolean(d200h.lastOpenError || d200h.lastWriteError));
+    }
+    const adb = asRecord(moduleHealth.adb);
+    if (adb) {
+        const devices = asArray(adb.devices);
+        const reverse = asNumber(adb.reverseReadyCount) ?? devices.length;
+        const available = adb.available === true;
+        push('ADB', available ? `${reverse} reverse` : 'missing', available && reverse > 0, available);
+    }
+    return lines;
+}
 // ===== Panel Renderers =====
 function renderAgentLines(state, maxWidth, useLogo) {
     const lines = [];
@@ -241,68 +456,33 @@ function renderAgentLines(state, maxWidth, useLogo) {
         lines.push(` ${hotkey} ${emoji} ${col}${name}${RESET}`);
         lines.push(`${colors.dim}    ${truncText(secondary, maxWidth - 4)}${RESET}`);
     };
-    // #N suffix via shared assignDisplayNames
-    // Daemon mode: sessions list already contains all agents (including virtual OpenClaw).
-    // Also applies when daemon relays OpenClaw (agentType='openclaw' but sessions has the entry).
-    // Session bridge mode: sessions has siblings only — prepend self.
-    const isDaemonLike = state.agentType === 'daemon' ||
-        (state.agentType && state.sessions.some(s => s.agentType === state.agentType));
-    if (isDaemonLike) {
-        const sorted = sortSessions(state.sessions);
-        const displayed = assignDisplayNames(sorted.map(s => ({
-            id: s.id, projectName: s.projectName || 'unknown', agentType: s.agentType, state: s.state,
-            modelName: s.modelName,
-            port: s.port, controlMode: s.controlMode,
-            currentTask: s.currentTask,
-            contextPercent: s.contextPercent,
-            totalTokens: s.totalTokens,
-        })));
-        let focusableIndex = 0;
-        for (const d of displayed) {
-            const hotkeyIndex = sessionHotkeyIndex(d.session, focusableIndex);
-            if (hotkeyIndex !== null)
-                focusableIndex += 1;
-            renderSession(d.displayName, d.session.modelName, d.session.state || 'idle', d.session.agentType, hotkeyIndex, d.session);
-        }
-    }
-    else if (state.state) {
-        // Self (primary session)
-        renderSession(state.projectName || 'unknown', state.modelName ?? undefined, state.state, state.agentType ?? undefined, null);
-        // Siblings — include self as virtual entry for correct #N numbering
-        const sorted = sortSessions(state.sessions);
-        const selfEntry = {
-            id: '__self__', projectName: state.projectName || 'unknown',
-            agentType: state.agentType ?? undefined, state: state.state,
-        };
-        const allForNumbering = [selfEntry, ...sorted.map(s => ({
-                id: s.id, projectName: s.projectName || 'unknown', agentType: s.agentType, state: s.state,
-                modelName: s.modelName,
-                port: s.port, controlMode: s.controlMode,
-                currentTask: s.currentTask,
-                contextPercent: s.contextPercent,
-                totalTokens: s.totalTokens,
-            }))];
-        const displayed = assignDisplayNames(allForNumbering);
-        // Skip the self entry (index 0), render siblings with hotkey indices
-        let focusableIndex = 0;
-        for (let i = 1; i < displayed.length; i++) {
-            const d = displayed[i];
-            const sessionInfo = d.session;
-            const hotkeyIndex = sessionHotkeyIndex(sessionInfo, focusableIndex);
-            if (hotkeyIndex !== null)
-                focusableIndex += 1;
-            renderSession(d.displayName, d.session.modelName, d.session.state || 'idle', d.session.agentType, hotkeyIndex, sessionInfo);
-        }
-    }
-    // Virtual OpenClaw entry when gateway detected but not in sessions list
-    const hasOcSession = state.sessions.some(s => s.agentType === 'openclaw' || s.agentType === 'gateway');
-    if (state.gatewayAvailable && !hasOcSession) {
-        renderSession('OpenClaw', undefined, state.crayfishRouting ? 'processing' : 'idle', 'openclaw', null);
+    // Unified entry list (primary + siblings + virtual OpenClaw). Order and #N
+    // suffix matches macOS / iOS / Android via the shared sortSessions +
+    // assignDisplayNames pipeline inside buildHudEntries.
+    const entries = buildHudEntries(state);
+    let focusableIndex = 0;
+    for (const e of entries) {
+        const hotkeyIndex = hudHotkeyIndex(e, focusableIndex);
+        if (hotkeyIndex !== null)
+            focusableIndex += 1;
+        renderSession(e.displayName, e.modelName, e.state, e.agentType, hotkeyIndex, {
+            port: e.port,
+            controlMode: e.controlMode,
+            currentTask: e.currentTask,
+            contextPercent: e.contextPercent,
+            totalTokens: e.totalTokens,
+        });
     }
     // Gateway error warning
     if (state.gatewayHasError) {
         lines.push(`${colors.error} \u26A0 Gateway Error${RESET}`);
     }
+    const moduleLines = renderModuleHealthLines(state.moduleHealth, maxWidth);
+    if (moduleLines.length > 0) {
+        lines.push('');
+        lines.push(`${colors.header} DOWNSTREAM${RESET}`);
+        lines.push(...moduleLines);
+    }
     // Voice assistant indicator
     if (state.voiceAssistantState && state.voiceAssistantState !== 'disabled' && state.voiceAssistantState !== 'idle') {
         lines.push('');
@@ -391,9 +571,9 @@ function renderStatusLines(state, width) {
 }
 function renderOauthCatalogLines(modelCatalog, oauthConnected, width) {
     const lines = [];
-    const models = modelCatalog.filter((m) => m.available).map((m) => m.name);
+    const models = (modelCatalog ?? []).filter((m) => m.available).map((m) => m.name);
     if (models.length > 0) {
-        return wrapCommaList(' OAuth: ', models, width);
+        return wrapCommaList(' OAuth: ', models, width, 4);
     }
     if (oauthConnected === true) {
         lines.push(`${colors.dim}${truncText(' OAuth: connected', width)}${RESET}`);
@@ -403,22 +583,38 @@ function renderOauthCatalogLines(modelCatalog, oauthConnected, width) {
     }
     return lines;
 }
-function wrapCommaList(prefix, items, width) {
+function wrapCommaList(prefix, items, width, maxLines = Number.POSITIVE_INFINITY) {
     const lines = [];
     const indent = ' '.repeat(prefix.length);
     let current = prefix;
+    let consumed = 0;
     for (let i = 0; i < items.length; i++) {
         const chunk = i === 0 ? items[i] : `, ${items[i]}`;
         if (visLen(current) + visLen(chunk) <= width) {
             current += chunk;
+            consumed = i + 1;
             continue;
         }
         if (visLen(current) > visLen(prefix)) {
             lines.push(`${colors.dim}${padRight(current, width)}${RESET}`.trimEnd());
+            if (lines.length >= maxLines) {
+                const hidden = items.length - consumed;
+                if (hidden > 0)
+                    lines.push(`${colors.dim}${truncText(` ${hidden} more models`, width)}${RESET}`);
+                return lines;
+            }
             current = indent + items[i];
+            consumed = i + 1;
             continue;
         }
         lines.push(`${colors.dim}${truncText(current + chunk, width)}${RESET}`);
+        consumed = i + 1;
+        if (lines.length >= maxLines) {
+            const hidden = items.length - consumed;
+            if (hidden > 0)
+                lines.push(`${colors.dim}${truncText(` ${hidden} more models`, width)}${RESET}`);
+            return lines;
+        }
         current = indent;
     }
     if (visLen(current.trim()) > 0) {
@@ -451,12 +647,33 @@ function renderTimelineLines(state, width, maxLines, scrollOffset) {
         const e = entries[i];
         const time = new Date(e.ts);
         const timeStr = `${String(time.getHours()).padStart(2, '0')}:${String(time.getMinutes()).padStart(2, '0')}`;
-        const raw = truncText(e.raw, width - 10);
+        // task_end rows append a score+outcome suffix once the LLM judge resolves
+        // (5–30 s after the boundary itself). Until then the `taskOutcome` field
+        // is undefined and we render only the boundary label.
+        const evalSuffix = (e.type === 'task_end' && e.taskOutcome)
+            ? formatTaskEvalSuffix(e.taskScore, e.taskOutcome)
+            : '';
+        const raw = truncText(`${e.raw}${evalSuffix}`, width - 10);
         const pending = e.status === 'pending' ? `${colors.dim} [PENDING]${RESET}` : '';
         lines.push(` ${colors.dim}${timeStr}${RESET} ${typeColor(e.type)}${typeIcon(e.type)}${RESET} ${raw}${pending}`);
     }
     return lines;
 }
+export function formatTaskEvalSuffix(score, outcome) {
+    // `abandoned` flows from the manual `agentdeck task cancel` path and
+    // must render as its own glyph — not fall through to '' (which would
+    // make the task look pending) and not borrow the fail glyph (which
+    // would read as agent failure rather than user-initiated stop).
+    const glyph = outcome === 'success' ? '✓'
+        : outcome === 'fail' ? '✗'
+            : outcome === 'partial' ? '△'
+                : outcome === 'abandoned' ? '⊘'
+                    : '';
+    if (!glyph)
+        return '';
+    const scoreText = typeof score === 'number' ? score.toFixed(2) : '?';
+    return ` · ${scoreText} ${glyph}`;
+}
 function timelineHeader(state, width, maxLines, scrollOffset) {
     const total = state.timeline.length;
     if (total === 0)
@@ -649,64 +866,31 @@ function renderStandardLayout(state, cols, rows, terrariumLines, frame, scrollOf
 }
 function renderAgentCompactLines(state, width) {
     const lines = [];
-    const isDaemonLikeCompact = state.agentType === 'daemon' ||
-        (state.agentType && state.sessions.some(s => s.agentType === state.agentType));
-    if (isDaemonLikeCompact) {
-        let focusableIndex = 0;
-        for (const s of sortSessions(state.sessions)) {
-            const renderInfo = s;
-            const st = s.state || 'idle';
-            const col = stateColor(st);
-            const emoji = `${creatureBrandColor(s.agentType)}${creatureEmoji(s.agentType)}${RESET}`;
-            const status = `${col}${stateIcon(st)} ${compactStateLabel(st)}${RESET}`;
-            const detail = renderInfo.currentTask || s.modelName;
-            const model = detail ? `${colors.dim} · ${truncText(detail, Math.max(8, width - 24))}${RESET}` : '';
-            const marker = renderInfo.controlMode === 'observed' ? `${colors.dim} · obs${RESET}` : '';
-            const project = truncText(s.projectName || '?', Math.max(8, width - 20));
-            const hotkeyIndex = sessionHotkeyIndex(renderInfo, focusableIndex);
-            if (hotkeyIndex !== null)
-                focusableIndex += 1;
-            lines.push(` ${colors.dim}[${sessionHotkeyLabel(hotkeyIndex)}]${RESET} ${emoji} ${project} ${status}${marker}${model}`);
-        }
-    }
-    else if (state.state) {
-        // Self first
-        const col = stateColor(state.state);
-        const proj = truncText(state.projectName || '?', Math.max(8, width - 16));
-        const status = `${col}${stateIcon(state.state)} ${compactStateLabel(state.state)}${RESET}`;
-        const model = state.modelName ? `${colors.dim} · ${truncText(state.modelName, Math.max(8, width - 24))}${RESET}` : '';
-        const emoji = `${creatureBrandColor(state.agentType ?? undefined)}${creatureEmoji(state.agentType ?? undefined)}${RESET}`;
-        lines.push(` ${emoji} ${proj} ${status}${model}`);
-        // Siblings
-        let focusableIndex = 0;
-        for (const s of sortSessions(state.sessions)) {
-            const renderInfo = s;
-            const st = s.state || 'idle';
-            const sCol = stateColor(st);
-            const sEmoji = `${creatureBrandColor(s.agentType)}${creatureEmoji(s.agentType)}${RESET}`;
-            const sStatus = `${sCol}${stateIcon(st)} ${compactStateLabel(st)}${RESET}`;
-            const detail = renderInfo.currentTask || s.modelName;
-            const sModel = detail ? `${colors.dim} · ${truncText(detail, Math.max(8, width - 24))}${RESET}` : '';
-            const marker = renderInfo.controlMode === 'observed' ? `${colors.dim} · obs${RESET}` : '';
-            const sProject = truncText(s.projectName || '?', Math.max(8, width - 20));
-            const hotkeyIndex = sessionHotkeyIndex(renderInfo, focusableIndex);
-            if (hotkeyIndex !== null)
-                focusableIndex += 1;
-            lines.push(` ${colors.dim}[${sessionHotkeyLabel(hotkeyIndex)}]${RESET} ${sEmoji} ${sProject} ${sStatus}${marker}${sModel}`);
-        }
-    }
-    // Virtual OpenClaw entry
-    const hasOcCompact = state.sessions.some(s => s.agentType === 'openclaw' || s.agentType === 'gateway');
-    if (state.gatewayAvailable && !hasOcCompact) {
-        const ocState = state.crayfishRouting ? 'processing' : 'idle';
-        const ocCol = stateColor(ocState);
-        const ocEmoji = `${creatureBrandColor('openclaw')}${creatureEmoji('openclaw')}${RESET}`;
-        lines.push(` ${ocEmoji} OpenClaw ${ocCol}${stateIcon(ocState)}${ocState.toUpperCase()}${RESET}`);
+    // Unified entry list — same ordering and #N suffix as macOS / iOS / Android.
+    const entries = buildHudEntries(state);
+    let focusableIndex = 0;
+    for (const e of entries) {
+        const hotkeyIndex = hudHotkeyIndex(e, focusableIndex);
+        if (hotkeyIndex !== null)
+            focusableIndex += 1;
+        const col = stateColor(e.state);
+        const emoji = `${creatureBrandColor(e.agentType)}${creatureEmoji(e.agentType)}${RESET}`;
+        const status = `${col}${stateIcon(e.state)} ${compactStateLabel(e.state)}${RESET}`;
+        const detail = e.currentTask || e.modelName;
+        const model = detail ? `${colors.dim} · ${truncText(detail, Math.max(8, width - 24))}${RESET}` : '';
+        const marker = e.controlMode === 'observed' ? `${colors.dim} · obs${RESET}` : '';
+        const project = truncText(e.displayName, Math.max(8, width - 20));
+        lines.push(` ${colors.dim}[${sessionHotkeyLabel(hotkeyIndex)}]${RESET} ${emoji} ${project} ${status}${marker}${model}`);
     }
     // Gateway error warning
     if (state.gatewayHasError) {
         lines.push(`${colors.error} \u26A0 Gateway Error${RESET}`);
     }
+    const moduleLines = renderModuleHealthLines(state.moduleHealth, width);
+    if (moduleLines.length > 0) {
+        lines.push(`${colors.header} DOWNSTREAM${RESET}`);
+        lines.push(...moduleLines);
+    }
     // Voice assistant indicator (compact)
     if (state.voiceAssistantState && state.voiceAssistantState !== 'disabled' && state.voiceAssistantState !== 'idle') {
         if (state.voiceAssistantState === 'listening') {