magi-ai 0.1.0

package/dist/src/tui/magi-tui.js

@@ -0,0 +1,754 @@
+/**
+ * MagiTui — Main TUI class that orchestrates the Evangelion-themed interface.
+ *
+ * Subscribes to all 17 MagiEventBus events and drives:
+ *   Event → State update → Activity log → Animation → Render → ScreenBuffer → stdout
+ */
+import { isUnanimous as isUnanimousDecision, isApproval, isRejection } from '../types/consensus.js';
+import { ScreenBuffer } from './screen-buffer.js';
+import { calculateLayout } from './layout.js';
+import { PanelRenderer, getDisplayName } from './panel.js';
+import { HeaderRenderer } from './header.js';
+import { StatusBarRenderer } from './status-bar.js';
+import { ActivityLog } from './activity-log.js';
+import { AnimationController } from './animations.js';
+import { runBootSequence } from './boot-sequence.js';
+import { getTerminalSize, MIN_COLS, MIN_ROWS } from './terminal-detect.js';
+import { EVA_PALETTE, voteColor } from './colors.js';
+import { CURSOR_SHOW, ALT_SCREEN_LEAVE, CLEAR_SCREEN, CURSOR_HOME } from './ansi.js';
+import { ACTIVITY_LOG_LINES } from './layout.js';
+import { registerCleanup } from '../utils/shutdown.js';
+import { fireAndForget } from '../utils/fire-and-forget.js';
+import { suppressStdin } from './keypress.js';
+import { deriveSourceLabel, derivePriorityLabel, phaseCode, formatElapsedMmSs } from './tui-helpers.js';
+import { stringDisplayWidth, truncateToDisplayWidth } from './screen-buffer.js';
+// ── Unit order for layout mapping ───────────────────────────
+const KNOWN_UNITS = ['MELCHIOR', 'BALTHASAR', 'CASPER'];
+const UNIT_PHASE_OFFSETS = {
+    BALTHASAR: 0.0,
+    CASPER: 0.18,
+    MELCHIOR: 0.36,
+};
+const UNIT_KEYS = {
+    '1': 'MELCHIOR',
+    '2': 'BALTHASAR',
+    '3': 'CASPER',
+    q: undefined,
+    escape: undefined,
+    other: undefined,
+};
+// ── MagiTui ─────────────────────────────────────────────────
+export class MagiTui {
+    buf;
+    layout;
+    panelRenderer = new PanelRenderer();
+    headerRenderer = new HeaderRenderer();
+    statusBarRenderer = new StatusBarRenderer();
+    activityLog;
+    animations = new AnimationController();
+    stream;
+    eventBus;
+    skipBoot;
+    soundEnabled;
+    // State
+    unitStates = new Map();
+    headerData = { taskTitle: '', taskType: '', deliberationId: '', priorityLabel: 'B', modeLabel: 'STANDBY' };
+    statusData = { phase: '', roundNumber: 0, maxRounds: 3, elapsedMs: 0, modeLabel: 'STANDBY', alertCode: 'ALERT:NONE', umbilicalStatus: 'CONNECTED' };
+    verdictStamp = { text: '待　機', tone: 'pending' };
+    elapsedTimer;
+    startTime = 0;
+    renderScheduled = false;
+    disposed = false;
+    backgroundFilled = false;
+    completionPromise;
+    stdinCleanup;
+    deregisterCleanup;
+    dismissResolver;
+    tuiPhase = 'idle';
+    overlayUnit;
+    lastOverlayRect;
+    connectorPulseIndex = -1;
+    berserkFlashActive = false;
+    syncRates = {};
+    terminalFailure;
+    // Event listener references for cleanup
+    boundListeners = [];
+    resizeHandler;
+    constructor(options) {
+        this.eventBus = options.eventBus;
+        this.stream = options.stream ?? process.stdout;
+        this.skipBoot = options.skipBoot ?? false;
+        this.soundEnabled = options.soundEnabled ?? false;
+        const { cols, rows } = getTerminalSize();
+        this.buf = new ScreenBuffer(cols, rows);
+        this.layout = calculateLayout(cols, rows);
+        this.activityLog = new ActivityLog(ACTIVITY_LOG_LINES);
+        this.terminalFailure = this.getTerminalFailure(cols, rows);
+        // Initialize unit states
+        for (const unit of KNOWN_UNITS) {
+            this.unitStates.set(unit, { state: 'idle', breathPhase: 0 });
+        }
+    }
+    /** Start the TUI: boot sequence → initial draw → event binding. */
+    async start() {
+        // Boot sequence
+        this.tuiPhase = 'booting';
+        await runBootSequence({
+            write: (s) => this.write(s),
+            cols: this.buf.cols,
+            rows: this.buf.rows,
+            skipAnimation: this.skipBoot,
+        });
+        this.tuiPhase = 'idle';
+        // Initial full draw
+        this.buf.invalidate();
+        this.render();
+        this.write(this.buf.flush());
+        // Bind all events
+        this.bindEvents();
+        // Suppress stdin echo (prevents ^[[B etc. from appearing on screen)
+        this.stdinCleanup = suppressStdin((key) => this.handleKeypress(key));
+        // Resize handler (stored for cleanup in dispose())
+        if (this.stream === process.stdout) {
+            this.resizeHandler = () => this.handleResize();
+            process.stdout.on('resize', this.resizeHandler);
+        }
+        // Register cleanup for graceful shutdown (store deregister to avoid memory leak in REPL)
+        this.deregisterCleanup = registerCleanup(() => this.dispose());
+    }
+    /** Clean up: stop animations, unbind events, restore terminal. */
+    dispose() {
+        if (this.disposed)
+            return;
+        // Resolve pending dismiss (FIX-02: prevent hang on Ctrl+C during dismiss)
+        this.resolveDismiss();
+        // Stop animations and timers
+        this.animations.dispose();
+        if (this.elapsedTimer)
+            clearInterval(this.elapsedTimer);
+        // Restore stdin
+        this.stdinCleanup?.();
+        this.stdinCleanup = undefined;
+        // Unbind events
+        for (const { event, fn } of this.boundListeners) {
+            this.eventBus.off(event, fn);
+        }
+        this.boundListeners = [];
+        // Remove resize listener
+        if (this.resizeHandler && this.stream === process.stdout) {
+            process.stdout.off('resize', this.resizeHandler);
+            this.resizeHandler = undefined;
+        }
+        // Deregister cleanup callback to prevent memory leak in REPL (CRITICAL-2)
+        this.deregisterCleanup?.();
+        this.deregisterCleanup = undefined;
+        // Restore terminal (must happen BEFORE setting disposed flag)
+        this.write(CURSOR_SHOW + ALT_SCREEN_LEAVE);
+        this.disposed = true;
+    }
+    /** Wait for completion animation + keypress before disposing. */
+    async waitForDismiss() {
+        if (this.disposed)
+            return;
+        // Wait for completion animation (cascade + unanimousReveal)
+        if (this.completionPromise) {
+            await this.completionPromise;
+        }
+        // CRITICAL-1: dispose() may have fired during the await above,
+        // resolving dismissResolver before it was assigned. Check now.
+        if (this.disposed)
+            return;
+        // Show prompt in status bar
+        this.tuiPhase = 'dismiss';
+        this.statusData.showPrompt = true;
+        this.scheduleRender();
+        // Flush the render synchronously
+        await new Promise(resolve => queueMicrotask(() => resolve()));
+        // HIGH-10: When stdin is piped (not a TTY), no keypress will ever arrive.
+        // Show the final screen briefly then return.
+        if (!process.stdin.isTTY) {
+            await new Promise(r => setTimeout(r, 3000));
+            return;
+        }
+        await new Promise((resolve) => {
+            this.dismissResolver = resolve;
+        });
+    }
+    // ── Event binding ───────────────────────────────────────
+    bindEvents() {
+        this.on('deliberation:start', (e) => this.onDeliberationStart(e));
+        this.on('phase:start', (e) => this.onPhaseStart(e));
+        this.on('unit:start', (e) => this.onUnitStart(e));
+        this.on('unit:complete', (e) => this.onUnitComplete(e));
+        this.on('unit:error', (e) => this.onUnitError(e));
+        this.on('phase:complete', (e) => this.onPhaseComplete(e));
+        this.on('phase:skipped', (e) => this.onPhaseSkipped(e));
+        this.on('deliberation:complete', (e) => this.onDeliberationComplete(e));
+        // Phase H events
+        this.on('syncrate:updated', (e) => this.onSyncRateUpdated(e));
+        this.on('berserk:warning', (e) => this.onBerserkWarning(e));
+        this.on('bias:detected', (e) => this.onBiasDetected(e));
+        this.on('gospel:milestone', (e) => this.onGospelMilestone(e));
+        this.on('umbilical:status_changed', (e) => this.onUmbilicalStatusChanged(e));
+        this.on('dummyplug:activated', (e) => this.onDummyPlugActivated(e));
+        this.on('dummyplug:recovery', (e) => this.onDummyPlugRecovery(e));
+        this.on('cipher:discovered', (e) => this.onCipherDiscovered(e));
+        // Phase I events
+        this.on('memory:drift-warning', (e) => this.onMemoryDriftWarning(e));
+        this.on('memory:consolidated', (e) => this.onMemoryConsolidated(e));
+        this.on('berserk:activated', (e) => this.onBerserkActivated(e));
+        this.on('berserk:deactivated', (e) => this.onBerserkDeactivated(e));
+        this.on('instrumentality:triggered', (e) => this.onInstrumentalityTriggered(e));
+        this.on('fusion:complete', (e) => this.onFusionComplete(e));
+        this.on('lcl:contamination-detected', (e) => this.onLCLContamination(e));
+        this.on('lcl:purified', (e) => this.onLCLPurified(e));
+    }
+    on(event, fn) {
+        this.eventBus.on(event, fn);
+        this.boundListeners.push({ event, fn: fn });
+    }
+    // ── Core event handlers ─────────────────────────────────
+    onDeliberationStart(e) {
+        this.headerData = {
+            taskTitle: e.taskTitle,
+            taskType: e.taskType,
+            deliberationId: e.deliberationId,
+            sourceLabel: deriveSourceLabel(e.taskType, e.taskTitle),
+            priorityLabel: derivePriorityLabel(e.taskType),
+            modeLabel: 'NORMAL',
+        };
+        this.startTime = Date.now();
+        this.startElapsedTimer();
+        this.tuiPhase = 'deliberating';
+        this.overlayUnit = undefined;
+        this.statusData = {
+            ...this.statusData,
+            phase: '',
+            roundNumber: 0,
+            elapsedMs: 0,
+            decision: undefined,
+            fromCache: false,
+            atFieldLevel: 1,
+            warning: undefined,
+            modeLabel: 'NORMAL',
+            alertCode: 'ALERT:NONE',
+            syncSummary: 'AVG --  LOW --',
+            showPrompt: false,
+        };
+        this.verdictStamp = { text: '審　議　中', tone: 'pending' };
+        this.activityLog.push(`審議開始: ${e.taskTitle}`);
+        this.activityLog.setLive('ACTIVE LINK WAITING', EVA_PALETTE.magi);
+        this.playSound('start');
+        fireAndForget(this.animations.linePulse(this.layout.connectors.length, (index) => {
+            this.connectorPulseIndex = index;
+            this.scheduleRender();
+        }).finally(() => {
+            this.connectorPulseIndex = -1;
+            this.scheduleRender();
+        }), 'line-pulse');
+        this.scheduleRender();
+    }
+    onPhaseStart(e) {
+        this.statusData = {
+            ...this.statusData,
+            phase: e.phase,
+            roundNumber: e.roundNumber,
+            alertCode: 'ALERT:NONE',
+        };
+        // Reset unit states for new phase
+        for (const unit of KNOWN_UNITS) {
+            const us = this.unitStates.get(unit);
+            if (us && us.state !== 'offline') {
+                us.state = 'idle';
+                us.vote = undefined;
+                us.confidence = undefined;
+                us.durationMs = undefined;
+                us.startedAtMs = undefined;
+                us.reasoning = undefined;
+            }
+        }
+        this.activityLog.push(`Phase ${e.roundNumber}: ${e.phase}`);
+        this.updateLiveActivityStatus();
+        this.scheduleRender();
+    }
+    onUnitStart(e) {
+        const us = this.getOrCreateUnit(e.unit);
+        us.state = 'thinking';
+        us.startedAtMs = Date.now();
+        this.animations.startBreathingWithOffset(e.unit, UNIT_PHASE_OFFSETS[e.unit] ?? 0, (phase) => {
+            const s = this.unitStates.get(e.unit);
+            if (s) {
+                s.breathPhase = phase;
+                this.scheduleRender();
+            }
+        });
+        this.activityLog.push(`${e.unit} thinking...`);
+        this.updateLiveActivityStatus();
+        this.scheduleRender();
+    }
+    onUnitComplete(e) {
+        this.animations.stopBreathing(e.unit);
+        const us = this.getOrCreateUnit(e.unit);
+        us.state = 'complete';
+        us.vote = e.vote;
+        us.confidence = e.confidence;
+        us.durationMs = e.durationMs;
+        us.startedAtMs = undefined;
+        us.reasoning = e.reasoningSummary;
+        us.breathPhase = 0;
+        const confPct = Math.round(e.confidence * 100);
+        const dur = (e.durationMs / 1000).toFixed(1);
+        this.statusData.syncSummary = formatConfidenceSummary(this.unitStates);
+        this.activityLog.push(`${e.unit} ${e.vote} (${confPct}%) [${dur}s]`, voteColor(e.vote));
+        this.updateLiveActivityStatus();
+        this.playSound('unit');
+        this.scheduleRender();
+    }
+    onUnitError(e) {
+        this.animations.stopBreathing(e.unit);
+        const us = this.getOrCreateUnit(e.unit);
+        us.state = 'error';
+        us.startedAtMs = undefined;
+        us.breathPhase = 0;
+        this.activityLog.push(`${e.unit} FAILED: ${e.error.slice(0, 50)}`, EVA_PALETTE.warning);
+        this.statusData.alertCode = `ERROR:${e.unit}`;
+        this.updateLiveActivityStatus();
+        this.playSound('alert');
+        this.scheduleRender();
+    }
+    onPhaseSkipped(e) {
+        const label = e.reason === 'unanimous_early_exit' ? '全会一致' : '多数決合意';
+        this.activityLog.push(`SKIP: ${e.phase} (${label})`, EVA_PALETTE.approve);
+        this.statusData.alertCode = `SKIP:${label}`;
+        this.scheduleRender();
+    }
+    onPhaseComplete(e) {
+        const dur = (e.durationMs / 1000).toFixed(1);
+        this.activityLog.push(`Phase ${e.roundNumber} complete (${dur}s)`);
+        this.scheduleRender();
+    }
+    onDeliberationComplete(e) {
+        this.stopElapsedTimer();
+        this.statusData.decision = e.decision;
+        this.statusData.elapsedMs = e.totalDurationMs;
+        this.statusData.fromCache = e.fromCache;
+        this.tuiPhase = 'verdict-lock';
+        this.activityLog.setLive(undefined);
+        if (e.fromCache) {
+            this.activityLog.push(`MAGI DECISION: ${e.decision} (cached)`);
+            this.verdictStamp = { text: decisionStampText(e.decision), tone: decisionTone(e.decision) };
+            this.playSound('decision');
+            this.scheduleRender();
+            this.completionPromise = Promise.resolve();
+            return;
+        }
+        // Cascade reveal for non-cached results
+        const units = [...KNOWN_UNITS];
+        const isUnanimous = isUnanimousDecision(e.decision);
+        this.verdictStamp = { text: decisionStampText(e.decision), tone: decisionTone(e.decision) };
+        this.scheduleRender();
+        this.completionPromise = this.animations.cascade(units, (_unit) => {
+            this.playSound('unit');
+            this.scheduleRender();
+        }).then(async () => {
+            await this.animations.verdictLock(e.decision, (text, tone, blink) => {
+                this.verdictStamp = { text, tone, blink };
+                this.scheduleRender();
+            });
+            if (isUnanimous && !this.disposed) {
+                await this.animations.unanimousReveal(e.decision, (text, isApprove) => {
+                    this.activityLog.push(`MAGI DECISION: ${text} — ${e.decision}`, isApprove ? EVA_PALETTE.approve : EVA_PALETTE.reject);
+                    this.playSound('decision');
+                    this.scheduleRender();
+                });
+            }
+            else {
+                this.activityLog.push(`MAGI DECISION: ${e.decision}`);
+                this.playSound('decision');
+                this.scheduleRender();
+            }
+        });
+    }
+    // ── Phase H event handlers ──────────────────────────────
+    onSyncRateUpdated(e) {
+        this.syncRates = { ...e.rates };
+        this.statusData.syncSummary = formatSyncRateSummary(this.syncRates);
+        const rates = Object.entries(e.rates)
+            .map(([u, r]) => `${u} ${(r * 100).toFixed(1)}%`)
+            .join(' | ');
+        this.activityLog.push(`シンクロ率: ${rates}`);
+        this.scheduleRender();
+    }
+    onBerserkWarning(e) {
+        this.startBerserkFlash('ALERT', 'ALERT:BERSERK', `[BERSERK] 暴走警告: 合計シンクロ率 ${e.totalSyncRate.toFixed(2)}`, EVA_PALETTE.warning);
+    }
+    onBiasDetected(e) {
+        if (e.level === 1)
+            return;
+        this.statusData.atFieldLevel = e.level;
+        this.statusData.alertCode = `A.T.FIELD:${e.level === 'MAX' ? 'MAX' : `Lv${e.level}`}`;
+        const levelStr = e.level === 'MAX' ? 'MAX' : String(e.level);
+        this.activityLog.push(`[A.T. FIELD Level ${levelStr}] バイアス検出 (エントロピー: ${e.voteEntropy.toFixed(3)})`, EVA_PALETTE.frame);
+        this.scheduleRender();
+    }
+    onGospelMilestone(e) {
+        const labels = {
+            first_deliberation: '最初の審議完了',
+            first_unanimous: '初の全会一致',
+            first_deadlock: '初のデッドロック',
+            centenary: '100回到達',
+            millennium: '1000回到達',
+        };
+        const label = labels[e.milestone] ?? e.milestone;
+        this.activityLog.push(`[GOSPEL] ${label} (第${e.count}審議)`);
+        this.scheduleRender();
+    }
+    onUmbilicalStatusChanged(e) {
+        const us = this.unitStates.get(e.unit);
+        if (us) {
+            if (e.newStatus === 'disconnected') {
+                us.state = 'offline';
+            }
+            else if (us.state === 'offline') {
+                // Reconnected — restore to idle (unit:start/complete will set correct state)
+                us.state = 'idle';
+            }
+        }
+        this.statusData.umbilicalStatus = e.newStatus.toUpperCase();
+        this.statusData.alertCode = `CABLE:${e.newStatus.toUpperCase()}`;
+        this.activityLog.push(`[CABLE] ${e.unit} ${e.previousStatus} → ${e.newStatus}`);
+        this.scheduleRender();
+    }
+    onDummyPlugActivated(e) {
+        const conf = Math.round(e.confidence * 100);
+        this.activityLog.push(`[DUMMY PLUG] ${e.unit} 起動 (confidence: ${conf}%)`);
+        this.statusData.alertCode = 'ALERT:DUMMY';
+        this.scheduleRender();
+    }
+    onDummyPlugRecovery(e) {
+        this.activityLog.push(`[RECOVERY] ${e.unit} 復帰プロトコル`);
+        this.scheduleRender();
+    }
+    onCipherDiscovered(_e) {
+        this.activityLog.push(`[CIPHER] 裏コード発見`);
+        this.scheduleRender();
+    }
+    // ── Phase I event handlers ─────────────────────────────
+    onMemoryDriftWarning(e) {
+        const asi = (e.asiScore * 100).toFixed(1);
+        this.activityLog.push(`[DRIFT] ${e.unit} ASI ${asi}% (${e.consecutiveCount}連続)`, EVA_PALETTE.warning);
+        this.statusData.warning = `DRIFT: ${e.unit}`;
+        this.statusData.alertCode = `DRIFT:${e.unit}`;
+        this.scheduleRender();
+    }
+    onMemoryConsolidated(e) {
+        this.activityLog.push(`[ENGRAM] 記憶統合: ${e.episodicCount}件 → ${e.patternsExtracted}パターン`);
+        this.scheduleRender();
+    }
+    onBerserkActivated(e) {
+        this.startBerserkFlash('BERSERK', 'CODE:666', `[BERSERK] CODE:666 起動 R${e.round} (${e.candidateCount}候補)`, EVA_PALETTE.warning);
+    }
+    /** Shared berserk flash logic — overlay approach (FIX-03 + FIX-06). */
+    startBerserkFlash(modeLabel, alertCode, logMsg, logColor) {
+        fireAndForget(this.animations.berserkFlash((isRed) => {
+            this.berserkFlashActive = isRed;
+            this.scheduleRender();
+        }).finally(() => {
+            this.berserkFlashActive = false;
+            this.scheduleRender();
+        }), 'berserk-flash');
+        this.headerData.modeLabel = modeLabel;
+        this.statusData.modeLabel = modeLabel;
+        this.statusData.alertCode = alertCode;
+        this.activityLog.push(logMsg, logColor);
+        this.playSound('alert');
+        this.scheduleRender();
+    }
+    onBerserkDeactivated(e) {
+        this.headerData.modeLabel = 'NORMAL';
+        this.statusData.modeLabel = 'NORMAL';
+        this.statusData.alertCode = `BERSERK:${e.decision}`;
+        this.activityLog.push(`[BERSERK] 暴走停止: ${e.decision} (${e.totalRounds}R)`);
+        this.scheduleRender();
+    }
+    onInstrumentalityTriggered(e) {
+        this.activityLog.push(`[補完] 人類補完計画発動: ${e.reason} (${e.roundsBeforeFusion}R)`, EVA_PALETTE.frame);
+        this.statusData.alertCode = 'ALERT:FUSION';
+        this.scheduleRender();
+    }
+    onFusionComplete(e) {
+        const conf = Math.round(e.confidence * 100);
+        this.activityLog.push(`[補完] 融合完了: confidence ${conf}%`);
+        this.statusData.alertCode = 'FUSION:COMPLETE';
+        this.scheduleRender();
+    }
+    onLCLContamination(e) {
+        this.activityLog.push(`[LCL] ${e.unit} 汚染検出: ${e.hallucinationCount}件 (${e.types.join(', ')})`, EVA_PALETTE.warning);
+        this.statusData.alertCode = 'LCL:CONTAM';
+        this.scheduleRender();
+    }
+    onLCLPurified(e) {
+        const orig = Math.round(e.originalConfidence * 100);
+        const adj = Math.round(e.adjustedConfidence * 100);
+        this.activityLog.push(`[LCL] ${e.unit} 浄化完了: ${orig}% → ${adj}%`);
+        this.statusData.alertCode = 'LCL:PURIFIED';
+        this.scheduleRender();
+    }
+    // ── Render pipeline ─────────────────────────────────────
+    scheduleRender() {
+        if (this.renderScheduled || this.disposed)
+            return;
+        this.renderScheduled = true;
+        queueMicrotask(() => {
+            this.renderScheduled = false;
+            if (!this.disposed) {
+                this.render();
+                this.write(this.buf.flush());
+            }
+        });
+    }
+    render() {
+        const l = this.layout;
+        // Draw outer frame background (once; reset on resize)
+        if (!this.backgroundFilled) {
+            const bgc = EVA_PALETTE.background;
+            for (let r = 0; r < this.buf.rows; r++) {
+                for (let c = 0; c < this.buf.cols; c++) {
+                    this.buf.writeAt(r, c, ' ', bgc.r, bgc.g, bgc.b, bgc.r, bgc.g, bgc.b);
+                }
+            }
+            this.backgroundFilled = true;
+        }
+        if (this.lastOverlayRect) {
+            this.fillBackgroundRect(this.lastOverlayRect);
+            this.lastOverlayRect = undefined;
+        }
+        if (this.terminalFailure) {
+            this.renderTerminalWarning(this.terminalFailure);
+            return;
+        }
+        // Header
+        this.headerRenderer.drawHeader(this.buf, l.header, this.headerData);
+        this.headerRenderer.drawVerdictStamp(this.buf, l.verdictStamp, this.verdictStamp);
+        // Panels
+        this.panelRenderer.drawPanel(this.buf, l.balthasarPanel, this.buildPanelContent('BALTHASAR'));
+        this.panelRenderer.drawPanel(this.buf, l.casperPanel, this.buildPanelContent('CASPER'));
+        this.panelRenderer.drawPanel(this.buf, l.melchiorPanel, this.buildPanelContent('MELCHIOR'));
+        // MAGI node + connectors
+        this.panelRenderer.drawMagiNode(this.buf, l.magiNode, this.buildMagiNodeContent());
+        this.panelRenderer.drawConnectors(this.buf, l.connectors, this.connectorPulseIndex);
+        // Activity log
+        this.activityLog.draw(this.buf, l.activityLog);
+        // Status bar
+        this.statusBarRenderer.drawStatusBar(this.buf, l.statusBar, this.statusData);
+        if (this.overlayUnit) {
+            this.lastOverlayRect = this.renderDetailOverlay(this.overlayUnit);
+        }
+    }
+    buildPanelContent(unit) {
+        const us = this.unitStates.get(unit) ?? { state: 'idle', breathPhase: 0 };
+        // Overlay berserk flash without mutating actual unit state (FIX-03)
+        const effectiveState = this.berserkFlashActive && us.state !== 'error' && us.state !== 'offline' && us.state !== 'complete'
+            ? 'berserk'
+            : us.state;
+        return {
+            unit,
+            displayName: getDisplayName(unit),
+            state: effectiveState,
+            vote: us.vote,
+            confidence: us.confidence,
+            durationMs: us.durationMs,
+            activeDurationMs: us.startedAtMs !== undefined && us.state === 'thinking'
+                ? Math.max(0, Date.now() - us.startedAtMs)
+                : undefined,
+            reasoning: us.reasoning,
+            breathPhase: us.breathPhase,
+        };
+    }
+    buildMagiNodeContent() {
+        return {
+            phaseCode: phaseCode(this.statusData.phase),
+            roundLabel: this.statusData.roundNumber > 0 ? `R${this.statusData.roundNumber}` : undefined,
+            modeLabel: this.statusData.modeLabel,
+        };
+    }
+    // ── Resize ──────────────────────────────────────────────
+    handleResize() {
+        const { cols, rows } = getTerminalSize();
+        this.buf.resize(cols, rows);
+        this.layout = calculateLayout(cols, rows);
+        this.terminalFailure = this.getTerminalFailure(cols, rows);
+        this.buf.invalidate();
+        this.backgroundFilled = false;
+        this.write(CLEAR_SCREEN + CURSOR_HOME);
+        this.render();
+        this.write(this.buf.flush());
+    }
+    // ── Elapsed timer ───────────────────────────────────────
+    startElapsedTimer() {
+        this.stopElapsedTimer();
+        this.elapsedTimer = setInterval(() => {
+            this.statusData.elapsedMs = Date.now() - this.startTime;
+            this.updateLiveActivityStatus();
+            this.scheduleRender();
+        }, 500);
+    }
+    stopElapsedTimer() {
+        if (this.elapsedTimer) {
+            clearInterval(this.elapsedTimer);
+            this.elapsedTimer = undefined;
+        }
+    }
+    // ── Helpers ─────────────────────────────────────────────
+    getOrCreateUnit(unit) {
+        let us = this.unitStates.get(unit);
+        if (!us) {
+            us = { state: 'idle', breathPhase: 0 };
+            this.unitStates.set(unit, us);
+        }
+        return us;
+    }
+    getTerminalFailure(cols, rows) {
+        if (cols < MIN_COLS || rows < MIN_ROWS) {
+            return `Terminal too small (${cols}x${rows}, need ${MIN_COLS}x${MIN_ROWS})`;
+        }
+        return null;
+    }
+    renderTerminalWarning(message) {
+        const frame = EVA_PALETTE.warning;
+        const title = 'TACTICAL DISPLAY PAUSED';
+        const messageLines = [
+            title,
+            truncateToDisplayWidth(message, Math.max(12, this.buf.cols - 8)),
+            `Resize terminal to at least ${MIN_COLS}x${MIN_ROWS}.`,
+        ];
+        const desiredWidth = Math.max(18, Math.max(...messageLines.map(line => stringDisplayWidth(line))) + 4);
+        const boxWidth = Math.max(10, Math.min(this.buf.cols - 2, desiredWidth));
+        const boxHeight = messageLines.length + 2;
+        const top = Math.max(0, Math.floor((this.buf.rows - boxHeight) / 2));
+        const left = Math.max(0, Math.floor((this.buf.cols - boxWidth) / 2));
+        for (let x = left; x < left + boxWidth; x++) {
+            this.buf.writeAt(top, x, x === left ? '┌' : x === left + boxWidth - 1 ? '┐' : '─', frame.r, frame.g, frame.b);
+            this.buf.writeAt(top + boxHeight - 1, x, x === left ? '└' : x === left + boxWidth - 1 ? '┘' : '─', frame.r, frame.g, frame.b);
+        }
+        for (let y = top + 1; y < top + boxHeight - 1; y++) {
+            this.buf.writeAt(y, left, '│', frame.r, frame.g, frame.b);
+            this.buf.writeAt(y, left + boxWidth - 1, '│', frame.r, frame.g, frame.b);
+        }
+        const textColor = EVA_PALETTE.textPrimary;
+        for (let i = 0; i < messageLines.length; i++) {
+            const line = truncateToDisplayWidth(messageLines[i], boxWidth - 4);
+            const startCol = left + Math.max(1, Math.floor((boxWidth - stringDisplayWidth(line)) / 2));
+            this.buf.writeAt(top + 1 + i, startCol, line, textColor.r, textColor.g, textColor.b);
+        }
+    }
+    write(s) {
+        if (s && !this.disposed) {
+            this.stream.write(s);
+        }
+    }
+    handleKeypress(key) {
+        if (key === 'escape' || key === 'q') {
+            if (this.overlayUnit) {
+                this.overlayUnit = undefined;
+                this.scheduleRender();
+                return;
+            }
+            this.resolveDismiss();
+            return;
+        }
+        const unit = UNIT_KEYS[key];
+        if (unit && this.tuiPhase !== 'booting') {
+            this.overlayUnit = unit;
+            this.scheduleRender();
+            return;
+        }
+        this.resolveDismiss();
+    }
+    /** Resolve pending dismiss promise if in dismiss phase (FIX-02). */
+    resolveDismiss() {
+        if (this.dismissResolver) {
+            const resolve = this.dismissResolver;
+            this.dismissResolver = undefined;
+            resolve();
+        }
+    }
+    renderDetailOverlay(unit) {
+        const overlayRect = {
+            row: 3,
+            col: 4,
+            width: Math.max(40, this.buf.cols - 8),
+            height: Math.max(10, this.buf.rows - 6),
+        };
+        this.panelRenderer.drawUnitDetailOverlay(this.buf, overlayRect, this.buildPanelContent(unit));
+        return overlayRect;
+    }
+    playSound(kind) {
+        if (!this.soundEnabled || this.disposed)
+            return;
+        const repeat = kind === 'decision' ? 2 : 1;
+        for (let i = 0; i < repeat; i++) {
+            this.stream.write('\x07');
+        }
+    }
+    fillBackgroundRect(rect) {
+        const bgc = EVA_PALETTE.background;
+        for (let r = rect.row; r < rect.row + rect.height; r++) {
+            for (let c = rect.col; c < rect.col + rect.width; c++) {
+                this.buf.writeAt(r, c, ' ', bgc.r, bgc.g, bgc.b, bgc.r, bgc.g, bgc.b);
+            }
+        }
+    }
+    updateLiveActivityStatus() {
+        const activeUnits = KNOWN_UNITS.filter((unit) => this.unitStates.get(unit)?.state === 'thinking');
+        if (this.tuiPhase !== 'deliberating') {
+            this.activityLog.setLive(undefined);
+            return;
+        }
+        if (activeUnits.length === 0) {
+            this.activityLog.setLive('ACTIVE LINK WAITING', EVA_PALETTE.magi);
+            return;
+        }
+        const parts = [];
+        for (const unit of activeUnits) {
+            const state = this.unitStates.get(unit);
+            const elapsed = state?.startedAtMs !== undefined ? formatElapsedMmSs(Date.now() - state.startedAtMs) : '--:--';
+            parts.push(`${unit} ${elapsed}`);
+        }
+        this.activityLog.setLive(`ACTIVE ${parts.join('  //  ')}`, EVA_PALETTE.magi);
+    }
+}
+function formatSyncRateSummary(syncRates) {
+    const values = KNOWN_UNITS
+        .map(unit => syncRates[unit])
+        .filter((value) => value !== undefined);
+    if (values.length === 0)
+        return 'AVG --  LOW --';
+    const avg = Math.round(values.reduce((sum, value) => sum + value, 0) / values.length * 100);
+    const low = Math.round(Math.min(...values) * 100);
+    return `AVG ${avg}%  LOW ${low}%`;
+}
+function formatConfidenceSummary(unitStates) {
+    const values = KNOWN_UNITS
+        .map(unit => unitStates.get(unit)?.confidence)
+        .filter((value) => value !== undefined);
+    if (values.length === 0)
+        return 'AVG --  LOW --';
+    const avg = Math.round(values.reduce((sum, value) => sum + value, 0) / values.length * 100);
+    const low = Math.round(Math.min(...values) * 100);
+    return `AVG ${avg}%  LOW ${low}%`;
+}
+function decisionStampText(decision) {
+    if (isApproval(decision))
+        return '可　決';
+    if (isRejection(decision))
+        return '否　決';
+    return '膠　着';
+}
+function decisionTone(decision) {
+    if (isApproval(decision))
+        return 'approve';
+    if (isRejection(decision))
+        return 'reject';
+    return 'deadlock';
+}