agent-tempo 1.0.1

package/dist/tui/App.js

@@ -0,0 +1,1791 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = App;
+exports.stripLeadingIcon = stripLeadingIcon;
+exports.isHomeView = isHomeView;
+exports.pinnedConfirmationLines = pinnedConfirmationLines;
+exports.countPinnedConfirmationLines = countPinnedConfirmationLines;
+exports.pinnedTipLine = pinnedTipLine;
+exports.countPinnedTipLines = countPinnedTipLines;
+/**
+ * Root TUI application component — chat-focused shell with slash commands.
+ *
+ * Layout (top to bottom):
+ * - TitleBar (pinned)
+ * - Divider
+ * - Static scroll-up history
+ * - Live content area (splash, main, chat, error)
+ * - Divider
+ * - PromptArea (pinned)
+ */
+const react_1 = __importStar(require("react"));
+const os_1 = require("os");
+const ink_context_1 = require("./ink-context");
+const store_1 = require("./store");
+/**
+ * Track terminal rows so the root Box height stays < stdout.rows.
+ * Prevents Ink's fullscreen bypass (clearTerminal + full rewrite).
+ */
+function useTerminalRows() {
+    const [rows, setRows] = (0, react_1.useState)(process.stdout.rows || 24);
+    (0, react_1.useEffect)(() => {
+        const onResize = () => setRows(process.stdout.rows || 24);
+        process.stdout.on('resize', onResize);
+        return () => { process.stdout.off('resize', onResize); };
+    }, []);
+    return rows;
+}
+const Splash_1 = require("./components/Splash");
+const ChatView_1 = require("./components/ChatView");
+const ErrorView_1 = require("./components/ErrorView");
+const RecruitWizard_1 = require("./components/RecruitWizard");
+const PromptArea_1 = require("./components/PromptArea");
+const StatusBar_1 = require("./components/StatusBar");
+const ScheduleWizard_1 = require("./components/ScheduleWizard");
+const CreateEnsembleWizard_1 = require("./components/CreateEnsembleWizard");
+const HomeView_1 = require("./components/HomeView");
+const NewEnsembleModal_1 = require("./components/NewEnsembleModal");
+const LoadLineupModal_1 = require("./components/LoadLineupModal");
+const RestoreConfirmModal_1 = require("./components/RestoreConfirmModal");
+const DestroyConfirmModal_1 = require("./components/DestroyConfirmModal");
+const CommandPalette_1 = require("./components/CommandPalette");
+const StatusOverlay_1 = require("./components/StatusOverlay");
+const ConversationStream_1 = require("./components/ConversationStream");
+const PlayerDetailView_1 = require("./components/PlayerDetailView");
+const Picker_1 = require("./components/Picker");
+const commands_1 = require("./commands");
+const removed_commands_1 = require("./removed-commands");
+const theme_1 = require("./utils/theme");
+const format_1 = require("./utils/format");
+const platform_1 = require("./utils/platform");
+const format_2 = require("./utils/format");
+const history_1 = require("./utils/history");
+const sse_handler_1 = require("./sse-handler");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const packageVersion = require('../../package.json').version;
+let staticIdCounter = 0;
+function nextStaticId() {
+    return `static-${++staticIdCounter}`;
+}
+/** Color for static item text. */
+function staticItemColor(item) {
+    switch (item.type) {
+        case 'error': return theme_1.THEME.error;
+        case 'message': return theme_1.THEME.accent;
+        case 'splash-done': return theme_1.THEME.success;
+        case 'info': return theme_1.THEME.textMuted;
+        case 'command-output': return theme_1.THEME.text;
+        default: return theme_1.THEME.text;
+    }
+}
+function App({ api, ensemble, defaultAgent }) {
+    const { Box, Text, useApp, useInput } = (0, ink_context_1.useInk)();
+    const [state, dispatch] = (0, react_1.useReducer)(store_1.tuiReducer, (0, store_1.initialState)(ensemble));
+    const { exit } = useApp();
+    const termRows = useTerminalRows();
+    // ── Persistent command history ──
+    const [cmdHistory] = react_1.default.useState(() => (0, history_1.loadHistory)());
+    // ── Prompt ref (uncontrolled — input lives in PromptArea, not parent state) ──
+    const promptRef = react_1.default.useRef(null);
+    // Input value ref for palette filtering (no dispatch per keystroke)
+    const inputValueRef = react_1.default.useRef('');
+    // ── Refs for values read by useInput/useCallback (avoids stale closures + excess re-renders) ──
+    const lastSeenMsgRef = react_1.default.useRef(state.lastSeenMessageId);
+    const lastSeenMaestroRef = react_1.default.useRef(undefined);
+    const stateRef = react_1.default.useRef(state);
+    stateRef.current = state; // Always current on every render
+    // Track which messages have been committed to Static (overflow from live area)
+    const overflowCommittedRef = react_1.default.useRef(new Set());
+    // Overflow data computed during render, committed to Static via useEffect
+    const overflowRef = react_1.default.useRef(null);
+    // Callback for picker selection — set before showing picker, called on Enter
+    const pickerCallbackRef = react_1.default.useRef(null);
+    // Picker items ref — synced from pickerItems memo so useInput reads sorted items
+    const pickerItemsRef = react_1.default.useRef([]);
+    // Reset stale refs when switching ensembles + add separator
+    const prevEnsembleRef = react_1.default.useRef(state.activeEnsemble);
+    (0, react_1.useEffect)(() => {
+        lastSeenMsgRef.current = undefined;
+        lastSeenMaestroRef.current = undefined;
+        overflowCommittedRef.current.clear();
+        // Add separator when switching between ensembles (not on initial load)
+        if (state.activeEnsemble && prevEnsembleRef.current !== state.activeEnsemble && prevEnsembleRef.current !== undefined) {
+            dispatch({
+                type: 'COMMIT_STATIC',
+                item: {
+                    id: nextStaticId(),
+                    type: 'info',
+                    content: `\u2500\u2500 Switched to ensemble: ${state.activeEnsemble} \u2500\u2500`,
+                    timestamp: Date.now(),
+                },
+            });
+        }
+        prevEnsembleRef.current = state.activeEnsemble;
+    }, [state.activeEnsemble]);
+    // Commit overflow messages to Static scrollback after render (not during render)
+    (0, react_1.useEffect)(() => {
+        const data = overflowRef.current;
+        if (!data)
+            return;
+        const { formatted, startIdx } = data;
+        const overflow = formatted.slice(0, startIdx);
+        for (const msg of overflow) {
+            const key = `${msg.direction}:${msg.time}:${msg.body.slice(0, 60)}`;
+            if (!overflowCommittedRef.current.has(key)) {
+                overflowCommittedRef.current.add(key);
+                // Blank separator
+                dispatch({ type: 'COMMIT_STATIC', item: { id: nextStaticId(), type: 'info', content: '', timestamp: Date.now() } });
+                // Cap third-party messages to 4 lines; direct messages uncapped
+                const lines = msg.body.split('\n');
+                const lineCap = msg.thirdParty ? 4 : lines.length;
+                let body = lines.slice(0, lineCap).join('\n');
+                if (lines.length > lineCap) {
+                    body += `\n\u2026 (${lines.length - lineCap} more lines)`;
+                }
+                // Commit entire body as a single message item — static renderer word-wraps correctly
+                dispatch({ type: 'COMMIT_STATIC', item: {
+                        id: nextStaticId(), type: 'message', content: body, timestamp: Date.now(),
+                        msgDirection: msg.direction, msgSender: msg.sender, msgTime: msg.time,
+                        msgThirdParty: msg.thirdParty, msgRouteLabel: msg.routeLabel,
+                    } });
+            }
+        }
+    });
+    const handleHistoryUpdate = (0, react_1.useCallback)((entries) => {
+        (0, history_1.saveHistory)(entries);
+    }, []);
+    // ── Global keybindings (uses stateRef to avoid recreating on every poll) ──
+    useInput((0, react_1.useCallback)((input, key) => {
+        const s = stateRef.current;
+        if (key.ctrl && input === 'c') {
+            exit();
+            return;
+        }
+        // Scrollback navigation (Page Up/Down, Home/End)
+        // Scroll keys removed — terminal native scrollback via <Static> handles this
+        // Status overlay — Escape dismisses, ↑↓ scrolls
+        if (s.statusOverlay) {
+            if (key.escape) {
+                dispatch({ type: 'HIDE_STATUS' });
+                return;
+            }
+            if (key.upArrow) {
+                dispatch({ type: 'STATUS_SCROLL_UP' });
+                return;
+            }
+            if (key.downArrow) {
+                dispatch({ type: 'STATUS_SCROLL_DOWN' });
+                return;
+            }
+            return;
+        }
+        // Interactive overlay — Escape dismisses, ↑↓ selects, action keys per type
+        if (s.overlay) {
+            if (key.escape) {
+                dispatch({ type: 'HIDE_OVERLAY' });
+                return;
+            }
+            if (key.upArrow) {
+                dispatch({ type: 'OVERLAY_SELECT', direction: 'up' });
+                return;
+            }
+            if (key.downArrow) {
+                dispatch({ type: 'OVERLAY_SELECT', direction: 'down' });
+                return;
+            }
+            // Schedule overlay action keys
+            if (s.overlay.type === 'schedules') {
+                if (input === 'n' || input === 'N') {
+                    dispatch({ type: 'HIDE_OVERLAY' });
+                    dispatch({ type: 'ENTER_SCHEDULE_WIZARD' });
+                    return;
+                }
+            }
+            // Gates/stages — Enter shows detail for selected item
+            if ((s.overlay.type === 'gates' || s.overlay.type === 'stages') && key.return) {
+                const selected = s.overlay.items[s.overlay.selectedIndex];
+                if (selected) {
+                    const detail = selected.sublabel
+                        ? `\n  ${selected.label}\n\n  ${selected.sublabel.split('  ').join('\n  ')}`
+                        : `\n  ${selected.label}\n\n  No details available.`;
+                    dispatch({ type: 'SHOW_COMMAND_OVERLAY', title: selected.label.slice(0, 40), content: detail });
+                }
+                return;
+            }
+            return; // Swallow all other input while overlay is active
+        }
+        // Player detail view — Escape goes back, ↑↓ scrolls messages
+        if (s.view === 'player') {
+            if (key.escape) {
+                dispatch({ type: 'NAVIGATE_ENSEMBLE', ensemble: s.activeEnsemble });
+                return;
+            }
+            if (key.upArrow) {
+                dispatch({ type: 'PLAYER_SCROLL_UP' });
+                return;
+            }
+            if (key.downArrow) {
+                dispatch({ type: 'PLAYER_SCROLL_DOWN' });
+                return;
+            }
+            return;
+        }
+        // Picker overlay navigation
+        if (s.pickerVisible) {
+            if (key.escape) {
+                dispatch({ type: 'HIDE_PICKER' });
+                return;
+            }
+            if (key.upArrow) {
+                dispatch({ type: 'PICKER_UP' });
+                return;
+            }
+            if (key.downArrow) {
+                dispatch({ type: 'PICKER_DOWN' });
+                return;
+            }
+            if (key.return) {
+                const cb = pickerCallbackRef.current;
+                if (s.pickerType === 'players') {
+                    const item = pickerItemsRef.current[s.pickerIndex];
+                    if (item) {
+                        dispatch({ type: 'HIDE_PICKER' });
+                        if (cb) {
+                            cb(item.id);
+                            pickerCallbackRef.current = null;
+                        }
+                        else if (s.pickerIntent === 'navigate') {
+                            // Navigate to player detail view
+                            dispatch({ type: 'NAVIGATE_PLAYER', playerId: item.id });
+                        }
+                        else {
+                            // Default: navigate to player detail view
+                            dispatch({ type: 'NAVIGATE_PLAYER', playerId: item.id });
+                        }
+                    }
+                }
+                else if (s.pickerType === 'ensembles') {
+                    const ensItem = pickerItemsRef.current[s.pickerIndex];
+                    if (ensItem) {
+                        dispatch({ type: 'HIDE_PICKER' });
+                        if (ensItem.id === '__create__') {
+                            // Launch the create-ensemble wizard
+                            dispatch({ type: 'ENTER_CREATE_ENSEMBLE' });
+                        }
+                        else if (cb) {
+                            cb(ensItem.id);
+                            pickerCallbackRef.current = null;
+                        }
+                        else {
+                            dispatch({ type: 'NAVIGATE_ENSEMBLE', ensemble: ensItem.id });
+                            dispatch({
+                                type: 'COMMIT_STATIC',
+                                item: { id: nextStaticId(), type: 'info', content: `Switched to ensemble: ${ensItem.id}`, timestamp: Date.now() },
+                            });
+                        }
+                    }
+                }
+                return;
+            }
+            return;
+        }
+        // Destroy confirmation mode (PR-H: was `/stop`; now `/destroy` and routed
+        // through TempoClient.destroy() — the V2 outbox path — instead of the
+        // legacy raw-Temporal `terminatePlayer` shim.
+        if (s.confirmingStop) {
+            if (input === 'y' || input === 'Y') {
+                const target = s.confirmingStop;
+                const reason = s.confirmingStopReason;
+                dispatch({ type: 'CANCEL_STOP' });
+                (async () => {
+                    try {
+                        const ensembles = await api.discoverEnsembles();
+                        for (const ens of ensembles) {
+                            try {
+                                await api.destroy(ens.name, target, reason);
+                                // #306: command-result summary as a bottom-pinned notification
+                                // so the user actually sees the confirmation when chat is busy.
+                                (0, commands_1.commitNotification)(dispatch, 'info', `\u2716 Destroyed ${target}${reason ? ` (${reason})` : ''}.`);
+                                return;
+                            }
+                            catch {
+                                // Try next ensemble
+                            }
+                        }
+                        (0, commands_1.commitNotification)(dispatch, 'error', `\u2717 Player "${target}" not found in any ensemble.`);
+                    }
+                    catch (err) {
+                        (0, commands_1.commitNotification)(dispatch, 'error', `\u2717 Failed to destroy ${target}: ${err}`);
+                    }
+                })();
+            }
+            else if (input === 'n' || input === 'N' || key.escape) {
+                dispatch({ type: 'CANCEL_STOP' });
+                dispatch({
+                    type: 'COMMIT_STATIC',
+                    item: { id: nextStaticId(), type: 'info', content: 'Destroy cancelled.', timestamp: Date.now() },
+                });
+            }
+            return;
+        }
+        // Disband confirmation mode
+        if (s.confirmingDisband) {
+            if (input === 'y' || input === 'Y') {
+                const ensemble = s.confirmingDisband;
+                dispatch({ type: 'CANCEL_DISBAND' });
+                (async () => {
+                    try {
+                        const { terminated } = await api.disbandEnsemble(ensemble);
+                        dispatch({
+                            type: 'COMMIT_STATIC',
+                            item: { id: nextStaticId(), type: 'info', content: `\u2714 Disbanded ensemble "${ensemble}" — terminated ${terminated} workflow${terminated !== 1 ? 's' : ''}.`, timestamp: Date.now() },
+                        });
+                        // Navigate back to home view
+                        dispatch({ type: 'NAVIGATE_HOME' });
+                    }
+                    catch (err) {
+                        (0, commands_1.commitNotification)(dispatch, 'error', `\u2717 Failed to disband "${ensemble}": ${err}`);
+                    }
+                })();
+            }
+            else if (input === 'n' || input === 'N' || key.escape) {
+                dispatch({ type: 'CANCEL_DISBAND' });
+                dispatch({
+                    type: 'COMMIT_STATIC',
+                    item: { id: nextStaticId(), type: 'info', content: 'Disband cancelled.', timestamp: Date.now() },
+                });
+            }
+            return;
+        }
+        // Lineup confirmation mode
+        if (s.confirmingLineup) {
+            if (input === 'y' || input === 'Y') {
+                const { path: lineupPath } = s.confirmingLineup;
+                const activeEns = s.activeEnsemble;
+                dispatch({ type: 'CANCEL_LINEUP' });
+                if (!activeEns) {
+                    (0, commands_1.commitNotification)(dispatch, 'error', 'No active ensemble.');
+                }
+                else {
+                    (async () => {
+                        try {
+                            await api.sendCommand(activeEns, `/load_lineup ${lineupPath}`, 'maestro');
+                            dispatch({
+                                type: 'COMMIT_STATIC',
+                                item: { id: nextStaticId(), type: 'info', content: `\u2714 Lineup load requested: ${lineupPath}`, timestamp: Date.now() },
+                            });
+                        }
+                        catch (err) {
+                            (0, commands_1.commitNotification)(dispatch, 'error', `\u2717 Failed to load lineup: ${err}`);
+                        }
+                    })();
+                }
+            }
+            else if (input === 'n' || input === 'N' || key.escape) {
+                dispatch({ type: 'CANCEL_LINEUP' });
+                dispatch({
+                    type: 'COMMIT_STATIC',
+                    item: { id: nextStaticId(), type: 'info', content: 'Lineup load cancelled.', timestamp: Date.now() },
+                });
+            }
+            return;
+        }
+        // #306: Esc dismisses the oldest live notification when no other
+        // Esc-consumer is active (overlays, pickers, confirmations all return
+        // early above). Filter-expired-first is handled in the reducer so this
+        // always acts on what the user is actually looking at. No-op when the
+        // stack is empty, so other Esc fallthroughs — like clearing a typed
+        // command — aren't disturbed.
+        if (key.escape && s.notifications.some(n => n.expiresAt > Date.now())) {
+            dispatch({ type: 'DISMISS_OLDEST_NOTIFICATION' });
+            return;
+        }
+    }, [exit, api])); // Stable deps only — reads stateRef.current for everything else
+    // ── Derived: conductor player id ──
+    // #358: single source of truth — derive the active conductor's playerId from
+    // the `players` array rather than caching it in a separate state field that
+    // only the snapshot path updated. Incremental SSE events (`player.added`,
+    // `player.removed`) update `players` directly, so the badge stays accurate
+    // between snapshots. `undefined` when no conductor is in the ensemble.
+    const conductorPlayerId = (0, react_1.useMemo)(() => state.players.find(p => p.isConductor)?.playerId, [state.players]);
+    // ── Context string for title bar ──
+    const contextString = (0, react_1.useMemo)(() => {
+        if (state.phase === 'splash')
+            return 'Starting up...';
+        if (state.phase === 'error')
+            return 'Error';
+        if (state.chatTarget) {
+            const isConductor = state.chatTarget === conductorPlayerId;
+            const player = state.players.find(p => p.playerId === state.chatTarget);
+            const status = (0, format_1.phaseToLabel)(player?.phase);
+            const icon = isConductor ? '\u2605' : '\u2022';
+            return `${icon} ${state.chatTarget} \u00b7 ${status}${state.activeEnsemble ? ` \u00b7 ${state.activeEnsemble}` : ''}`;
+        }
+        if (state.activeEnsemble) {
+            // Headline count excludes the maestro session (TUI's own dashboard
+            // attachment). The full list with the maestro is still available in
+            // `/players` and the status overlay.
+            const count = (0, format_1.filterRealPlayers)(state.players).length;
+            const conductorInfo = conductorPlayerId ? '' : ' \u00b7 No conductor';
+            return `${state.activeEnsemble} \u00b7 ${count} player${count !== 1 ? 's' : ''}${conductorInfo} \u00b7 Connected`;
+        }
+        const count = state.ensembles?.length ?? 0;
+        return count > 0 ? `${count} ensemble${count !== 1 ? 's' : ''} \u00b7 Connected` : 'Discovering ensembles...';
+    }, [state.phase, state.chatTarget, state.activeEnsemble, state.players, state.ensembles, conductorPlayerId]);
+    // ── Hint text for prompt area ──
+    const promptHints = (0, react_1.useMemo)(() => {
+        if (state.confirmingStop) {
+            return `Destroy ${state.confirmingStop}? This will terminally end their session workflow. [y/N]`;
+        }
+        if (state.confirmingDisband) {
+            return `Disband ensemble "${state.confirmingDisband}"? All sessions will be terminated. [y/N]`;
+        }
+        if (state.confirmingLineup) {
+            return `${state.confirmingLineup.summary} [y/N]`;
+        }
+        if (state.phase === 'recruit') {
+            return 'Follow the prompts above. Esc to cancel.';
+        }
+        if (state.chatTarget) {
+            return `Chatting with ${state.chatTarget}. /back to return.`;
+        }
+        if (state.activeEnsemble) {
+            return 'Type a message, or @player to message directly. /players to list.';
+        }
+        return '/help /quit';
+    }, [state.phase, state.chatTarget, state.confirmingStop, state.confirmingDisband, state.activeEnsemble]);
+    // ── Completion data for prompt ──
+    const commandNamesList = (0, react_1.useMemo)(() => (0, commands_1.getCommandNames)(), []);
+    const playerNamesList = (0, react_1.useMemo)(() => state.players.map(p => p.playerId), [state.players]);
+    // ── Picker items ──
+    const pickerItems = (0, react_1.useMemo)(() => {
+        if (!state.pickerVisible)
+            return [];
+        if (state.pickerType === 'players') {
+            // Apply status filter if set.
+            const filtered = state.pickerStatusFilter
+                ? state.players.filter(p => p.phase === state.pickerStatusFilter)
+                : state.players;
+            // Sort by type for grouping, conductor first
+            const sorted = [...filtered].sort((a, b) => {
+                if (a.isConductor !== b.isConductor)
+                    return a.isConductor ? -1 : 1;
+                const typeA = a.playerType || a.agentType || '';
+                const typeB = b.playerType || b.agentType || '';
+                return typeA.localeCompare(typeB) || a.playerId.localeCompare(b.playerId);
+            });
+            // Resolve icons once for the whole map (not per-item) per
+            // docs/tui-performance.md — `statusIcons()` allocates a small object.
+            const icons = (0, platform_1.statusIcons)((0, platform_1.supportsUnicode)());
+            return sorted.map(p => ({
+                id: p.playerId,
+                label: p.playerId,
+                detail: `[${(0, format_1.phaseToLabel)(p.phase)}]`,
+                meta: p.part || undefined,
+                icon: p.isConductor ? '\u2605' : icons[(0, format_1.phaseToIconName)(p.phase)],
+                color: (0, format_1.phaseToColor)(p.phase),
+                current: p.playerId === state.chatTarget,
+                group: p.playerType || p.agentType || 'unknown',
+            }));
+        }
+        if (state.pickerType === 'ensembles') {
+            const items = (state.ensembles ?? []).map(ens => ({
+                id: ens.name,
+                label: ens.name,
+                detail: `${ens.playerCount} player${ens.playerCount !== 1 ? 's' : ''}`,
+                meta: ens.hasConductor ? '\u2605 conductor' : undefined,
+                current: ens.name === state.activeEnsemble,
+            }));
+            // Add "Create new ensemble" option at the bottom
+            items.push({
+                id: '__create__',
+                label: '+ Create new ensemble',
+                detail: 'launch wizard',
+                icon: '\u2795',
+                color: theme_1.THEME.accent,
+            });
+            return items;
+        }
+        return [];
+    }, [state.pickerVisible, state.pickerType, state.pickerStatusFilter, state.players, state.ensembles, state.chatTarget, state.activeEnsemble]);
+    pickerItemsRef.current = pickerItems;
+    // ── Command palette ──
+    const allPaletteCommands = (0, react_1.useMemo)(() => (0, commands_1.getCommandNames)().map(name => ({
+        name,
+        usage: commands_1.COMMANDS[name].usage,
+        description: commands_1.COMMANDS[name].description,
+    })), []);
+    // Palette filter state — updated via onInputChange ref callback (no dispatch per keystroke).
+    // Stores the full PaletteContext (mode + partial + replacePrefix) so the palette can
+    // show player names for `/restart <partial>`-style player-arg inputs, not just bare
+    // `/cmd` and `@name` inputs.
+    const [paletteCtx, setPaletteCtx] = (0, react_1.useState)(null);
+    const handleInputChange = (0, react_1.useCallback)((value) => {
+        inputValueRef.current = value;
+        const next = (0, commands_1.classifyPaletteInput)(value);
+        // Reference-equal no-op avoidance: only dispatch when mode/partial actually changed.
+        setPaletteCtx(prev => {
+            if (prev === next)
+                return prev;
+            if (prev && next && prev.mode === next.mode && prev.partial === next.partial && prev.replacePrefix === next.replacePrefix) {
+                return prev;
+            }
+            return next;
+        });
+    }, []);
+    // Player commands and subcommand map imported from commands.ts
+    const filteredPaletteCommands = (0, react_1.useMemo)(() => {
+        if (!state.paletteVisible || !paletteCtx)
+            return [];
+        if (paletteCtx.mode === 'player' || paletteCtx.mode === 'player-arg') {
+            return (0, commands_1.filterPlayerNames)(playerNamesList, paletteCtx.partial)
+                .map(n => ({ name: n, usage: `${paletteCtx.replacePrefix}${n}`, description: '' }));
+        }
+        // command mode
+        if (!paletteCtx.partial)
+            return allPaletteCommands;
+        return allPaletteCommands.filter(c => c.name.startsWith(paletteCtx.partial));
+    }, [state.paletteVisible, paletteCtx, allPaletteCommands, playerNamesList]);
+    // Clamp palette index
+    const clampedPaletteIndex = Math.min(state.paletteIndex, Math.max(0, filteredPaletteCommands.length - 1));
+    const handlePaletteToggle = (0, react_1.useCallback)((visible) => {
+        dispatch(visible ? { type: 'SHOW_PALETTE' } : { type: 'HIDE_PALETTE' });
+    }, []);
+    const handlePaletteUp = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'PALETTE_UP' });
+    }, []);
+    const handlePaletteDown = (0, react_1.useCallback)(() => {
+        if (state.paletteIndex < filteredPaletteCommands.length - 1) {
+            dispatch({ type: 'PALETTE_DOWN' });
+        }
+    }, [state.paletteIndex, filteredPaletteCommands.length]);
+    const handlePaletteSelect = (0, react_1.useCallback)(() => {
+        if (filteredPaletteCommands.length > 0 && paletteCtx) {
+            const selected = filteredPaletteCommands[clampedPaletteIndex];
+            // replacePrefix already carries the right leading characters:
+            //   command mode    → '/'         → `${/}recruit `
+            //   player mode     → '@'         → `${@}conductor `
+            //   player-arg mode → '/restart ' → `${/restart }conductor `
+            const value = `${paletteCtx.replacePrefix}${selected.name} `;
+            promptRef.current?.setValue(value);
+            inputValueRef.current = value;
+            dispatch({ type: 'HIDE_PALETTE' });
+        }
+    }, [filteredPaletteCommands, clampedPaletteIndex, paletteCtx]);
+    // ── Command submission handler ──
+    const handleSubmit = (0, react_1.useCallback)(async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return;
+        const s = stateRef.current;
+        // PromptArea clears itself on Enter (uncontrolled). Just clear our ref + palette.
+        inputValueRef.current = '';
+        if (s.paletteVisible)
+            dispatch({ type: 'HIDE_PALETTE' });
+        const parsed = (0, commands_1.parseCommand)(trimmed);
+        if (parsed) {
+            // Slash command
+            if (parsed.name === 'quit' || parsed.name === 'exit') {
+                exit();
+                return;
+            }
+            if (parsed.name === 'back') {
+                // Return to maestro view (exit any player chat)
+                if (s.chatTarget) {
+                    dispatch({ type: 'EXIT_CHAT' });
+                    dispatch({
+                        type: 'COMMIT_STATIC',
+                        item: { id: nextStaticId(), type: 'info', content: `\u2500\u2500 returned to maestro view \u2500\u2500`, timestamp: Date.now() },
+                    });
+                }
+                else if (s.activeEnsemble) {
+                    dispatch({ type: 'NAVIGATE_HOME' });
+                    dispatch({
+                        type: 'COMMIT_STATIC',
+                        item: { id: nextStaticId(), type: 'info', content: `\u2500\u2500 returned to home view \u2500\u2500`, timestamp: Date.now() },
+                    });
+                }
+                return;
+            }
+            if (parsed.name === 'help') {
+                if (parsed.args.length > 0) {
+                    const cmdName = parsed.args[0].replace(/^\//, '');
+                    const cmd = commands_1.COMMANDS[cmdName];
+                    if (cmd) {
+                        dispatch({ type: 'SHOW_COMMAND_OVERLAY', title: `Help \u00B7 /${cmdName}`, content: `\n  ${cmd.description}\n\n  Usage: ${cmd.usage}` });
+                    }
+                    else {
+                        dispatch({ type: 'SHOW_COMMAND_OVERLAY', title: 'Help', content: `\n  Unknown command: "${cmdName}"` });
+                    }
+                }
+                else {
+                    dispatch({ type: 'SHOW_COMMAND_OVERLAY', title: 'Help', content: (0, commands_1.formatHelpSummary)() });
+                }
+                return;
+            }
+            // Commands that open player picker when no args provided
+            const PICKER_COMMANDS = {
+                stop: (id) => {
+                    dispatch({ type: 'COMMIT_STATIC', item: { id: nextStaticId(), type: 'info', content: `Stopping ${id}...`, timestamp: Date.now() } });
+                    const cmd = commands_1.COMMANDS['stop'];
+                    if (cmd?.handler)
+                        cmd.handler([id], dispatch, api, { activeEnsemble: stateRef.current.activeEnsemble, defaultAgent });
+                },
+                players: (id) => {
+                    dispatch({ type: 'NAVIGATE_PLAYER', playerId: id });
+                },
+                player: (id) => {
+                    dispatch({ type: 'NAVIGATE_PLAYER', playerId: id });
+                },
+            };
+            if (PICKER_COMMANDS[parsed.name] && parsed.args.length === 0) {
+                pickerCallbackRef.current = PICKER_COMMANDS[parsed.name];
+                dispatch({ type: 'SHOW_PICKER', pickerType: 'players' });
+                return;
+            }
+            // Alias: /player → /players
+            if (parsed.name === 'player') {
+                parsed.name = 'players';
+            }
+            if (!(0, commands_1.isValidCommand)(parsed.name)) {
+                const migrationHint = (0, removed_commands_1.removedSlashCommandHelp)(parsed.name);
+                (0, commands_1.commitNotification)(dispatch, 'error', migrationHint ?? `Unknown command: /${parsed.name}. Type /help for available commands.`);
+                return;
+            }
+            // Command exists but handler not yet implemented
+            const cmd = commands_1.COMMANDS[parsed.name];
+            if (!cmd.handler) {
+                dispatch({
+                    type: 'COMMIT_STATIC',
+                    item: {
+                        id: nextStaticId(),
+                        type: 'info',
+                        content: `/${parsed.name}: coming soon. Usage: ${cmd.usage}`,
+                        timestamp: Date.now(),
+                    },
+                });
+                return;
+            }
+            // Execute handler
+            try {
+                const ctx = { activeEnsemble: s.activeEnsemble, defaultAgent };
+                await cmd.handler(parsed.args, dispatch, api, ctx);
+            }
+            catch (err) {
+                (0, commands_1.commitNotification)(dispatch, 'error', `Error running /${parsed.name}: ${err}`);
+            }
+        }
+        else if (s.activeEnsemble) {
+            // Bare text → route via @player or to conductor
+            const atMatch = trimmed.match(/^@(\S+)\s+(.+)$/s);
+            try {
+                if (atMatch) {
+                    // @player message → send directly to that player
+                    const [, targetPlayer, message] = atMatch;
+                    dispatch({ type: 'APPEND_SENT_MESSAGE', to: targetPlayer, text: `@${targetPlayer} ${message}` });
+                    api.sendAsMaestro(s.activeEnsemble, targetPlayer, message).catch(err => (0, commands_1.commitNotification)(dispatch, 'error', `\u2717 Failed to deliver to @${targetPlayer}: ${err}`));
+                }
+                else {
+                    // No @prefix → send to conductor.
+                    // #358: derive from `players` (single source of truth) instead of
+                    // a separate cached field. `hasConductor` is the snapshot-derived
+                    // flag; we fall back to the legacy `'conductor'` literal when no
+                    // playerId is yet known so a freshly-loaded ensemble with the
+                    // hasConductor flag still routes correctly.
+                    const conductorPid = s.players.find(p => p.isConductor)?.playerId;
+                    if (!conductorPid && !s.hasConductor) {
+                        // No conductor — show error
+                        (0, commands_1.commitNotification)(dispatch, 'error', 'No conductor. Use @player to message directly, or /recruit a conductor.');
+                        return;
+                    }
+                    const conductorTarget = conductorPid || 'conductor';
+                    dispatch({ type: 'APPEND_SENT_MESSAGE', to: conductorTarget, text: trimmed });
+                    api.sendCommand(s.activeEnsemble, trimmed, 'maestro').catch(err => (0, commands_1.commitNotification)(dispatch, 'error', `\u2717 Failed to deliver: ${err}`));
+                }
+            }
+            catch (err) {
+                (0, commands_1.commitNotification)(dispatch, 'error', `\u2717 Error: ${err}`);
+            }
+        }
+        else {
+            // Bare text in main mode — hint to use commands
+            dispatch({
+                type: 'COMMIT_STATIC',
+                item: {
+                    id: nextStaticId(),
+                    type: 'info',
+                    content: 'Use /commands to interact. Type /help for available commands.',
+                    timestamp: Date.now(),
+                },
+            });
+        }
+    }, [api, exit]); // Reads stateRef.current for chatTarget/activeEnsemble
+    // ── Lightweight startup: check connectivity + ensure maestro session ──
+    // Phase starts at 'main' — polling handles all data discovery.
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        (async () => {
+            try {
+                // Check Temporal connectivity
+                const connected = await api.isConnected();
+                if (cancelled)
+                    return;
+                if (!connected) {
+                    dispatch({ type: 'SET_PHASE', phase: 'error', error: 'Cannot connect to Temporal. Run `agent-tempo up` first.' });
+                    return;
+                }
+                // Mark splash as connected (updates splash UI)
+                dispatch({ type: 'SET_SPLASH_CONNECTED' });
+                // Ensure maestro session (best effort)
+                const ens = stateRef.current.activeEnsemble;
+                if (ens) {
+                    try {
+                        await api.ensureMaestroSession(ens);
+                    }
+                    catch (err) {
+                        console.error('[tui] Failed to create maestro session:', err);
+                    }
+                }
+            }
+            catch (err) {
+                if (!cancelled) {
+                    dispatch({ type: 'SET_PHASE', phase: 'error', error: String(err) });
+                }
+            }
+        })();
+        return () => { cancelled = true; };
+    }, [api]);
+    // ── Ensure maestro session exists when ensemble changes ──
+    (0, react_1.useEffect)(() => {
+        if (!state.activeEnsemble)
+            return;
+        api.ensureMaestroSession(state.activeEnsemble).catch(err => console.error('[tui] maestro session:', err));
+    }, [state.activeEnsemble, api]);
+    // ── #94/#95 PR-4a: data acquisition is split across three effects ──
+    //
+    // Previously a single 2 s `setInterval` fanned out 5 RPCs/tick (players,
+    // schedules, chat, paused, held) and conditionally drilled into a
+    // selected player. After PR-3 the per-ensemble surface is exposed via
+    // SSE, so we:
+    //   1. Keep a 2 s poll for the home view's ensemble list (no per-
+    //      ensemble surface there; SSE wouldn't help).
+    //   2. Subscribe to the daemon's SSE event stream for the active
+    //      ensemble so player/chat/flags/schedule updates land in
+    //      sub-second latency rather than waiting for a poll tick.
+    //   3. Keep a 2 s poll for the player drill-in view — per
+    //      docs/SSE-PROTOCOL.md §11 the per-player + per-message
+    //      endpoints are intentionally Temporal-direct.
+    // PR-4b will replace the rendering primitives (chat scrollback +
+    // player list); this PR deliberately leaves layout untouched so a
+    // streaming regression is bisectable independent of scroll changes.
+    // Effect 1: home-view ensembles list polling.
+    (0, react_1.useEffect)(() => {
+        if (state.phase !== 'splash' && state.phase !== 'main' && state.phase !== 'chat')
+            return;
+        if (state.activeEnsemble)
+            return;
+        let cancelled = false;
+        const tick = async () => {
+            try {
+                const ensembles = await api.discoverEnsembles();
+                if (cancelled)
+                    return;
+                // Intentionally no auto-select: HomeView is an explicit picker
+                // (Online / Paused / Offline, arrow keys + Enter). Auto-selecting
+                // on the poller was bouncing users back into a just-shut-down
+                // ensemble after `/shutdown`, `/back`, or `/disband`.
+                dispatch({ type: 'REFRESH_ENSEMBLES', ensembles });
+            }
+            catch (err) {
+                console.error('[tui:home-poll] error:', err);
+            }
+        };
+        void tick();
+        const interval = setInterval(tick, 2000);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, [state.phase, state.activeEnsemble, api]);
+    // Effect 2: active-ensemble SSE subscription.
+    (0, react_1.useEffect)(() => {
+        if (state.phase !== 'splash' && state.phase !== 'main' && state.phase !== 'chat')
+            return;
+        if (!state.activeEnsemble)
+            return;
+        const ensemble = state.activeEnsemble;
+        const controller = new AbortController();
+        void (async () => {
+            try {
+                for await (const event of api.subscribe(ensemble, { signal: controller.signal })) {
+                    await (0, sse_handler_1.handleSseEvent)(event, dispatch, ensemble, api);
+                }
+            }
+            catch (err) {
+                // AbortError on teardown is expected — only log unexpected failures.
+                if (controller.signal.aborted)
+                    return;
+                console.error('[tui:subscribe] error:', err);
+            }
+        })();
+        return () => controller.abort();
+    }, [state.phase, state.activeEnsemble, api]);
+    // Effect 3: player drill-in polling (per spec §11 — Temporal-direct).
+    (0, react_1.useEffect)(() => {
+        if (state.view !== 'player')
+            return;
+        if (!state.activeEnsemble || !state.activePlayer)
+            return;
+        const ensemble = state.activeEnsemble;
+        const playerId = state.activePlayer;
+        let cancelled = false;
+        const tick = async () => {
+            try {
+                const [metadata, messages] = await Promise.all([
+                    api.getPlayerMetadata(ensemble, playerId),
+                    api.getPlayerMessages(ensemble, playerId),
+                ]);
+                if (cancelled)
+                    return;
+                dispatch({ type: 'REFRESH_PLAYER_DATA', metadata, messages });
+            }
+            catch {
+                // Best-effort — player may have been terminated mid-poll.
+            }
+        };
+        void tick();
+        const interval = setInterval(tick, 2000);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, [state.view, state.activeEnsemble, state.activePlayer, api]);
+    // ── Recruit wizard callbacks (must be before early return — Rules of Hooks) ──
+    const handleRecruitAnswer = (0, react_1.useCallback)((answer) => {
+        dispatch({ type: 'RECRUIT_NEXT_STEP', answer });
+    }, []);
+    const handleRecruitBack = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'RECRUIT_PREV_STEP' });
+    }, []);
+    const handleRecruitConfirm = (0, react_1.useCallback)(async () => {
+        if (!state.recruitState)
+            return;
+        const activeEns = state.activeEnsemble;
+        if (!activeEns) {
+            dispatch({ type: 'RECRUIT_DONE', error: 'No active ensemble. Start one with: agent-tempo up <name>' });
+            return;
+        }
+        dispatch({ type: 'RECRUIT_SUBMIT' });
+        const a = state.recruitState.answers;
+        try {
+            // #306: Direct TempoClient path — submit the recruit entry on the
+            // TUI's own maestro session instead of round-tripping through the
+            // conductor's Claude Code session. Works when no conductor is present
+            // (the wizard's original use-case) and eliminates the 2-5s LLM hop.
+            await api.recruit(activeEns, {
+                name: a.name,
+                workDir: a.workDir,
+                agent: a.agent,
+                ...(a.playerType ? { playerType: a.playerType } : {}),
+                ...(a.host && a.host !== 'localhost' ? { host: a.host } : {}),
+                ...(a.initialMessage ? { initialMessage: a.initialMessage } : {}),
+            });
+            dispatch({ type: 'RECRUIT_DONE' });
+            dispatch({
+                type: 'COMMIT_STATIC',
+                item: {
+                    id: nextStaticId(),
+                    type: 'info',
+                    content: `\u2714 Recruit requested: ${a.name} (${a.agent}${a.playerType ? ', type: ' + a.playerType : ''})`,
+                    timestamp: Date.now(),
+                },
+            });
+        }
+        catch (err) {
+            dispatch({ type: 'RECRUIT_DONE', error: String(err) });
+        }
+    }, [state.recruitState, state.activeEnsemble, api]);
+    const handleRecruitCancel = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'EXIT_RECRUIT' });
+        dispatch({
+            type: 'COMMIT_STATIC',
+            item: { id: nextStaticId(), type: 'info', content: 'Recruit cancelled.', timestamp: Date.now() },
+        });
+    }, []);
+    const handleRecruitDone = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'EXIT_RECRUIT' });
+    }, []);
+    // ── Schedule wizard callbacks ──
+    const handleScheduleAnswer = (0, react_1.useCallback)((answer) => {
+        dispatch({ type: 'SCHEDULE_NEXT_STEP', answer });
+    }, []);
+    const handleScheduleBack = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'SCHEDULE_PREV_STEP' });
+    }, []);
+    const handleScheduleConfirm = (0, react_1.useCallback)(async () => {
+        if (!state.scheduleWizard)
+            return;
+        const activeEns = state.activeEnsemble;
+        if (!activeEns) {
+            dispatch({ type: 'SCHEDULE_DONE', error: 'No active ensemble.' });
+            return;
+        }
+        dispatch({ type: 'SCHEDULE_SUBMIT' });
+        const a = state.scheduleWizard.answers;
+        try {
+            const parts = [`/schedule ${a.name} --to ${a.target}`];
+            if (a.schedType === 'delay')
+                parts.push(`--delay ${a.timing}`);
+            else if (a.schedType === 'at')
+                parts.push(`--at ${a.timing}`);
+            else if (a.schedType === 'every')
+                parts.push(`--every ${a.timing}`);
+            else if (a.schedType === 'cron') {
+                parts.push(`--cron "${a.timing}"`);
+                if (a.timezone)
+                    parts.push(`--timezone ${a.timezone}`);
+            }
+            parts.push(a.message);
+            await api.sendCommand(activeEns, parts.join(' '), 'maestro');
+            dispatch({ type: 'SCHEDULE_DONE' });
+            dispatch({
+                type: 'COMMIT_STATIC',
+                item: { id: nextStaticId(), type: 'info', content: `\u2714 Schedule "${a.name}" creation requested.`, timestamp: Date.now() },
+            });
+        }
+        catch (err) {
+            dispatch({ type: 'SCHEDULE_DONE', error: String(err) });
+        }
+    }, [state.scheduleWizard, state.activeEnsemble, api]);
+    const handleScheduleCancel = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'EXIT_SCHEDULE_WIZARD' });
+        dispatch({
+            type: 'COMMIT_STATIC',
+            item: { id: nextStaticId(), type: 'info', content: 'Schedule creation cancelled.', timestamp: Date.now() },
+        });
+    }, []);
+    const handleScheduleDone = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'EXIT_SCHEDULE_WIZARD' });
+    }, []);
+    // ── Create ensemble wizard callbacks ──
+    const handleCreateEnsAnswer = (0, react_1.useCallback)((answer) => {
+        dispatch({ type: 'CREATE_ENSEMBLE_NEXT_STEP', answer });
+    }, []);
+    const handleCreateEnsBack = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'CREATE_ENSEMBLE_PREV_STEP' });
+    }, []);
+    const handleCreateEnsConfirm = (0, react_1.useCallback)(async () => {
+        const wizState = stateRef.current.createEnsembleState;
+        if (!wizState)
+            return;
+        dispatch({ type: 'CREATE_ENSEMBLE_SUBMIT' });
+        const { name, workDir, lineup } = wizState.answers;
+        try {
+            await api.createEnsemble({ ensemble: name, workDir, ...(lineup ? { lineup } : {}) });
+            dispatch({
+                type: 'COMMIT_STATIC',
+                item: { id: nextStaticId(), type: 'info', content: `\u2714 Ensemble "${name}" created.`, timestamp: Date.now() },
+            });
+            dispatch({ type: 'CREATE_ENSEMBLE_DONE', ensemble: name });
+        }
+        catch (err) {
+            dispatch({ type: 'CREATE_ENSEMBLE_DONE', error: err instanceof Error ? err.message : String(err) });
+        }
+    }, [api]);
+    const handleCreateEnsCancel = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'EXIT_CREATE_ENSEMBLE' });
+    }, []);
+    const handleCreateEnsDone = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'EXIT_CREATE_ENSEMBLE' });
+    }, []);
+    // ── Home view ─────────────────────────────────────────────────────────
+    const [cwdGitRoot] = (0, react_1.useState)(() => {
+        const { getGitInfo } = require('../git-info');
+        return getGitInfo(process.cwd()).gitRoot ?? null;
+    });
+    const bootstrapInitial = (0, react_1.useMemo)(() => ({
+        ensembles: state.ensembles ?? [],
+        cwdGitRoot,
+        badges: { orphanCount: 0 },
+    }), [state.ensembles, cwdGitRoot]);
+    const handleHomeEnter = (0, react_1.useCallback)((name) => {
+        dispatch({ type: 'NAVIGATE_ENSEMBLE', ensemble: name });
+    }, []);
+    const handleHomeQuit = (0, react_1.useCallback)(() => {
+        exit();
+    }, [exit]);
+    const handleHomeOpenNew = (0, react_1.useCallback)(() => {
+        // #306: Use the full CreateEnsembleWizard (same as Splash's `+ Create new
+        // ensemble` row) so the user gets the multi-step name → dir → lineup
+        // flow instead of the bare single-prompt NewEnsembleModal.
+        dispatch({ type: 'ENTER_CREATE_ENSEMBLE' });
+    }, []);
+    const handleHomeOpenLineup = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'OPEN_HOME_MODAL', modal: { type: 'lineup' } });
+    }, []);
+    const handleHomeOpenRestore = (0, react_1.useCallback)((ensembleName) => {
+        const match = state.ensembles?.find((e) => e.name === ensembleName);
+        dispatch({
+            type: 'OPEN_HOME_MODAL',
+            modal: {
+                type: 'restore',
+                ensemble: ensembleName,
+                playerCount: Math.max(0, (match?.playerCount ?? 1) - (match?.hasConductor ? 1 : 0)),
+                conductor: match?.hasConductor ? 'conductor' : undefined,
+            },
+        });
+    }, [state.ensembles]);
+    const handleHomeModalClose = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'CLOSE_HOME_MODAL' });
+    }, []);
+    const handleHomeNewSubmit = (0, react_1.useCallback)(async (name) => {
+        dispatch({ type: 'SET_HOME_MODAL_STATUS', submitting: true });
+        try {
+            await api.createEnsemble({ ensemble: name });
+            dispatch({ type: 'CLOSE_HOME_MODAL' });
+            dispatch({ type: 'NAVIGATE_ENSEMBLE', ensemble: name });
+        }
+        catch (err) {
+            dispatch({
+                type: 'SET_HOME_MODAL_STATUS',
+                submitting: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }, [api]);
+    const handleHomeLineupSubmit = (0, react_1.useCallback)(async (args) => {
+        dispatch({ type: 'SET_HOME_MODAL_STATUS', submitting: true });
+        try {
+            await api.createEnsemble({ ensemble: args.ensemble, lineup: args.lineupPath });
+            dispatch({ type: 'CLOSE_HOME_MODAL' });
+            dispatch({ type: 'NAVIGATE_ENSEMBLE', ensemble: args.ensemble });
+        }
+        catch (err) {
+            dispatch({
+                type: 'SET_HOME_MODAL_STATUS',
+                submitting: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }, [api]);
+    // /destroy <ensemble> typed-name confirmation handlers (#291)
+    const handleEnsembleDestroyInput = (0, react_1.useCallback)((next) => {
+        dispatch({ type: 'ENSEMBLE_DESTROY_INPUT', input: next });
+    }, []);
+    const handleEnsembleDestroyCancel = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'CANCEL_ENSEMBLE_DESTROY' });
+        dispatch({
+            type: 'COMMIT_STATIC',
+            item: { id: nextStaticId(), type: 'info', content: 'Destroy cancelled.', timestamp: Date.now() },
+        });
+    }, []);
+    const handleEnsembleDestroySubmit = (0, react_1.useCallback)(async () => {
+        const pending = stateRef.current.confirmingEnsembleDestroy;
+        if (!pending)
+            return;
+        if (pending.input !== pending.ensemble) {
+            dispatch({ type: 'ENSEMBLE_DESTROY_MISMATCH' });
+            return;
+        }
+        dispatch({ type: 'ENSEMBLE_DESTROY_SUBMIT_BUSY' });
+        const target = pending.ensemble;
+        try {
+            const summary = await api.destroy(target);
+            dispatch({ type: 'CANCEL_ENSEMBLE_DESTROY' });
+            if (summary && 'details' in summary) {
+                // #306: aggregate ensemble-destroy summary surfaces as a bottom-pinned
+                // notification so it's still visible after we navigate the user home.
+                (0, commands_1.commitNotification)(dispatch, summary.failed > 0 ? 'error' : 'info', `\u2714 Destroyed "${target}" \u2014 ${summary.destroyed} destroyed, ${summary.terminated} terminated, ${summary.failed} failed.`);
+            }
+            dispatch({ type: 'NAVIGATE_HOME' });
+        }
+        catch (err) {
+            dispatch({ type: 'CANCEL_ENSEMBLE_DESTROY' });
+            (0, commands_1.commitNotification)(dispatch, 'error', `\u2717 Destroy failed for "${target}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [api]);
+    const handleHomeRestoreConfirm = (0, react_1.useCallback)(async () => {
+        const modal = stateRef.current.homeModal;
+        if (!modal || modal.type !== 'restore')
+            return;
+        const target = modal.ensemble;
+        dispatch({ type: 'SET_HOME_MODAL_STATUS', submitting: true });
+        try {
+            const summary = await api.restore(target);
+            dispatch({ type: 'CLOSE_HOME_MODAL' });
+            if (summary.failed > 0) {
+                (0, commands_1.commitNotification)(dispatch, 'error', `Restore partial: ${summary.reattached} queued, ${summary.failed} failed, ${summary.skipped} skipped.`);
+            }
+            // Mirror the `/restore` slash two-op: ensure a conductor terminal is
+            // live so the home-view restore path never strands the user on a
+            // reattached-but-conductor-less ensemble.
+            const { ensureConductorSpawned } = await Promise.resolve().then(() => __importStar(require('../client/ensure-conductor-spawned')));
+            const conductorOutcome = await ensureConductorSpawned(target, api);
+            if (!conductorOutcome.spawned && conductorOutcome.reason === 'spawnFailed') {
+                (0, commands_1.commitNotification)(dispatch, 'error', `Conductor spawn failed for "${target}": ${conductorOutcome.error}`);
+            }
+            dispatch({ type: 'NAVIGATE_ENSEMBLE', ensemble: target });
+        }
+        catch (err) {
+            dispatch({
+                type: 'SET_HOME_MODAL_STATUS',
+                submitting: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }, [api]);
+    // ── Memoize chat messages (must be before early return — Rules of Hooks) ──
+    const memoizedChatData = (0, react_1.useMemo)(() => {
+        if (!state.chatTarget)
+            return null;
+        const isConductorChat = state.chatTarget === conductorPlayerId;
+        let chatMessages;
+        if (isConductorChat) {
+            const fromHistory = state.conductorHistory.map(entry => {
+                if (entry.type === 'command') {
+                    const cmd = entry.data;
+                    return { direction: 'sent', from: cmd.source || 'maestro', text: cmd.text, timestamp: entry.timestamp || cmd.timestamp };
+                }
+                else {
+                    const report = entry.data;
+                    return { direction: 'received', from: report.playerId, text: `[${report.type}] ${report.text}`, timestamp: entry.timestamp || report.timestamp };
+                }
+            });
+            const fromSent = state.sentMessages
+                .filter(m => m.to === state.chatTarget)
+                .map(m => ({ direction: 'sent', from: 'maestro', text: m.text, timestamp: m.timestamp }));
+            const seen = new Set();
+            chatMessages = [...fromHistory, ...fromSent]
+                .sort((a, b) => a.timestamp.localeCompare(b.timestamp))
+                .filter(m => { const k = `${m.direction}:${m.timestamp}:${m.text.slice(0, 50)}`; if (seen.has(k))
+                return false; seen.add(k); return true; });
+        }
+        else {
+            const fromRelay = state.messages
+                .filter(m => m.from === state.chatTarget || m.to === state.chatTarget)
+                .map(m => ({ direction: m.to === state.chatTarget ? 'sent' : 'received', from: m.from, text: m.text, timestamp: m.timestamp }));
+            const fromSent = state.sentMessages
+                .filter(m => m.to === state.chatTarget)
+                .map(m => ({ direction: 'sent', from: 'maestro', text: m.text, timestamp: m.timestamp }));
+            const seen = new Set();
+            chatMessages = [...fromRelay, ...fromSent]
+                .sort((a, b) => a.timestamp.localeCompare(b.timestamp))
+                .filter(m => { const k = `${m.direction}:${m.timestamp}:${m.text.slice(0, 50)}`; if (seen.has(k))
+                return false; seen.add(k); return true; });
+        }
+        return {
+            messages: chatMessages,
+            received: chatMessages.filter(m => m.direction === 'received').length,
+            sent: chatMessages.filter(m => m.direction === 'sent').length,
+            isConductor: isConductorChat,
+        };
+    }, [state.chatTarget, conductorPlayerId, state.conductorHistory, state.messages, state.sentMessages]);
+    // Note: relay messages are committed to staticItems directly in the poll loop.
+    // Conductor history messages are committed when entering conductor chat mode.
+    // ── Render ──
+    // Divider — thin horizontal rule
+    const dividerWidth = Math.max(20, (process.stdout.columns || 80) - 4);
+    const dividerLine = '\u2500'.repeat(dividerWidth);
+    // Splash → create ensemble handler: launch the create-ensemble wizard
+    const handleSplashCreate = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'ENTER_CREATE_ENSEMBLE' });
+    }, []);
+    // Splash → main transition handler
+    const handleSplashContinue = (0, react_1.useCallback)((selectedEnsemble) => {
+        if (selectedEnsemble) {
+            dispatch({ type: 'NAVIGATE_ENSEMBLE', ensemble: selectedEnsemble });
+            dispatch({
+                type: 'COMMIT_STATIC',
+                item: { id: nextStaticId(), type: 'info', content: `\u2714 Connected to ensemble: ${selectedEnsemble}`, timestamp: Date.now() },
+            });
+        }
+        dispatch({ type: 'SET_PHASE', phase: 'main' });
+    }, []);
+    function renderLiveContent() {
+        // Terminal size warning (non-blocking)
+        const termCols = process.stdout.columns || 80;
+        if (termCols < 60 || termRows < 15) {
+            return react_1.default.createElement(Text, { color: theme_1.THEME.warning }, `\n  \u26A0 Terminal too small (${termCols}\u00D7${termRows}). Resize to at least 60\u00D715 for best experience.`);
+        }
+        // Splash screen — shown on startup when no ensemble is specified
+        if (state.phase === 'splash') {
+            return react_1.default.createElement(Splash_1.Splash, {
+                status: state.splashStatus,
+                version: packageVersion,
+                connected: state.splashConnected,
+                ensembles: (state.ensembles ?? undefined),
+                onContinue: handleSplashContinue,
+                onCreateEnsemble: handleSplashCreate,
+            });
+        }
+        if (state.phase === 'error') {
+            return react_1.default.createElement(ErrorView_1.ErrorView, {
+                version: packageVersion,
+                checks: [
+                    { label: `Cannot reach Temporal`, passed: false, detail: state.error },
+                ],
+                errorDetail: state.error,
+                onQuit: () => { process.exitCode = 1; exit(); },
+            });
+        }
+        // Picker takes over full content area
+        if (state.pickerVisible) {
+            const pickerTitle = state.pickerType === 'ensembles'
+                ? 'Select Ensemble'
+                : 'Select Player';
+            return react_1.default.createElement(Picker_1.Picker, {
+                title: pickerTitle,
+                items: pickerItems,
+                selectedIndex: state.pickerIndex,
+                hint: '\u2191\u2193 navigate, Enter select, Esc dismiss',
+            });
+        }
+        if (state.phase === 'recruit' && state.recruitState) {
+            return react_1.default.createElement(RecruitWizard_1.RecruitWizard, {
+                state: state.recruitState,
+                onAnswer: handleRecruitAnswer,
+                onBack: handleRecruitBack,
+                onConfirm: handleRecruitConfirm,
+                onCancel: handleRecruitCancel,
+                onDone: handleRecruitDone,
+            });
+        }
+        if (state.phase === 'schedule-create' && state.scheduleWizard) {
+            return react_1.default.createElement(ScheduleWizard_1.ScheduleWizard, {
+                state: state.scheduleWizard,
+                onAnswer: handleScheduleAnswer,
+                onBack: handleScheduleBack,
+                onConfirm: handleScheduleConfirm,
+                onCancel: handleScheduleCancel,
+                onDone: handleScheduleDone,
+            });
+        }
+        if (state.phase === 'create-ensemble' && state.createEnsembleState) {
+            return react_1.default.createElement(CreateEnsembleWizard_1.CreateEnsembleWizard, {
+                state: state.createEnsembleState,
+                onAnswer: handleCreateEnsAnswer,
+                onBack: handleCreateEnsBack,
+                onConfirm: handleCreateEnsConfirm,
+                onCancel: handleCreateEnsCancel,
+                onDone: handleCreateEnsDone,
+            });
+        }
+        // Home-view modals (#290). Render in place of HomeView so the modal
+        // owns keyboard focus — HomeView's own useInput short-circuits when a
+        // modal is up (matches the wizard pattern).
+        if (state.homeModal?.type === 'new') {
+            return react_1.default.createElement(NewEnsembleModal_1.NewEnsembleModal, {
+                onSubmit: handleHomeNewSubmit,
+                onCancel: handleHomeModalClose,
+                submitting: state.homeModalSubmitting,
+                error: state.homeModalError,
+            });
+        }
+        if (state.homeModal?.type === 'lineup') {
+            return react_1.default.createElement(LoadLineupModal_1.LoadLineupModal, {
+                onSubmit: handleHomeLineupSubmit,
+                onCancel: handleHomeModalClose,
+                submitting: state.homeModalSubmitting,
+                error: state.homeModalError,
+            });
+        }
+        if (state.homeModal?.type === 'restore') {
+            return react_1.default.createElement(RestoreConfirmModal_1.RestoreConfirmModal, {
+                ensemble: state.homeModal.ensemble,
+                playerCount: state.homeModal.playerCount,
+                conductorName: state.homeModal.conductor,
+                onConfirm: handleHomeRestoreConfirm,
+                onCancel: handleHomeModalClose,
+                submitting: state.homeModalSubmitting,
+                error: state.homeModalError,
+            });
+        }
+        // /destroy <ensemble> typed-name confirmation modal (#291)
+        if (state.confirmingEnsembleDestroy) {
+            return react_1.default.createElement(DestroyConfirmModal_1.DestroyConfirmModal, {
+                ensemble: state.confirmingEnsembleDestroy.ensemble,
+                input: state.confirmingEnsembleDestroy.input,
+                error: state.confirmingEnsembleDestroy.error,
+                submitting: state.confirmingEnsembleDestroy.submitting,
+                onInput: handleEnsembleDestroyInput,
+                onSubmit: handleEnsembleDestroySubmit,
+                onCancel: handleEnsembleDestroyCancel,
+            });
+        }
+        // Home view (#290) — renders when on the 'home' navigation and the
+        // app is past the splash connection check. The view pre-renders from
+        // the current `ensembles` snapshot and refreshes itself on a timer.
+        if (state.phase === 'main' && state.view === 'home' && state.splashConnected) {
+            return react_1.default.createElement(HomeView_1.HomeView, {
+                initial: bootstrapInitial,
+                client: api,
+                onEnterEnsemble: handleHomeEnter,
+                onCreateEnsemble: handleHomeOpenNew,
+                onLoadLineup: handleHomeOpenLineup,
+                onRestoreEnsemble: handleHomeOpenRestore,
+                onQuit: handleHomeQuit,
+            });
+        }
+        if (state.chatTarget && memoizedChatData) {
+            const targetPlayer = state.players.find(p => p.playerId === state.chatTarget);
+            return react_1.default.createElement(ChatView_1.ChatView, {
+                targetPlayer: state.chatTarget,
+                targetPart: targetPlayer?.part,
+                targetBranch: targetPlayer?.gitBranch,
+                targetStatus: targetPlayer?.phase,
+                targetHost: targetPlayer?.hostname,
+                localHost: (0, os_1.hostname)(),
+                isConductor: memoizedChatData.isConductor,
+                receivedCount: memoizedChatData.received,
+                sentCount: memoizedChatData.sent,
+                messages: memoizedChatData.messages,
+            });
+        }
+        // Status overlay — card layout with scrolling
+        if (state.statusOverlay && state.activeEnsemble) {
+            return react_1.default.createElement(StatusOverlay_1.StatusOverlay, {
+                players: state.players,
+                ensemble: state.activeEnsemble,
+                scrollOffset: state.statusScrollOffset,
+                contentHeight,
+            });
+        }
+        // Unified overlay — all overlay types rendered here
+        if (state.overlay) {
+            const ov = state.overlay;
+            const children = [];
+            children.push(react_1.default.createElement(Text, { key: 'ov-title', bold: true, color: theme_1.THEME.accent }, `  ${ov.title}`));
+            if (ov.items.length === 0) {
+                children.push('\n\n');
+                children.push(react_1.default.createElement(Text, { key: 'ov-empty', color: theme_1.THEME.dim }, '  No items.'));
+            }
+            else {
+                for (let i = 0; i < ov.items.length; i++) {
+                    const item = ov.items[i];
+                    const selected = i === ov.selectedIndex;
+                    const prefix = selected ? ' \u276F ' : '   ';
+                    children.push('\n\n');
+                    children.push(react_1.default.createElement(Text, { key: `ov-${i}`, color: selected ? theme_1.THEME.text : theme_1.THEME.dim, bold: selected }, `${prefix}${item.label}`));
+                    if (item.sublabel) {
+                        children.push('\n');
+                        children.push(react_1.default.createElement(Text, { key: `ovs-${i}`, color: theme_1.THEME.dim }, `    ${item.sublabel}`));
+                    }
+                }
+            }
+            // Pad to fill contentHeight
+            const usedLines = 1 + ov.items.reduce((n, item) => n + 2 + (item.sublabel ? 1 : 0), 0) + 2;
+            const padLines = Math.max(0, contentHeight - usedLines);
+            if (padLines > 0)
+                children.push('\n'.repeat(padLines));
+            children.push('\n');
+            children.push(react_1.default.createElement(Text, { key: 'ov-hint', color: theme_1.THEME.dim }, `  ${ov.hint}`));
+            return react_1.default.createElement(Text, null, ...children);
+        }
+        // Player detail view — shows player metadata + message history
+        if (state.view === 'player' && state.activePlayer && state.activeEnsemble) {
+            const player = state.players.find(p => p.playerId === state.activePlayer) || null;
+            return react_1.default.createElement(PlayerDetailView_1.PlayerDetailView, {
+                playerId: state.activePlayer,
+                ensemble: state.activeEnsemble,
+                player,
+                metadata: state.playerMetadata,
+                messages: state.playerMessages,
+                scrollOffset: state.playerScrollOffset,
+                localHost: (0, os_1.hostname)(),
+            });
+        }
+        // Main view — conversation stream (like Claude Code)
+        if (state.activeEnsemble) {
+            // Show loading state until first poll completes
+            if (state.conversation === null) {
+                return react_1.default.createElement(Text, { color: theme_1.THEME.dim }, '\n  \u27F3 Loading messages...');
+            }
+            return react_1.default.createElement(ConversationStream_1.ConversationStream, {
+                conversation: state.conversation,
+                sentMessages: state.sentMessages,
+                contentHeight,
+                overflowRef,
+                conductorPlayerId,
+            });
+        }
+        // No active ensemble — show ensemble list, loading state, or help
+        // Still loading ensembles
+        if (state.ensembles === null) {
+            if (ensemble) {
+                return react_1.default.createElement(Text, { color: theme_1.THEME.dim }, `\n  \u27F3 Connecting to ${ensemble}...`);
+            }
+            return react_1.default.createElement(Text, { color: theme_1.THEME.dim }, '\n  \u27F3 Discovering ensembles...');
+        }
+        if (state.ensembles.length > 0) {
+            const ensLines = [
+                react_1.default.createElement(Text, { key: 'eh', bold: true, color: theme_1.THEME.text }, `${state.ensembles.length} ensemble${state.ensembles.length !== 1 ? 's' : ''} running:`),
+            ];
+            for (const ens of state.ensembles) {
+                ensLines.push('\n');
+                ensLines.push(react_1.default.createElement(Text, { key: ens.name, color: theme_1.THEME.textMuted }, `  ${ens.name} (${ens.playerCount} player${ens.playerCount !== 1 ? 's' : ''})${ens.hasConductor ? ' \u2605' : ''}`));
+            }
+            ensLines.push('\n\n');
+            ensLines.push(react_1.default.createElement(Text, { key: 'hint', color: theme_1.THEME.dim }, '  Type /ensemble <name> to connect, or /ensemble to browse'));
+            return react_1.default.createElement(Text, null, ...ensLines);
+        }
+        // No ensembles running (single Text, 1 Yoga node)
+        return react_1.default.createElement(Text, null, '\n', react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.accent }, '  Getting Started'), '\n', '\n', react_1.default.createElement(Text, { color: theme_1.THEME.text }, '  No ensembles are running.'), '\n', '\n', react_1.default.createElement(Text, { color: theme_1.THEME.text }, '  Create an ensemble:'), '\n', react_1.default.createElement(Text, { color: theme_1.THEME.accent }, '    /ensemble → + Create new ensemble'), '\n', '\n', react_1.default.createElement(Text, { color: theme_1.THEME.text }, '  Or load a lineup:'), '\n', react_1.default.createElement(Text, { color: theme_1.THEME.accent }, '    /lineup load <file.yml>'), '\n', '\n', react_1.default.createElement(Text, { color: theme_1.THEME.dim }, '  The TUI will auto-detect ensembles as they start.'), '\n', react_1.default.createElement(Text, { color: theme_1.THEME.dim }, '  Type /help for all available commands.'));
+    }
+    // ── Notification expiry tick (#306) ──
+    // A single interval keeps the notifications stack fresh — when any
+    // notification exists, bump the tick counter every 500ms so the render
+    // pass re-evaluates `expiresAt > Date.now()` and drops expired entries
+    // from view. Auto-stops (cleared to 0) when the stack empties, avoiding
+    // a background timer when there's nothing to watch. Cheap — one integer
+    // diff per tick, and only while notifications are live.
+    (0, react_1.useEffect)(() => {
+        if (state.notifications.length === 0)
+            return undefined;
+        const id = setInterval(() => {
+            dispatch({ type: 'NOTIFICATION_TICK' });
+        }, 500);
+        return () => clearInterval(id);
+    }, [state.notifications.length]);
+    // ── Static items — rendered once to stdout, become native terminal scrollback ──
+    const { Static } = (0, ink_context_1.useInk)();
+    // Layout: header (2 lines) + content (variable) + footer (dynamic)
+    // Content height is calculated to guarantee footer is always visible.
+    // When command palette is visible, footer grows to accommodate palette items.
+    const paletteLines = (state.paletteVisible && filteredPaletteCommands.length > 0)
+        ? Math.min(filteredPaletteCommands.length, 6) + (filteredPaletteCommands.length > 6 ? 2 : 0) // items + scroll indicators
+        : 0;
+    // #306: Notifications stack lives below the palette. Each live notification
+    // takes one line; when the stack is empty, this contributes zero to the
+    // footer so the main content area gets the full terminal height back.
+    const now = Date.now();
+    const notificationLines = state.notifications.filter(n => n.expiresAt > now).length;
+    // Pinned confirmation lines — persist exactly as long as the state does,
+    // no TTL. Each active confirmation state contributes one line above the
+    // notifications stack. Keeps the y/N prompt anchored below the input so
+    // it can't scroll away under new messages.
+    const confirmationLines = countPinnedConfirmationLines(state);
+    // #306 follow-up: Pinned paused/held tip — 1 row when an ensemble is
+    // paused or held (or both), 0 otherwise. Same accounting pattern as
+    // confirmationLines so the live content area reclaims the row when the
+    // tip auto-clears on state change.
+    const tipLines = countPinnedTipLines(state);
+    // #306: Hide the chat prompt on the home view. Home is a wizard/picker
+    // (arrow keys + Enter), not a chat target — there is no ensemble to talk
+    // to, and a visible input box double-fires Enter (HomeView's own useInput
+    // selects the row, PromptArea's useInput submits the empty buffer). The
+    // Splash phase already follows this pattern; home now mirrors it. When
+    // hidden we drop 2 lines from FOOTER_LINES (PromptArea row + the second
+    // divider) so the live content area reclaims that space.
+    const hidePrompt = isHomeView(state);
+    const promptFooterLines = hidePrompt ? 0 : 2; // PromptArea + bottom divider
+    const FOOTER_LINES = 2 + promptFooterLines + paletteLines + confirmationLines + tipLines + notificationLines; // StatusBar + divider + (PromptArea + bottom divider when shown) + palette + pinned confirmations + paused/held tip + notifications
+    const contentHeight = Math.max(3, termRows - 1 - FOOTER_LINES);
+    // Splash phase — full screen, no chrome (title/status/prompt hidden)
+    if (state.phase === 'splash') {
+        return react_1.default.createElement(Box, { flexDirection: 'column', height: termRows - 1, overflow: 'hidden' }, renderLiveContent());
+    }
+    // Root layout: <Static> items above, then live area constrained to terminal height
+    return react_1.default.createElement(react_1.default.Fragment, null, 
+    // Static items — rendered once to stdout, become native terminal scrollback
+    react_1.default.createElement(Static, { items: state.staticItems, children: (item) => {
+            // Rich rendering for messages — header + indented body (matches live ConversationStream)
+            if (item.type === 'message' && item.msgDirection) {
+                const cols = process.stdout.columns || 80;
+                const bodyWidth = Math.max(20, cols - 4);
+                const wrapped = (0, format_2.wordWrap)(item.content, bodyWidth);
+                if (item.msgDirection === 'out') {
+                    // Outbound: ♩ first line, then indented continuation (matches live)
+                    const firstLine = wrapped[0] || '';
+                    const pad = ' '.repeat(Math.max(0, cols - 2 - 3 - firstLine.length));
+                    const contLines = wrapped.slice(1).map(l => `   ${l}`.padEnd(cols - 2)).join('\n');
+                    const children = [
+                        react_1.default.createElement(Text, { backgroundColor: theme_1.THEME.inputBg, color: theme_1.THEME.accent, bold: true }, ' \u2669 '),
+                        react_1.default.createElement(Text, { backgroundColor: theme_1.THEME.inputBg, color: theme_1.THEME.text }, firstLine),
+                        react_1.default.createElement(Text, { backgroundColor: theme_1.THEME.inputBg, color: theme_1.THEME.dim }, pad),
+                    ];
+                    if (contLines) {
+                        children.push('\n');
+                        children.push(react_1.default.createElement(Text, { backgroundColor: theme_1.THEME.inputBg, color: theme_1.THEME.text }, contLines));
+                    }
+                    return react_1.default.createElement(Text, { key: item.id }, ...children);
+                }
+                else {
+                    // Inbound: header + 3-space indent body
+                    const isThirdParty = item.msgThirdParty;
+                    const headerLabel = item.msgRouteLabel || item.msgSender || '';
+                    const headerPrefix = isThirdParty ? '   ' : ' \u2190 ';
+                    const headerColor = isThirdParty ? theme_1.THEME.dim : theme_1.THEME.accent;
+                    const bodyColor = isThirdParty ? theme_1.THEME.textMuted : theme_1.THEME.text;
+                    const bodyLines = wrapped.map(l => `   ${l}`).join('\n');
+                    return react_1.default.createElement(Text, { key: item.id }, react_1.default.createElement(Text, { color: theme_1.THEME.dim }, headerPrefix), react_1.default.createElement(Text, { color: headerColor }, headerLabel), react_1.default.createElement(Text, { color: theme_1.THEME.dim }, `  ${item.msgTime || ''}`), '\n', react_1.default.createElement(Text, { color: bodyColor }, bodyLines));
+                }
+            }
+            // Fallback for non-message items
+            return react_1.default.createElement(Text, { key: item.id, color: staticItemColor(item) }, `  ${item.content}`);
+        } }), 
+    // Live area — height constrained to termRows-1
+    react_1.default.createElement(Box, { flexDirection: 'column', height: termRows - 1, overflow: 'hidden' }, 
+    // Content area — full height above footer
+    react_1.default.createElement(Box, { flexDirection: 'column', height: contentHeight, overflow: 'hidden' }, 
+    // Live content area
+    renderLiveContent()), 
+    // ── Footer (fixed height, always visible) ──
+    // Status bar (1 Text node)
+    react_1.default.createElement(StatusBar_1.StatusBar, {
+        ensemble: state.activeEnsemble,
+        players: state.players,
+        playersLoaded: state.playersLoaded,
+        scheduleCount: state.schedules.length,
+        connected: true,
+        ensemblePaused: state.ensemblePaused,
+        ensembleHeld: state.ensembleHeld,
+    }), 
+    // Bottom divider (1 Text node, no Box wrapper)
+    react_1.default.createElement(Text, { color: theme_1.THEME.border }, ` ${dividerLine} `), 
+    // Prompt area + bottom divider — hidden on the home view (#306).
+    // Home is a picker, not a chat target; the input would either eat keys
+    // or double-fire Enter against HomeView's own useInput. Mirrors the
+    // Splash phase, which renders no prompt at all.
+    hidePrompt
+        ? null
+        : react_1.default.createElement(PromptArea_1.PromptArea, {
+            hints: promptHints,
+            onSubmit: handleSubmit,
+            disabled: (state.phase !== 'main' && state.phase !== 'chat') || !!state.confirmingStop || !!state.confirmingDisband || !!state.confirmingEnsembleDestroy || !!state.confirmingLineup || state.pickerVisible || state.statusOverlay || !!state.overlay,
+            commandNames: commandNamesList,
+            playerNames: playerNamesList,
+            initialHistory: cmdHistory,
+            onHistoryUpdate: handleHistoryUpdate,
+            onInputChange: handleInputChange,
+            paletteVisible: state.paletteVisible,
+            onPaletteToggle: handlePaletteToggle,
+            onPaletteUp: handlePaletteUp,
+            onPaletteDown: handlePaletteDown,
+            onPaletteSelect: handlePaletteSelect,
+            inputRef: promptRef,
+        }), 
+    // Bottom divider (1 Text node) — also hidden when the prompt is hidden
+    // so the footer accounting in FOOTER_LINES stays consistent.
+    hidePrompt
+        ? null
+        : react_1.default.createElement(Text, { color: theme_1.THEME.border }, ` ${dividerLine} `), 
+    // Command palette (1 Text node when visible)
+    state.paletteVisible && filteredPaletteCommands.length > 0
+        ? react_1.default.createElement(CommandPalette_1.CommandPalette, {
+            commands: filteredPaletteCommands,
+            selectedIndex: clampedPaletteIndex,
+            // Display prefix mirrors what the user's input would become on select.
+            prefix: paletteCtx?.replacePrefix ?? '/',
+        })
+        : null, 
+    // Pinned confirmation prompts — sit directly below the prompt area,
+    // above the notifications stack. Unlike notifications, these have no
+    // TTL and persist exactly as long as the corresponding `confirming*`
+    // state field is set. Keeps the y/N (or typed-name) prompt visible
+    // even when new chat messages are flooding the scroll-up history.
+    renderPinnedConfirmations(state, Box, Text), 
+    // #306 follow-up: paused/held informational tip. Dim color so it
+    // sits behind the warning-yellow confirmations and red-error
+    // notifications visually. Auto-clears on state change.
+    renderPinnedTip(state, Box, Text), 
+    // #306: Bottom-pinned notifications — errors/warnings stay visible below
+    // the prompt until they TTL out (8s for errors, 5s otherwise) or the user
+    // hits Esc. Filters by `expiresAt` every render; the notificationTick
+    // counter forces periodic re-renders while entries are live.
+    renderNotifications(state.notifications, Box, Text))); // closes Fragment
+}
+/**
+ * #306: Render the bottom-pinned notification stack. Kept as a free function
+ * (not a component) so the caller composes Ink primitives directly — the
+ * App's render tree is already heavy with createElement calls, and a
+ * dedicated component for 10 lines of JSX would add a layout boundary for
+ * no gain.
+ */
+function renderNotifications(notifications, Box, Text) {
+    const now = Date.now();
+    const live = notifications.filter(n => n.expiresAt > now);
+    if (live.length === 0)
+        return null;
+    return react_1.default.createElement(Box, { flexDirection: 'column', paddingLeft: 1, paddingRight: 1 }, ...live.map(n => {
+        const icon = n.kind === 'error' ? '✗'
+            : n.kind === 'warn' ? '⚠'
+                : 'ⓘ';
+        const color = n.kind === 'error' ? theme_1.THEME.error
+            : n.kind === 'warn' ? theme_1.THEME.warning
+                : theme_1.THEME.accent;
+        return react_1.default.createElement(Text, { key: `notif-${n.id}`, color }, `${icon}  ${stripLeadingIcon(n.content)}`);
+    }));
+}
+/**
+ * #306: Strip a leading kind-icon (`✗ `, `⚠ `, `ⓘ `) from notification
+ * content. Defensive: many call sites historically prepended the icon into
+ * the message string, and the renderer also prepends a kind-based icon —
+ * without this normalization the user sees the icon twice (e.g.
+ * `✗ ✗ Cannot destroy the conductor …`). Exported for unit testing.
+ */
+function stripLeadingIcon(content) {
+    return content.replace(/^[✗⚠ⓘ]\s+/u, '');
+}
+/**
+ * #306: True when the TUI is on the home picker view — `phase === 'main'`
+ * AND `view === 'home'`. The chat input has no target on this view (the
+ * ensemble has not been entered yet), and HomeView owns Enter to navigate
+ * its own row list. Render guard for PromptArea + the second divider so
+ * the input cannot double-fire alongside HomeView's own `useInput`.
+ *
+ * Pure function, exported so tests can pin the guard's logic without
+ * standing up an Ink render. Mirrors the splash-phase bypass pattern.
+ */
+function isHomeView(state) {
+    return state.phase === 'main' && state.view === 'home';
+}
+/**
+ * #306: Build the pinned-confirmation line(s) for the current state. Returns
+ * an array (possibly empty) of `{ key, text }` entries — one per active
+ * `confirming*` state field. Rendered above the notifications stack by
+ * `renderPinnedConfirmations` and sized by `countPinnedConfirmationLines`
+ * so `FOOTER_LINES` reserves terminal rows correctly.
+ *
+ * Pure function, exported for unit testing — no Ink imports, no dispatch.
+ * The render helper below is the only caller that wraps these in Text nodes.
+ */
+function pinnedConfirmationLines(state) {
+    const out = [];
+    if (state.confirmingStop) {
+        const reason = state.confirmingStopReason ? ` Reason: ${state.confirmingStopReason}.` : '';
+        out.push({
+            key: 'confirm-stop',
+            text: `⚠  Destroy ${state.confirmingStop}? Press y to confirm, n to cancel.${reason}`,
+        });
+    }
+    if (state.confirmingDisband) {
+        out.push({
+            key: 'confirm-disband',
+            text: `⚠  Disband ensemble "${state.confirmingDisband}"? All sessions will be terminated. Press y to confirm, n to cancel.`,
+        });
+    }
+    if (state.confirmingEnsembleDestroy) {
+        // Typed-name gate — the detailed input UX lives in the full-screen
+        // modal; this pinned reminder mirrors the modal's question so the
+        // bottom of the screen still answers "what am I being asked?" at a
+        // glance. Shown even while the modal is up for layout consistency
+        // with the other confirmation states.
+        out.push({
+            key: 'confirm-ensemble-destroy',
+            text: `⚠  Destroy ensemble "${state.confirmingEnsembleDestroy.ensemble}"? Type the ensemble name to confirm, Esc to cancel.`,
+        });
+    }
+    if (state.confirmingLineup) {
+        out.push({
+            key: 'confirm-lineup',
+            text: `⚠  ${state.confirmingLineup.summary}? Press y to confirm, n to cancel.`,
+        });
+    }
+    return out;
+}
+/**
+ * #306: Count of pinned confirmation lines — one per active `confirming*`
+ * state field. Consumed by the `FOOTER_LINES` reservation so the live
+ * content area shrinks when a confirmation is active, keeping the pinned
+ * prompt on-screen.
+ */
+function countPinnedConfirmationLines(state) {
+    return pinnedConfirmationLines(state).length;
+}
+/**
+ * #306 follow-up: Build the pinned tip line for the current paused/held
+ * state. Returns `null` when neither flag is set — no tip should render.
+ *
+ * The tip appears below the input prompt in a dim color (informational,
+ * not an error or warning) and tells the user which slash commands they
+ * need to fully resume the ensemble. `/load_lineup` flips both flags;
+ * `/play` clears only paused; `/go` clears only held — without this
+ * tip users would unpause an ensemble and stare at frozen players.
+ *
+ * Pure function, exported for unit testing — no Ink imports.
+ */
+function pinnedTipLine(state) {
+    // Hide tips on the home view — there's no ensemble context to act on,
+    // and the prompt itself is hidden there too (see `hidePrompt` in App).
+    if (!state.activeEnsemble)
+        return null;
+    if (state.ensemblePaused && state.ensembleHeld) {
+        return {
+            key: 'tip-paused-held',
+            text: 'Tip: Type /play to unpause + /go to release held players.',
+        };
+    }
+    if (state.ensemblePaused) {
+        return { key: 'tip-paused', text: 'Tip: Type /play to resume.' };
+    }
+    if (state.ensembleHeld) {
+        return { key: 'tip-held', text: 'Tip: Type /go to release held players.' };
+    }
+    return null;
+}
+/**
+ * Count of pinned tip lines (0 or 1). Mirrors
+ * {@link countPinnedConfirmationLines} so `FOOTER_LINES` can reserve a
+ * row for the tip without re-evaluating the state shape twice.
+ */
+function countPinnedTipLines(state) {
+    return pinnedTipLine(state) ? 1 : 0;
+}
+/**
+ * #306: Render the pinned confirmation prompts as Ink Text nodes. Kept
+ * free-function (mirroring `renderNotifications`) because the App's root
+ * render tree is already `createElement`-heavy and a dedicated component
+ * would add a layout boundary for zero gain. Uses THEME.warning so the
+ * user's eye is drawn away from the chat scroll-up area.
+ */
+function renderPinnedConfirmations(state, Box, Text) {
+    const lines = pinnedConfirmationLines(state);
+    if (lines.length === 0)
+        return null;
+    return react_1.default.createElement(Box, { flexDirection: 'column', paddingLeft: 1, paddingRight: 1 }, ...lines.map(line => react_1.default.createElement(Text, { key: line.key, color: theme_1.THEME.warning, bold: true }, line.text)));
+}
+/**
+ * #306 follow-up: Render the pinned paused/held tip below the input. Dim
+ * (THEME.dim) so it reads as informational and doesn't compete visually
+ * with the yellow confirmation prompts above or red notifications below.
+ * Auto-clears when the state changes — no user dismissal needed.
+ */
+function renderPinnedTip(state, Box, Text) {
+    const tip = pinnedTipLine(state);
+    if (!tip)
+        return null;
+    return react_1.default.createElement(Box, { flexDirection: 'column', paddingLeft: 1, paddingRight: 1 }, react_1.default.createElement(Text, { key: tip.key, color: theme_1.THEME.dim }, tip.text));
+}