agent-tempo 1.0.1

package/dist/tui/components/ConversationStream.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFormattedMessages = buildFormattedMessages;
+exports.ConversationStream = ConversationStream;
+/**
+ * ConversationStream — live message area showing ensemble conversation.
+ *
+ * Merges server conversation with local echo (optimistic sent messages),
+ * formats messages with header/body layout and word-wrap, and renders
+ * the most recent that fit in the viewport.
+ *
+ * Performance: Single <Text> root with nested virtual-text children.
+ * Zero Yoga <Box> nodes.
+ */
+const react_1 = __importDefault(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+const format_1 = require("../utils/format");
+function formatTime(timestamp) {
+    try {
+        const d = new Date(timestamp);
+        return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+    }
+    catch {
+        return '??:??';
+    }
+}
+const INDENT = '   '; // 3-space indent for message body (aligns with input area)
+const MAX_DISPLAY_LINES_THIRD_PARTY = 4; // Cap visible body lines for third-party (conductor) traffic
+/** Direct messages (maestro-in/out) show in full; third-party traffic is capped. */
+function maxLines(msg) {
+    return msg.thirdParty ? MAX_DISPLAY_LINES_THIRD_PARTY : Infinity;
+}
+/** Maximum recipient names listed inline in the broadcast badge text. */
+const BROADCAST_BADGE_NAME_CAP = 3;
+/**
+ * Render the broadcast-badge inline text (#357). Format:
+ *   `📡 broadcast → 3 players (alice, bob, carol) `
+ *   `📡 broadcast → 8 players (alice, bob, carol +5 more) `
+ * Trailing space is intentional — the body text follows on the same line.
+ */
+function broadcastBadgeText(badge) {
+    const head = `\u{1F4E1} broadcast → ${badge.count} player${badge.count === 1 ? '' : 's'}`;
+    const named = badge.recipients.slice(0, BROADCAST_BADGE_NAME_CAP);
+    const remainder = Math.max(0, badge.count - named.length);
+    if (named.length === 0)
+        return `${head} `;
+    const list = remainder > 0 ? `${named.join(', ')} +${remainder} more` : named.join(', ');
+    return `${head} (${list}) `;
+}
+/**
+ * Build the inline first-line prefix string added to outbound messages:
+ * either the broadcast badge (#357) — which dominates when present —
+ * or the directed-recipient prefix (#360). Empty string when neither
+ * applies. Used by both `buildFormattedMessages` (precomputes once on
+ * `FormattedMsg.firstLinePrefix`) and as a fallback in `estimateLines`.
+ */
+function makeFirstLinePrefix(msg) {
+    if (msg.broadcastBadge)
+        return broadcastBadgeText(msg.broadcastBadge);
+    // `→ @<label> ` — arrow + space + @ + label + trailing space.
+    if (msg.recipientLabel)
+        return `→ @${msg.recipientLabel} `;
+    return '';
+}
+function estimateLines(msg, termCols) {
+    const bodyWidth = Math.max(20, termCols - 4);
+    const originalLines = msg.body.split('\n');
+    const cap = maxLines(msg);
+    // When a first-line prefix (broadcast badge / `→ @<to>`) is shown,
+    // wrap the FIRST source line at a narrower width. Continuation source
+    // lines (and continuation wraps) use the full bodyWidth.
+    const prefixLen = msg.firstLinePrefix?.length ?? 0;
+    const firstLineWidth = Math.max(20, bodyWidth - prefixLen);
+    // Wrap ALL lines, then cap — matches rendering logic exactly
+    let wrappedCount = 0;
+    for (let li = 0; li < originalLines.length; li++) {
+        const w = li === 0 ? firstLineWidth : bodyWidth;
+        wrappedCount += (0, format_1.wordWrap)(originalLines[li], w).length;
+    }
+    let total = msg.direction === 'out' ? 0 : 1; // header line for inbound
+    total += Math.min(wrappedCount, cap); // body (capped by WRAPPED count)
+    if (wrappedCount > cap)
+        total += 1; // overflow indicator "… (N more lines)"
+    total += 1; // separator (\n or \n\n)
+    return total;
+}
+/**
+ * #357: Fold consecutive `ConversationMessage`s sharing the same
+ * non-null `broadcastId` into a single group. Runs BEFORE per-message
+ * line estimation so `usedLines` doesn't over-count an unfolded
+ * fan-out and shrink the viewport.
+ *
+ * Fold key is `broadcastId + direction` only \u2014 role is excluded so
+ * local-echo entries (`from: 'you'`, undefined role) fold with their
+ * server-projected counterparts (`role: 'maestro-out'`) sharing the
+ * same id while the broadcast is in flight. Direction split keeps the
+ * inbound/outbound perspective intact.
+ */
+function foldByBroadcastId(sorted) {
+    const groups = [];
+    for (const m of sorted) {
+        const last = groups[groups.length - 1];
+        if (m.broadcastId &&
+            last &&
+            last[0].broadcastId === m.broadcastId &&
+            last[0].direction === m.direction) {
+            last.push(m);
+        }
+        else {
+            groups.push([m]);
+        }
+    }
+    return groups;
+}
+/**
+ * Pure projection: merge server conversation with local-echo sent
+ * messages, sort by timestamp, fold broadcast fan-out groups, and
+ * format each entry into the render-ready `FormattedMsg` shape.
+ * Exported so tests can assert on `recipientLabel` / `broadcastBadge`
+ * / `routeLabel` derivation without mounting Ink.
+ *
+ * `conductorPlayerId` is the active ensemble's conductor id. Used to
+ * suppress the `recipientLabel` on conductor-bound `maestro-out` rows
+ * so the `\u2192 @<conductor>` prefix doesn't dominate every message.
+ */
+function buildFormattedMessages(conversation, sentMessages, conductorPlayerId) {
+    // Merge server conversation with local echo (optimistic sent not yet on server)
+    const allConvoMsgs = [...conversation];
+    for (const m of sentMessages) {
+        const ts = new Date(m.timestamp).getTime();
+        // Strip @player prefix from sent text for comparison (server doesn't have it)
+        const sentBody = m.text.replace(/^@\S+\s+/, '');
+        const alreadyOnServer = conversation.some(c => c.direction === 'out' &&
+            Math.abs(new Date(c.timestamp).getTime() - ts) < 30000 &&
+            c.text.slice(0, 60) === sentBody.slice(0, 60));
+        if (!alreadyOnServer) {
+            allConvoMsgs.push({
+                id: `local-${m.timestamp}`,
+                from: 'you',
+                to: m.to,
+                text: m.text,
+                timestamp: m.timestamp,
+                direction: 'out',
+                // Forward broadcastId from the local-echo SentMessage so a
+                // freshly-sent broadcast still folds before the server projection
+                // catches up. (#357)
+                ...(m.broadcastId !== undefined ? { broadcastId: m.broadcastId } : {}),
+            });
+        }
+    }
+    const sorted = allConvoMsgs.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    // #357: fold consecutive same-broadcastId entries into groups, then
+    // project each group as one FormattedMsg. The badge enumerates
+    // recipients; the first message's body/timestamp/sender stand in for
+    // the group's display fields.
+    const groups = foldByBroadcastId(sorted);
+    return groups.map(group => {
+        const m = group[0];
+        const role = m.role;
+        const thirdParty = m.thirdParty;
+        let routeLabel;
+        if (role === 'conductor-out')
+            routeLabel = `${m.from} \u2192 ${m.to}`;
+        else if (role === 'conductor-in')
+            routeLabel = `${m.from} \u2192 ${m.to}`;
+        // #357: badge wins over recipientLabel \u2014 when the row represents a
+        // folded broadcast, recipients are already enumerated inside the
+        // badge text and the single-recipient prefix would duplicate that.
+        let broadcastBadge;
+        if (m.broadcastId) {
+            broadcastBadge = {
+                count: group.length,
+                recipients: group.map(g => g.to),
+            };
+        }
+        // #360: only set recipientLabel for `maestro-out` messages where
+        // the recipient is neither the active conductor (whose role is the
+        // implicit default for bare-text input) nor the legacy `'conductor'`
+        // literal. `to` of `'maestro'` is also excluded \u2014 outbound to maestro
+        // is meaningless (the maestro is the user's own session). Suppressed
+        // when `broadcastBadge` is set (#357 \u2194 #360 composition).
+        let recipientLabel;
+        if (!broadcastBadge &&
+            role === 'maestro-out' &&
+            m.to && m.to !== 'maestro' && m.to !== 'conductor' && m.to !== conductorPlayerId) {
+            recipientLabel = m.to;
+        }
+        // Pre-render the inline first-line prefix once so `estimateLines`
+        // and the renderer don't each call `broadcastBadgeText` separately.
+        const firstLinePrefix = makeFirstLinePrefix({ broadcastBadge, recipientLabel });
+        return {
+            sender: m.from,
+            time: formatTime(m.timestamp),
+            body: m.text,
+            direction: m.direction,
+            role,
+            thirdParty,
+            routeLabel,
+            recipientLabel,
+            broadcastBadge,
+            ...(firstLinePrefix ? { firstLinePrefix } : {}),
+        };
+    });
+}
+function ConversationStream({ conversation, sentMessages, contentHeight, overflowRef, conductorPlayerId }) {
+    const { Text } = (0, ink_context_1.useInk)();
+    const termCols = process.stdout.columns || 80;
+    const bodyWidth = Math.max(20, termCols - 4);
+    const formatted = buildFormattedMessages(conversation, sentMessages, conductorPlayerId);
+    // Work backwards from newest — include as many as fit in viewport
+    let usedLines = 0;
+    let startIdx = formatted.length;
+    for (let i = formatted.length - 1; i >= 0; i--) {
+        const needed = estimateLines(formatted[i], termCols);
+        if (usedLines + needed > contentHeight - 1)
+            break;
+        usedLines += needed;
+        startIdx = i;
+    }
+    // Store overflow data for parent to commit to Static scrollback
+    overflowRef.current = { formatted, startIdx };
+    const visibleMsgs = formatted.slice(startIdx);
+    const children = [];
+    if (visibleMsgs.length === 0) {
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'empty', color: theme_1.THEME.dim }, ' No messages yet. Type to send.'));
+    }
+    else {
+        for (let i = 0; i < visibleMsgs.length; i++) {
+            const msg = visibleMsgs[i];
+            children.push(i === 0 ? '\n' : '\n\n');
+            const isOut = msg.direction === 'out';
+            const bg = isOut ? theme_1.THEME.inputBg : undefined;
+            // Word-wrap body. #360: when a recipientLabel prefix is rendered
+            // inline on the first line, wrap the FIRST source line at a
+            // narrower width to leave room. Continuation source lines (and
+            // their wraps) use the full bodyWidth.
+            const prefixLen = msg.firstLinePrefix?.length ?? 0;
+            const firstLineWidth = Math.max(20, bodyWidth - prefixLen);
+            const originalLines = msg.body.split('\n');
+            const wrappedLines = [];
+            for (let li = 0; li < originalLines.length; li++) {
+                const w = li === 0 ? firstLineWidth : bodyWidth;
+                wrappedLines.push(...(0, format_1.wordWrap)(originalLines[li], w));
+            }
+            const cap = maxLines(msg);
+            const displayLines = wrappedLines.slice(0, cap);
+            if (isOut) {
+                // Outbound: inline — ♩ first line, then wrapped continuation lines (no timestamp).
+                // The first-line prefix string is precomputed in
+                // `buildFormattedMessages` (#357 broadcast badge / #360 directed
+                // recipient — mutually exclusive). Color picks are local: badge
+                // accent vs recipient dim.
+                const prefixEl = msg.firstLinePrefix
+                    ? react_1.default.createElement(Text, { key: `pre-${i}`, backgroundColor: bg, color: msg.broadcastBadge ? theme_1.THEME.accent : theme_1.THEME.dim }, msg.firstLinePrefix)
+                    : null;
+                for (let j = 0; j < displayLines.length; j++) {
+                    if (j > 0)
+                        children.push('\n');
+                    if (j === 0) {
+                        const firstText = displayLines[0];
+                        const pad = ' '.repeat(Math.max(0, termCols - 2 - 3 - prefixLen - firstText.length));
+                        children.push(react_1.default.createElement(react_1.default.Fragment, { key: `bl-${i}-0` }, react_1.default.createElement(Text, { backgroundColor: bg, color: theme_1.THEME.accent, bold: true }, ' \u2669 '), ...(prefixEl ? [prefixEl] : []), react_1.default.createElement(Text, { backgroundColor: bg, color: theme_1.THEME.text }, firstText), react_1.default.createElement(Text, { backgroundColor: bg, color: theme_1.THEME.dim }, pad)));
+                    }
+                    else {
+                        const contLine = `${INDENT}${displayLines[j]}`;
+                        children.push(react_1.default.createElement(Text, { key: `bl-${i}-${j}`, backgroundColor: bg, color: theme_1.THEME.text }, contLine.padEnd(termCols - 2)));
+                    }
+                }
+                if (wrappedLines.length > cap) {
+                    const moreLine = `${INDENT}\u2026 (${wrappedLines.length - cap} more lines)`;
+                    children.push('\n');
+                    children.push(react_1.default.createElement(Text, { key: `mt-${i}`, backgroundColor: bg, color: theme_1.THEME.dim }, moreLine.padEnd(termCols - 2)));
+                }
+            }
+            else {
+                // Inbound: header line + body lines
+                const headerLabel = msg.routeLabel || msg.sender;
+                const headerColor = msg.thirdParty ? theme_1.THEME.dim : theme_1.THEME.accent;
+                const bodyColor = msg.thirdParty ? theme_1.THEME.textMuted : theme_1.THEME.text;
+                const headerPrefix = msg.thirdParty ? '   ' : ' \u2190 ';
+                children.push(react_1.default.createElement(react_1.default.Fragment, { key: `hdr-${i}` }, 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 }, `  ${msg.time}`)));
+                for (let j = 0; j < displayLines.length; j++) {
+                    children.push('\n');
+                    children.push(react_1.default.createElement(Text, { key: `bl-${i}-${j}`, color: bodyColor }, `${INDENT}${displayLines[j]}`));
+                }
+                if (wrappedLines.length > cap) {
+                    children.push('\n');
+                    children.push(react_1.default.createElement(Text, { key: `mt-${i}`, color: theme_1.THEME.dim }, `${INDENT}\u2026 (${wrappedLines.length - cap} more lines)`));
+                }
+            }
+        }
+    }
+    // Explicit padding: fill remaining space so content = exactly contentHeight lines
+    // usedLines = exact terminal lines for messages (from fitting loop)
+    // 1 line reserved for footer margin
+    const paddingLines = Math.max(0, contentHeight - usedLines - 1);
+    if (paddingLines > 0) {
+        children.push('\n'.repeat(paddingLines));
+    }
+    children.push('\n'); // exactly 1-line footer margin
+    return react_1.default.createElement(Text, null, ...children);
+}

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

