agent-tempo 1.0.1

package/dist/tui/components/PromptArea.d.ts

@@ -0,0 +1,50 @@
+/**
+ * PromptArea — pinned bottom input area with tab completion and command history.
+ *
+ * UNCONTROLLED: Input value lives in local useState, NOT in parent state.
+ * This prevents parent re-renders on every keystroke, keeping Yoga node
+ * recalculation to this subtree only (~4 nodes).
+ *
+ * Parent communicates via:
+ * - inputRef.current.setValue(v) — to set input programmatically (palette select)
+ * - inputRef.current.getValue() — to read current value
+ * - onInputChange(v) — called on every keystroke (for palette filtering via ref, no dispatch)
+ * - onSubmit(v) — called on Enter
+ */
+import React from 'react';
+/** Commands that take a player name as their first argument. */
+export interface PromptAreaHandle {
+    setValue: (v: string) => void;
+    getValue: () => string;
+}
+export interface PromptAreaProps {
+    /** Hint text displayed above the input. */
+    hints: string;
+    /** Called when user presses Enter. */
+    onSubmit: (value: string) => void;
+    /** Disable input (e.g., during splash or recruit wizard). */
+    disabled?: boolean;
+    /** Available command names (without '/') for tab completion. */
+    commandNames?: string[];
+    /** Available player names for argument completion. */
+    playerNames?: string[];
+    /** Initial command history (loaded from disk). */
+    initialHistory?: string[];
+    /** Called when history is updated (for persistence). */
+    onHistoryUpdate?: (entries: string[]) => void;
+    /** Called on every input change (lightweight — caller should use ref, not dispatch). */
+    onInputChange?: (value: string) => void;
+    /** Whether the command palette is visible. */
+    paletteVisible?: boolean;
+    /** Called when palette should show/hide. */
+    onPaletteToggle?: (visible: boolean) => void;
+    /** Called to navigate palette up. */
+    onPaletteUp?: () => void;
+    /** Called to navigate palette down. */
+    onPaletteDown?: () => void;
+    /** Called when palette item is selected. */
+    onPaletteSelect?: () => void;
+    /** Ref for parent to read/set input value. */
+    inputRef?: React.Ref<PromptAreaHandle>;
+}
+export declare const PromptArea: React.NamedExoticComponent<PromptAreaProps>;

package/dist/tui/components/PromptArea.js