@@ -0,0 +1,19 @@
+/**
+ * CreateEnsembleWizard — step-by-step flow for creating a new ensemble.
+ *
+ * Steps: name → workDir → lineup (optional) → confirm
+ *
+ * Minimal-Box pattern: single <Text> root for static content,
+ * one <Box> for Ink's TextInput on text-input steps.
+ */
+import React from 'react';
+import type { CreateEnsembleState, CreateEnsembleAnswers } from '../store';
+export interface CreateEnsembleWizardProps {
+    state: CreateEnsembleState;
+    onAnswer: (answer: Partial<CreateEnsembleAnswers>) => void;
+    onBack: () => void;
+    onConfirm: () => void;
+    onCancel: () => void;
+    onDone: () => void;
+}
+export declare function CreateEnsembleWizard({ state, onAnswer, onBack, onConfirm, onCancel, onDone }: CreateEnsembleWizardProps): React.FunctionComponentElement<React.FragmentProps> | React.CElement<{}, React.Component<{}, any, any>>;

package/dist/tui/components/CreateEnsembleWizard.js

@@ -0,0 +1,223 @@
+"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.CreateEnsembleWizard = CreateEnsembleWizard;
+/**
+ * CreateEnsembleWizard — step-by-step flow for creating a new ensemble.
+ *
+ * Steps: name → workDir → lineup (optional) → confirm
+ *
+ * Minimal-Box pattern: single <Text> root for static content,
+ * one <Box> for Ink's TextInput on text-input steps.
+ */
+const react_1 = __importStar(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+const saver_1 = require("../../ensemble/saver");
+const STEP_LABELS = {
+    name: 'Ensemble name',
+    workDir: 'Working directory',
+    lineup: 'Lineup (optional)',
+    confirm: 'Confirm',
+    done: 'Done',
+};
+const TEXT_INPUT_STEPS = new Set(['name', 'workDir']);
+function CreateEnsembleWizard({ state, onAnswer, onBack, onConfirm, onCancel, onDone }) {
+    const { Box, Text, TextInput, useInput } = (0, ink_context_1.useInk)();
+    const [inputValue, setInputValue] = (0, react_1.useState)('');
+    const [lineupIdx, setLineupIdx] = (0, react_1.useState)(0);
+    const [lineupCustom, setLineupCustom] = (0, react_1.useState)(false);
+    // Build lineup options: (none) + saved/shipped + custom path
+    const lineupOptions = (0, react_1.useMemo)(() => {
+        const options = [
+            { label: '(none) \u2014 start with no lineup', value: '' },
+        ];
+        try {
+            for (const l of (0, saver_1.listAllLineups)()) {
+                options.push({ label: `${l.name} (${l.source})`, value: l.name, source: l.source });
+            }
+        }
+        catch { /* ignore */ }
+        options.push({ label: '[custom path...]', value: '__custom__' });
+        return options;
+    }, []);
+    useInput((0, react_1.useCallback)((_input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.backspace && state.step !== 'name' && state.step !== 'done' && !inputValue) {
+            if (state.step === 'lineup' && lineupCustom) {
+                setLineupCustom(false);
+                return;
+            }
+            onBack();
+            return;
+        }
+        if (state.step === 'confirm' && key.return)
+            onConfirm();
+        if (state.step === 'done' && key.return)
+            onDone();
+        // Lineup list navigation
+        if (state.step === 'lineup' && !lineupCustom) {
+            if (key.upArrow) {
+                setLineupIdx(i => (i - 1 + lineupOptions.length) % lineupOptions.length);
+                return;
+            }
+            if (key.downArrow) {
+                setLineupIdx(i => (i + 1) % lineupOptions.length);
+                return;
+            }
+            if (key.return) {
+                const selected = lineupOptions[lineupIdx];
+                if (selected.value === '__custom__') {
+                    setLineupCustom(true);
+                }
+                else {
+                    onAnswer({ lineup: selected.value });
+                }
+                return;
+            }
+        }
+    }, [state.step, inputValue, lineupCustom, lineupIdx, lineupOptions, onBack, onCancel, onConfirm, onDone, onAnswer]));
+    const handleTextSubmit = (0, react_1.useCallback)((value) => {
+        const trimmed = value.trim();
+        switch (state.step) {
+            case 'name':
+                if (!trimmed)
+                    return;
+                onAnswer({ name: trimmed });
+                break;
+            case 'workDir':
+                onAnswer({ workDir: trimmed || state.answers.workDir });
+                break;
+            case 'lineup':
+                // Custom path mode
+                onAnswer({ lineup: trimmed });
+                setLineupCustom(false);
+                break;
+        }
+        setInputValue('');
+    }, [state.step, state.answers.workDir, onAnswer]);
+    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 }, ' Create New Ensemble'), react_1.default.createElement(Text, { color: theme_1.THEME.dim }, '  (Esc to cancel, Backspace to go back)')));
+    // Completed steps
+    const steps = ['name', 'workDir', 'lineup'];
+    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
+    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 }, '   Create Ensemble:'));
+        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-d', color: theme_1.THEME.text }, `     Directory: ${a.workDir}`));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-l', color: theme_1.THEME.text }, `     Lineup:    ${a.lineup || '(none — bare ensemble)'}`));
+        children.push('\n\n');
+        children.push(react_1.default.createElement(Text, { key: 'sum-hint', color: theme_1.THEME.dim }, '   Press Enter to create, 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 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 if (state.submitting) {
+        children.push('\n\n');
+        children.push(react_1.default.createElement(Text, { key: 'sub', color: theme_1.THEME.warning }, `   \u2026 Creating ensemble "${state.answers.name}"...`));
+    }
+    else if (state.step === 'lineup') {
+        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 }, 'Select a lineup:')));
+        if (!lineupCustom) {
+            for (let i = 0; i < lineupOptions.length; i++) {
+                const opt = lineupOptions[i];
+                const selected = i === lineupIdx;
+                children.push('\n');
+                children.push(react_1.default.createElement(Text, { key: `lo-${i}`, color: selected ? theme_1.THEME.text : theme_1.THEME.dim, bold: selected }, `   ${selected ? '\u276F' : ' '} ${opt.label}`));
+            }
+        }
+    }
+    else if (TEXT_INPUT_STEPS.has(state.step)) {
+        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));
+    }
+    // Lineup custom path mode: show text input
+    if (state.step === 'lineup' && lineupCustom && !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,
+        })));
+    }
+    // Text input steps: Text + Box(TextInput)
+    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 'workDir': return answers.workDir;
+        case 'lineup': return answers.lineup || '(none)';
+        default: return '';
+    }
+}
+function getDefaultHint(step, answers) {
+    switch (step) {
+        case 'workDir': return answers.workDir;
+        case 'lineup': return 'press Enter to skip';
+        default: return null;
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Typed-name confirmation for `/destroy <ensemble>`. User must type the
+ * ensemble name character-for-character before Enter fires the destroy
+ * call. Mismatch preserves the input + surfaces an inline error; Esc
+ * cancels.
+ */
+import React from 'react';
+export interface DestroyConfirmModalProps {
+    ensemble: string;
+    input: string;
+    error?: string;
+    submitting?: boolean;
+    onInput: (next: string) => void;
+    onSubmit: () => void;
+    onCancel: () => void;
+}
+export declare function DestroyConfirmModal(props: DestroyConfirmModalProps): React.ReactElement;

package/dist/tui/components/DestroyConfirmModal.js

@@ -0,0 +1,62 @@
+"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.DestroyConfirmModal = DestroyConfirmModal;
+/**
+ * Typed-name confirmation for `/destroy <ensemble>`. User must type the
+ * ensemble name character-for-character before Enter fires the destroy
+ * call. Mismatch preserves the input + surfaces an inline error; Esc
+ * cancels.
+ */
+const react_1 = __importStar(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+function DestroyConfirmModal(props) {
+    const { ensemble, input, error, submitting, onInput, onSubmit, onCancel } = props;
+    const { Box, Text, TextInput, useInput } = (0, ink_context_1.useInk)();
+    useInput((0, react_1.useCallback)((_input, key) => {
+        if (!submitting && key.escape)
+            onCancel();
+    }, [submitting, onCancel]));
+    return react_1.default.createElement(Box, { flexDirection: 'column' }, react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.error }, ' Destroy ensemble'), react_1.default.createElement(Box, { marginTop: 1, flexDirection: 'column' }, react_1.default.createElement(Text, { color: theme_1.THEME.text }, `  Destroying "${ensemble}" will terminate all sessions, the scheduler, and the maestro.`), react_1.default.createElement(Text, { color: theme_1.THEME.text }, `  Type the ensemble name (${ensemble}) to confirm, or Esc to cancel:`)), submitting
+        ? react_1.default.createElement(Box, { marginLeft: 3, marginTop: 1 }, react_1.default.createElement(Text, { color: theme_1.THEME.warning }, `\u2026 Destroying "${ensemble}"\u2026`))
+        : react_1.default.createElement(Box, { marginLeft: 3, marginTop: 1 }, react_1.default.createElement(Text, { color: theme_1.THEME.error }, '> '), react_1.default.createElement(TextInput, {
+            value: input,
+            onChange: onInput,
+            onSubmit,
+        })), error
+        ? react_1.default.createElement(Text, { color: theme_1.THEME.error }, `  \u2717 ${error}`)
+        : null);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Ensemble list view — landing screen showing all ensembles.
+ * Arrow keys to navigate, Enter to drill in, q to quit.
+ */
+import React from 'react';
+import type { EnsembleSummary } from '../store';
+export interface EnsembleListViewProps {
+    ensembles: EnsembleSummary[];
+    selectedIndex: number;
+}
+export declare function EnsembleListView({ ensembles, selectedIndex }: EnsembleListViewProps): React.FunctionComponentElement<{
+    flexDirection: string;
+    padding: number;
+}>;