@@ -0,0 +1,303 @@
+"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.PromptArea = void 0;
+/**
+ * PromptArea — pinned bottom input area with tab completion and command history.
+ *
+ * UNCONTROLLED: Input value lives in local useState, NOT in parent state.
+ * This prevents parent re-renders on every keystroke, keeping Yoga node
+ * recalculation to this subtree only (~4 nodes).
+ *
+ * Parent communicates via:
+ * - inputRef.current.setValue(v) — to set input programmatically (palette select)
+ * - inputRef.current.getValue() — to read current value
+ * - onInputChange(v) — called on every keystroke (for palette filtering via ref, no dispatch)
+ * - onSubmit(v) — called on Enter
+ */
+const react_1 = __importStar(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+const commands_1 = require("../commands");
+const MAX_HISTORY = 50;
+exports.PromptArea = react_1.default.memo(function PromptArea({ hints, onSubmit, disabled, commandNames = [], playerNames = [], initialHistory = [], onHistoryUpdate, onInputChange, paletteVisible, onPaletteToggle, onPaletteUp, onPaletteDown, onPaletteSelect, inputRef, }) {
+    const { Box, Text, useInput } = (0, ink_context_1.useInk)();
+    // ── LOCAL input state (uncontrolled — no parent dispatch per keystroke) ──
+    const [value, setValueState] = (0, react_1.useState)('');
+    const valueRef = (0, react_1.useRef)('');
+    const setValue = (0, react_1.useCallback)((v) => {
+        valueRef.current = v;
+        ref.current.value = v; // Keep ref in sync between renders (prevents stale reads on rapid input)
+        setValueState(v);
+    }, []);
+    // ── Expose handle for parent ──
+    (0, react_1.useImperativeHandle)(inputRef, () => ({
+        setValue: (v) => setValue(v),
+        getValue: () => valueRef.current,
+    }), [setValue]);
+    // ── Internal state ──
+    const [history, setHistory] = (0, react_1.useState)(() => [...initialHistory]);
+    const [historyIndex, setHistoryIndex] = (0, react_1.useState)(-1);
+    const savedInput = (0, react_1.useRef)('');
+    const [completionHint, setCompletionHint] = (0, react_1.useState)('');
+    const [tabMatches, setTabMatches] = (0, react_1.useState)([]);
+    const [tabCycleIndex, setTabCycleIndex] = (0, react_1.useState)(0);
+    // ── Ref for all values the useInput callback reads (stable callback pattern) ──
+    const ref = (0, react_1.useRef)({
+        value: '', onSubmit, disabled, commandNames, playerNames,
+        history, historyIndex, tabMatches, tabCycleIndex,
+        paletteVisible, onPaletteToggle, onPaletteUp, onPaletteDown, onPaletteSelect,
+        onHistoryUpdate, onInputChange,
+    });
+    ref.current = {
+        value: valueRef.current, onSubmit, disabled, commandNames, playerNames,
+        history, historyIndex, tabMatches, tabCycleIndex,
+        paletteVisible, onPaletteToggle, onPaletteUp, onPaletteDown, onPaletteSelect,
+        onHistoryUpdate, onInputChange,
+    };
+    // ── Helpers (read from ref) ──
+    const doChange = (0, react_1.useCallback)((newValue) => {
+        const r = ref.current;
+        setValue(newValue);
+        r.onInputChange?.(newValue);
+        // Avoid new refs when already in default state — prevents unnecessary re-renders
+        setCompletionHint(prev => prev === '' ? prev : '');
+        setTabMatches(prev => prev.length === 0 ? prev : []);
+        setTabCycleIndex(prev => prev === 0 ? prev : 0);
+        // Only toggle palette when visibility actually changes — avoids parent dispatch on every keystroke
+        if (r.onPaletteToggle) {
+            // The palette shows for: "/cmd", "@name", and "/PLAYER_PARAM_CMD <partial>".
+            // classifyPaletteInput centralizes the rule so PromptArea + App stay in sync.
+            const shouldShow = (0, commands_1.classifyPaletteInput)(newValue) !== null;
+            if (shouldShow !== !!r.paletteVisible) {
+                r.onPaletteToggle(shouldShow);
+            }
+        }
+    }, [setValue]);
+    // PLAYER_PARAM_COMMANDS and SUBCOMMAND_MAP imported from commands.ts
+    const getCompletions = (0, react_1.useCallback)((input) => {
+        const r = ref.current;
+        const trimmed = input.trimStart();
+        // Command name completion: /par → /players
+        if (trimmed.startsWith('/') && !trimmed.includes(' ')) {
+            const partial = trimmed.slice(1).toLowerCase();
+            if (!partial)
+                return r.commandNames.map(c => `/${c} `);
+            return r.commandNames
+                .filter(c => c.startsWith(partial) && c !== partial)
+                .map(c => `/${c} `);
+        }
+        // Parameter completion: /stop te → /stop tempo-eng
+        if (trimmed.startsWith('/') && trimmed.includes(' ')) {
+            const spaceIdx = trimmed.indexOf(' ');
+            const cmd = trimmed.slice(1, spaceIdx).toLowerCase();
+            const afterCmd = trimmed.slice(spaceIdx + 1);
+            const parts = afterCmd.split(' ');
+            const partial = parts[parts.length - 1].toLowerCase();
+            const prefix = trimmed.slice(0, trimmed.length - parts[parts.length - 1].length);
+            // First param: player name for player commands (prefix + segment match)
+            if (parts.length === 1 && commands_1.PLAYER_PARAM_COMMANDS.has(cmd)) {
+                const names = r.playerNames || [];
+                const matches = names.filter(n => {
+                    const lower = n.toLowerCase();
+                    if (lower === partial)
+                        return false;
+                    return lower.startsWith(partial) || lower.split('-').some(seg => seg.startsWith(partial));
+                });
+                if (matches.length > 0)
+                    return matches.map(n => `${prefix}${n} `);
+            }
+            // First param: subcommand for structured commands
+            if (parts.length === 1 && commands_1.SUBCOMMAND_MAP[cmd]) {
+                const subs = commands_1.SUBCOMMAND_MAP[cmd];
+                const matches = subs.filter(s => s.startsWith(partial) && s !== partial);
+                if (matches.length > 0)
+                    return matches.map(s => `${prefix}${s} `);
+            }
+            // Second param after subcommand: player name for worktree create/remove
+            if (parts.length === 2 && cmd === 'worktree' && (parts[0] === 'create' || parts[0] === 'remove')) {
+                const names = r.playerNames || [];
+                const matches = names.filter(n => n.toLowerCase().startsWith(partial) && n.toLowerCase() !== partial);
+                if (matches.length > 0)
+                    return matches.map(n => `${prefix}${n} `);
+            }
+            return [];
+        }
+        // @player completion: @tem → @tempo-eng
+        if (trimmed.startsWith('@') && !trimmed.includes(' ')) {
+            const partial = trimmed.slice(1).toLowerCase();
+            if (!partial)
+                return r.playerNames.map(n => `@${n} `);
+            return r.playerNames
+                .filter(n => {
+                const lower = n.toLowerCase();
+                if (lower === partial)
+                    return false;
+                return lower.startsWith(partial) || lower.split('-').some(seg => seg.startsWith(partial));
+            })
+                .map(n => `@${n} `);
+        }
+        return [];
+    }, []);
+    // ── Stable useInput callback (never recreated) ──
+    useInput((0, react_1.useCallback)((input, key) => {
+        const r = ref.current;
+        if (r.disabled)
+            return;
+        // ── Command palette mode ──
+        if (r.paletteVisible) {
+            if (key.upArrow) {
+                r.onPaletteUp?.();
+                return;
+            }
+            if (key.downArrow) {
+                r.onPaletteDown?.();
+                return;
+            }
+            if (key.tab) {
+                r.onPaletteSelect?.();
+                return;
+            }
+            if (key.return) {
+                // Enter always submits. Use Tab to accept a palette suggestion. This
+                // avoids accept-vs-submit ambiguity when the typed command already
+                // matches exactly but the palette has no remaining suggestions
+                // (e.g. "/destroy conductor"). Close the palette and fall through to
+                // the regular Enter/submit block below.
+                r.onPaletteToggle?.(false);
+            }
+            if (key.escape) {
+                r.onPaletteToggle?.(false);
+                return;
+            }
+        }
+        // Tab: complete
+        if (key.tab) {
+            const matches = r.tabMatches.length > 0 ? r.tabMatches : getCompletions(r.value);
+            if (matches.length === 0)
+                return;
+            if (matches.length === 1) {
+                setValue(matches[0]);
+                r.onInputChange?.(matches[0]);
+                setCompletionHint('');
+                setTabMatches([]);
+                setTabCycleIndex(0);
+            }
+            else {
+                const newMatches = r.tabMatches.length > 0 ? r.tabMatches : matches;
+                const idx = r.tabMatches.length > 0 ? (r.tabCycleIndex + 1) % newMatches.length : 0;
+                setValue(newMatches[idx]);
+                r.onInputChange?.(newMatches[idx]);
+                setTabMatches(newMatches);
+                setTabCycleIndex(idx);
+                const options = newMatches.map(m => m.trim().split(/\s+/).pop() || '');
+                setCompletionHint(options.join('  '));
+            }
+            return;
+        }
+        // Up arrow: previous history
+        if (key.upArrow && !r.paletteVisible) {
+            if (r.history.length === 0)
+                return;
+            if (r.historyIndex === -1)
+                savedInput.current = r.value;
+            const newIdx = Math.min(r.historyIndex + 1, r.history.length - 1);
+            setHistoryIndex(newIdx);
+            const histValue = r.history[r.history.length - 1 - newIdx];
+            setValue(histValue);
+            r.onInputChange?.(histValue);
+            setCompletionHint('');
+            setTabMatches([]);
+            return;
+        }
+        // Down arrow: next history
+        if (key.downArrow && !r.paletteVisible) {
+            if (r.historyIndex <= 0) {
+                setHistoryIndex(-1);
+                setValue(savedInput.current);
+                r.onInputChange?.(savedInput.current);
+                return;
+            }
+            const newIdx = r.historyIndex - 1;
+            setHistoryIndex(newIdx);
+            const histValue = r.history[r.history.length - 1 - newIdx];
+            setValue(histValue);
+            r.onInputChange?.(histValue);
+            setCompletionHint('');
+            setTabMatches([]);
+            return;
+        }
+        // Enter: submit
+        if (key.return) {
+            const trimmed = r.value.trim();
+            if (trimmed) {
+                if (r.history.length === 0 || r.history[r.history.length - 1] !== trimmed) {
+                    const updated = [...r.history, trimmed].slice(-MAX_HISTORY);
+                    setHistory(updated);
+                    if (r.onHistoryUpdate)
+                        r.onHistoryUpdate(updated);
+                }
+                setHistoryIndex(-1);
+                savedInput.current = '';
+                r.onSubmit(trimmed);
+            }
+            setValue('');
+            r.onInputChange?.('');
+            setCompletionHint('');
+            setTabMatches([]);
+            return;
+        }
+        // Backspace
+        if (key.backspace || key.delete) {
+            if (r.value.length > 0)
+                doChange(r.value.slice(0, -1));
+            return;
+        }
+        // Regular character input
+        if (input && !key.ctrl && !key.meta) {
+            doChange(r.value + input);
+        }
+    }, [doChange, getCompletions, setValue])); // Stable — reads ref.current
+    // ── Render (minimal nodes: 1 Box + 2-3 Text, nested Text = 0 Yoga nodes) ──
+    return react_1.default.createElement(Box, { flexDirection: 'column', paddingX: 1 }, completionHint
+        ? react_1.default.createElement(Text, { color: theme_1.THEME.muted }, `  ${completionHint}`)
+        : null, 
+    // Prompt line with inline placeholder hint (like Claude Code)
+    react_1.default.createElement(Text, null, react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.accent }, '\u2669 '), disabled
+        ? react_1.default.createElement(Text, { color: theme_1.THEME.muted }, '...')
+        : value
+            ? react_1.default.createElement(react_1.default.Fragment, null, react_1.default.createElement(Text, { color: theme_1.THEME.text }, value), react_1.default.createElement(Text, { color: theme_1.THEME.accent }, '\u2588'))
+            : react_1.default.createElement(react_1.default.Fragment, null, react_1.default.createElement(Text, { color: theme_1.THEME.accent }, '\u2588'), react_1.default.createElement(Text, { color: theme_1.THEME.dim }, hints))));
+});

package/dist/tui/components/RecruitWizard.d.ts

@@ -0,0 +1,17 @@
+/**
+ * RecruitWizard — step-by-step wizard for spawning a new player session.
+ *
+ * Minimal-Box pattern: single <Text> root for all static content (0 Yoga nodes),
+ * with ONE <Box> wrapper for Ink's TextInput when a text-input step is active.
+ */
+import React from 'react';
+import type { RecruitState, RecruitAnswers } from '../store';
+export interface RecruitWizardProps {
+    state: RecruitState;
+    onAnswer: (answer: Partial<RecruitAnswers>) => void;
+    onBack: () => void;
+    onConfirm: () => void;
+    onCancel: () => void;
+    onDone: () => void;
+}
+export declare function RecruitWizard({ state, onAnswer, onBack, onConfirm, onCancel, onDone }: RecruitWizardProps): React.FunctionComponentElement<React.FragmentProps> | React.CElement<{}, React.Component<{}, any, any>>;

package/dist/tui/components/RecruitWizard.js

@@ -0,0 +1,221 @@
+"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.RecruitWizard = RecruitWizard;
+/**
+ * RecruitWizard — step-by-step wizard for spawning a new player session.
+ *
+ * Minimal-Box pattern: single <Text> root for all static content (0 Yoga nodes),
+ * with ONE <Box> wrapper for Ink's TextInput when a text-input step is active.
+ */
+const react_1 = __importStar(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+/** Step labels for display. */
+const STEP_LABELS = {
+    name: 'Player name',
+    agent: 'Agent',
+    type: 'Player type',
+    workDir: 'Working directory',
+    message: 'Initial message (optional)',
+    host: 'Host',
+    confirm: 'Confirm',
+    done: 'Done',
+};
+const TEXT_INPUT_STEPS = new Set(['name', 'type', 'workDir', 'message', 'host']);
+function RecruitWizard({ state, onAnswer, onBack, onConfirm, onCancel, onDone }) {
+    const { Box, Text, TextInput, useInput } = (0, ink_context_1.useInk)();
+    const [inputValue, setInputValue] = (0, react_1.useState)('');
+    const [agentIndex, setAgentIndex] = (0, react_1.useState)(state.answers.agent === 'copilot' ? 1 : 0);
+    const agents = ['claude', 'copilot'];
+    // Global keybindings for wizard
+    useInput((0, react_1.useCallback)((input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.backspace && state.step !== 'name' && state.step !== 'done' && !inputValue) {
+            onBack();
+            return;
+        }
+        if (state.step === 'agent') {
+            if (key.leftArrow || key.rightArrow) {
+                setAgentIndex(i => i === 0 ? 1 : 0);
+            }
+            if (key.return) {
+                onAnswer({ agent: agents[agentIndex] });
+                setInputValue('');
+            }
+        }
+        if (state.step === 'confirm') {
+            if (key.return)
+                onConfirm();
+        }
+        if (state.step === 'done') {
+            if (key.return)
+                onDone();
+        }
+    }, [state.step, agentIndex, inputValue, onAnswer, onBack, onCancel, onConfirm, onDone]));
+    // Text input submit for text steps
+    const handleTextSubmit = (0, react_1.useCallback)((value) => {
+        const trimmed = value.trim();
+        switch (state.step) {
+            case 'name':
+                if (!trimmed)
+                    return;
+                onAnswer({ name: trimmed });
+                break;
+            case 'type':
+                onAnswer({ playerType: trimmed });
+                break;
+            case 'workDir':
+                onAnswer({ workDir: trimmed || state.answers.workDir });
+                break;
+            case 'message':
+                onAnswer({ initialMessage: trimmed });
+                break;
+            case 'host':
+                onAnswer({ host: trimmed || 'localhost' });
+                break;
+        }
+        setInputValue('');
+    }, [state.step, state.answers.workDir, onAnswer]);
+    // ── Build all content as nested Text children ──
+    const children = [];
+    // Header
+    children.push(react_1.default.createElement(react_1.default.Fragment, { key: 'hdr' }, react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.accent }, ' Recruit New Player'), react_1.default.createElement(Text, { color: theme_1.THEME.dim }, '  (Esc to cancel, Backspace to go back)')));
+    // Completed steps
+    const steps = ['name', 'agent', 'type', 'workDir', 'message', 'host'];
+    for (const s of steps) {
+        if (s === state.step)
+            break;
+        const value = getAnswerDisplay(s, state.answers);
+        children.push('\n');
+        children.push(react_1.default.createElement(react_1.default.Fragment, { key: `done-${s}` }, react_1.default.createElement(Text, { color: theme_1.THEME.success }, ' \u2714 '), react_1.default.createElement(Text, { color: theme_1.THEME.dim }, `${STEP_LABELS[s]}: `), react_1.default.createElement(Text, { color: theme_1.THEME.text }, value)));
+    }
+    // Current step content
+    if (state.step === 'agent') {
+        children.push('\n\n');
+        children.push(react_1.default.createElement(react_1.default.Fragment, { key: 'agent-q' }, react_1.default.createElement(Text, { color: theme_1.THEME.accent }, ' ? '), react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.text }, `${STEP_LABELS.agent}:`)));
+        children.push('\n');
+        for (let i = 0; i < agents.length; i++) {
+            const selected = i === agentIndex;
+            const icon = selected ? '\u25CF' : '\u25CB';
+            children.push(react_1.default.createElement(Text, { key: `ag-${agents[i]}`, color: selected ? theme_1.THEME.accent : theme_1.THEME.dim, bold: selected }, `    ${icon} ${agents[i]}  `));
+        }
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'ag-hint', color: theme_1.THEME.dim }, '   \u2190\u2192 to select, Enter to confirm'));
+    }
+    else if (state.step === 'confirm') {
+        const a = state.answers;
+        children.push('\n\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-h', bold: true, color: theme_1.THEME.accent }, '   Recruit Summary:'));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-n', color: theme_1.THEME.text }, `     Name:      ${a.name}`));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-a', color: theme_1.THEME.text }, `     Agent:     ${a.agent}`));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-t', color: theme_1.THEME.text }, `     Type:      ${a.playerType || '(default)'}`));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-d', color: theme_1.THEME.text }, `     Directory: ${a.workDir}`));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-m', color: theme_1.THEME.text }, `     Message:   ${a.initialMessage || '(none)'}`));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-h2', color: theme_1.THEME.text }, `     Host:      ${a.host}`));
+        children.push('\n\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-hint', color: theme_1.THEME.dim }, '   Press Enter to recruit, Esc to cancel'));
+    }
+    else if (state.step === 'done') {
+        children.push('\n\n');
+        if (state.error) {
+            children.push(react_1.default.createElement(Text, { key: 'err', color: theme_1.THEME.error, bold: true }, `   \u2717 Recruit failed: ${state.error}`));
+            children.push('\n');
+            children.push(react_1.default.createElement(Text, { key: 'err-h', color: theme_1.THEME.dim }, '   Press Enter to return'));
+        }
+        else {
+            children.push(react_1.default.createElement(Text, { key: 'ok1', color: theme_1.THEME.success }, '   \u2714 Workflow created'));
+            children.push('\n');
+            children.push(react_1.default.createElement(Text, { key: 'ok2', color: theme_1.THEME.success }, '   \u2714 Initial message queued'));
+            children.push('\n');
+            children.push(react_1.default.createElement(Text, { key: 'ok3', color: theme_1.THEME.success }, '   \u2714 Process spawned'));
+            children.push('\n\n');
+            children.push(react_1.default.createElement(Text, { key: 'ok-h', color: theme_1.THEME.dim }, '   Press Enter to return'));
+        }
+    }
+    else if (state.submitting) {
+        children.push('\n\n');
+        children.push(react_1.default.createElement(Text, { key: 'sub', color: theme_1.THEME.warning }, `   Recruiting ${state.answers.name}...`));
+    }
+    else if (TEXT_INPUT_STEPS.has(state.step)) {
+        // Text input step — prompt line as Text, input in minimal Box
+        const defaultHint = getDefaultHint(state.step, state.answers);
+        children.push('\n\n');
+        children.push(react_1.default.createElement(react_1.default.Fragment, { key: 'inp-q' }, react_1.default.createElement(Text, { color: theme_1.THEME.accent }, ' ? '), react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.text }, `${STEP_LABELS[state.step]}:`), defaultHint
+            ? react_1.default.createElement(Text, { color: theme_1.THEME.dim }, ` (${defaultHint})`)
+            : null));
+        // TextInput needs a Box — this is the only Box in the component
+        // It renders AFTER the Text block below
+    }
+    // For text-input steps: render Text block + Box(TextInput) in a Fragment
+    // For all other steps: single Text element (0 Yoga Box nodes)
+    if (TEXT_INPUT_STEPS.has(state.step) && !state.submitting) {
+        return react_1.default.createElement(react_1.default.Fragment, null, react_1.default.createElement(Text, null, ...children), react_1.default.createElement(Box, { marginLeft: 3 }, react_1.default.createElement(Text, { color: theme_1.THEME.accent }, '> '), react_1.default.createElement(TextInput, {
+            value: inputValue,
+            onChange: setInputValue,
+            onSubmit: handleTextSubmit,
+        })));
+    }
+    return react_1.default.createElement(Text, null, ...children);
+}
+function getAnswerDisplay(step, answers) {
+    switch (step) {
+        case 'name': return answers.name;
+        case 'agent': return answers.agent;
+        case 'type': return answers.playerType || '(default)';
+        case 'workDir': return answers.workDir;
+        case 'message': return answers.initialMessage || '(none)';
+        case 'host': return answers.host;
+        default: return '';
+    }
+}
+function getDefaultHint(step, answers) {
+    switch (step) {
+        case 'workDir': return answers.workDir;
+        case 'host': return 'localhost';
+        case 'message': return 'press Enter to skip';
+        case 'type': return 'press Enter for default';
+        default: return null;
+    }
+}

package/dist/tui/components/RestoreConfirmModal.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Single-keypress y/N confirmation before restoring an offline ensemble.
+ * Restore is recoverable (operator can `shutdown` again), so no typed
+ * confirmation — that's reserved for `destroy`.
+ */
+import React from 'react';
+export interface RestoreConfirmModalProps {
+    ensemble: string;
+    /** Number of offline players in the ensemble (conductor excluded from the count). */
+    playerCount: number;
+    /** Conductor name if known — falls back to the default "conductor" label. */
+    conductorName?: string;
+    onConfirm: () => void;
+    onCancel: () => void;
+    submitting?: boolean;
+    error?: string | null;
+}
+export declare function RestoreConfirmModal(props: RestoreConfirmModalProps): React.ReactElement;