@ekkos/cli 0.3.3 → 1.0.1

package/dist/commands/swarm-setup.js

@@ -0,0 +1,956 @@
+"use strict";
+/**
+ * ekkos swarm setup
+ *
+ * Full-screen blessed TUI wizard for configuring and launching a swarm.
+ * 4 steps: Task & Workers → Configuration → Model Selection → Review & Launch.
+ *
+ * Uses manual focus management (blessed FormElement is unreliable).
+ * Transitions seamlessly to the swarm dashboard after launch.
+ */
+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.swarmSetup = swarmSetup;
+const fs = __importStar(require("fs"));
+const blessed = __importStar(require("blessed"));
+const child_process_1 = require("child_process");
+const swarm_1 = require("./swarm");
+// ── Ghostty detection ──
+const GHOSTTY_PATHS = [
+    '/Applications/Ghostty.app',
+    '/opt/homebrew/bin/ghostty',
+    '/usr/local/bin/ghostty',
+];
+function findGhostty() {
+    // Check PATH first
+    try {
+        const result = (0, child_process_1.execSync)('which ghostty 2>/dev/null', { encoding: 'utf-8' }).trim();
+        if (result)
+            return result;
+    }
+    catch { }
+    // Check known locations
+    for (const p of GHOSTTY_PATHS) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+/**
+ * Launch ONE Ghostty window with a tiled tmux layout showing all workers + queen.
+ *
+ * Creates a "workers-view" tmux window with panes. Each pane uses TMUX='' to
+ * nest-attach (read-only) to a linked session viewing a specific worker/queen.
+ * Opens a single Ghostty window attached to this overview.
+ *
+ * On macOS, Ghostty's `-e` flag is broken (wraps through /usr/bin/login).
+ * Use `--command="..."` config key instead.
+ */
+function launchGhosttyTiled(tmuxSession, workerCount, hasQueen) {
+    const ghosttyPath = findGhostty();
+    if (!ghosttyPath)
+        return;
+    const isApp = ghosttyPath.endsWith('.app');
+    // Create a linked session for the Ghostty window (independent window selection)
+    const ghosttySession = `${tmuxSession}-ghostty`;
+    try {
+        (0, child_process_1.execSync)(`tmux new-session -d -t "${tmuxSession}" -s "${ghosttySession}"`, { stdio: 'pipe' });
+    }
+    catch {
+        return;
+    }
+    // Create the "workers-view" window with tiled panes
+    try {
+        (0, child_process_1.execSync)(`tmux new-window -t "${ghosttySession}" -n "workers-view"`, { stdio: 'pipe' });
+        (0, child_process_1.execSync)(`tmux select-window -t "${ghosttySession}:workers-view"`, { stdio: 'pipe' });
+        // Build the list of linked sessions we need
+        const views = [];
+        for (let i = 1; i <= workerCount; i++) {
+            views.push({ name: `v-w${i}`, tmuxWindow: `worker-${i}` });
+        }
+        if (hasQueen) {
+            views.push({ name: 'v-queen', tmuxWindow: 'queen' });
+        }
+        // Create linked sessions for each view
+        for (const view of views) {
+            const linked = `${tmuxSession}-${view.name}`;
+            try {
+                (0, child_process_1.execSync)(`tmux new-session -d -t "${tmuxSession}" -s "${linked}"`, { stdio: 'pipe' });
+                (0, child_process_1.execSync)(`tmux select-window -t "${linked}:${view.tmuxWindow}"`, { stdio: 'pipe' });
+            }
+            catch { }
+        }
+        // First pane is already created — set it to worker-1
+        const firstLinked = `${tmuxSession}-${views[0].name}`;
+        (0, child_process_1.execSync)(`tmux send-keys -t "${ghosttySession}:workers-view.0" "TMUX='' tmux attach -r -t '${firstLinked}'" Enter`, { stdio: 'pipe' });
+        // Create additional panes for remaining workers + queen
+        for (let i = 1; i < views.length; i++) {
+            const linked = `${tmuxSession}-${views[i].name}`;
+            // Alternate horizontal/vertical splits for a good tiled layout
+            const splitFlag = i % 2 === 1 ? '-h' : '-v';
+            (0, child_process_1.execSync)(`tmux split-window ${splitFlag} -t "${ghosttySession}:workers-view"`, { stdio: 'pipe' });
+            (0, child_process_1.execSync)(`tmux send-keys -t "${ghosttySession}:workers-view.${i}" "TMUX='' tmux attach -r -t '${linked}'" Enter`, { stdio: 'pipe' });
+        }
+        // Tile all panes evenly
+        (0, child_process_1.execSync)(`tmux select-layout -t "${ghosttySession}:workers-view" tiled`, { stdio: 'pipe' });
+    }
+    catch (err) {
+        // Non-fatal — dashboard still works
+        return;
+    }
+    // Launch ONE Ghostty window attached to the workers-view
+    const attachCmd = `tmux attach -t "${ghosttySession}"`;
+    if (isApp) {
+        (0, child_process_1.spawn)('open', [
+            '-na', ghosttyPath, '--args',
+            `--command=${attachCmd}`,
+            `--title=ekkOS Swarm Workers`,
+        ], {
+            stdio: 'ignore',
+            detached: true,
+        }).unref();
+    }
+    else {
+        (0, child_process_1.spawn)(ghosttyPath, [
+            `--command=${attachCmd}`,
+            `--title=ekkOS Swarm Workers`,
+        ], {
+            stdio: 'ignore',
+            detached: true,
+        }).unref();
+    }
+}
+// ── Constants ──
+const LOGO_CHARS = ['e', 'k', 'k', 'O', 'S', '_'];
+const WAVE_COLORS = ['cyan', 'blue', 'magenta', 'yellow', 'green', 'white'];
+const WORKER_COLORS = ['magenta', 'blue', 'green', 'yellow', 'cyan', 'red', 'white', 'gray'];
+const MODEL_TIERS = ['opus', 'sonnet', 'haiku'];
+const QUEEN_STRATEGIES = ['adaptive-default', 'hierarchical-cascade', 'mesh-consensus'];
+const STEP_LABELS = ['Task', 'Config', 'Models', 'Launch'];
+// ── Main export ──
+async function swarmSetup() {
+    // ── State ──
+    const state = {
+        task: '',
+        workers: 4,
+        decompose: true,
+        queen: true,
+        bypass: true,
+        queenStrategy: 'adaptive-default',
+        sameForAll: true,
+        globalModel: 'sonnet',
+        perWorkerModels: Array(8).fill('sonnet'),
+        currentStep: 0,
+        focusIndex: 0,
+    };
+    // Per-step focusable widget arrays
+    const stepWidgets = [[], [], [], []];
+    // ── Screen init (reuses /dev/tty isolation from dashboard.ts) ──
+    let ttyInput;
+    let ttyOutput;
+    try {
+        const ttyFd = fs.openSync('/dev/tty', 'r+');
+        ttyInput = new (require('tty').ReadStream)(ttyFd);
+        ttyOutput = new (require('tty').WriteStream)(ttyFd);
+    }
+    catch {
+        ttyInput = process.stdin;
+        ttyOutput = process.stdout;
+    }
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: 'ekkOS Swarm Setup',
+        fullUnicode: true,
+        mouse: false,
+        grabKeys: false,
+        sendFocus: false,
+        ignoreLocked: ['C-c'],
+        input: ttyInput,
+        output: ttyOutput,
+        forceUnicode: true,
+        terminal: 'xterm-256color',
+        resizeTimeout: 300,
+    });
+    if (screen.program) {
+        screen.program.alternateBuffer = () => { };
+        screen.program.normalBuffer = () => { };
+        if (screen.program.setRawMode) {
+            screen.program.setRawMode = (enabled) => enabled;
+        }
+    }
+    // ── Layout ──
+    const W = '100%';
+    const HEADER_H = 3;
+    const STEPS_H = 3;
+    const PREVIEW_H = 5;
+    const FOOTER_H = 3;
+    const FIXED_H = HEADER_H + STEPS_H + PREVIEW_H + FOOTER_H;
+    function calcLayout() {
+        const H = Math.max(24, screen.height);
+        const formH = Math.max(8, H - FIXED_H);
+        return {
+            header: { top: 0, height: HEADER_H },
+            steps: { top: HEADER_H, height: STEPS_H },
+            form: { top: HEADER_H + STEPS_H, height: formH },
+            preview: { top: H - PREVIEW_H - FOOTER_H, height: PREVIEW_H },
+            footer: { top: H - FOOTER_H, height: FOOTER_H },
+        };
+    }
+    let layout = calcLayout();
+    // ── Header box ──
+    const headerBox = blessed.box({
+        top: layout.header.top, left: 0, width: W, height: layout.header.height,
+        content: ' {gray-fg}Swarm Setup Wizard{/gray-fg}',
+        tags: true,
+        style: { fg: 'white', border: { fg: 'cyan' } },
+        border: { type: 'line' },
+        label: ' ekkOS_ ',
+    });
+    // ── Step indicator ──
+    const stepsBox = blessed.box({
+        top: layout.steps.top, left: 0, width: W, height: layout.steps.height,
+        tags: true,
+        style: { fg: 'white', border: { fg: 'gray' } },
+        border: { type: 'line' },
+    });
+    // ── Form area (content changes per step) ──
+    const formBox = blessed.box({
+        top: layout.form.top, left: 0, width: W, height: layout.form.height,
+        tags: true,
+        style: { fg: 'white', border: { fg: 'cyan' } },
+        border: { type: 'line' },
+        label: ' Step 1: Task & Workers ',
+    });
+    // ── Tmux preview ──
+    const previewBox = blessed.box({
+        top: layout.preview.top, left: 0, width: W, height: layout.preview.height,
+        tags: true,
+        style: { fg: 'white', border: { fg: 'gray' } },
+        border: { type: 'line' },
+        label: ' tmux Preview ',
+    });
+    // ── Footer ──
+    const footerBox = blessed.box({
+        top: layout.footer.top, left: 0, width: W, height: layout.footer.height,
+        tags: true,
+        style: { fg: 'white', border: { fg: 'gray' } },
+        border: { type: 'line' },
+    });
+    screen.append(headerBox);
+    screen.append(stepsBox);
+    screen.append(formBox);
+    screen.append(previewBox);
+    screen.append(footerBox);
+    // ── Error message box (inside form area) ──
+    const errorBox = blessed.box({
+        parent: formBox,
+        bottom: 0, left: 1, width: '100%-4', height: 1,
+        tags: true,
+        style: { fg: 'red' },
+    });
+    // ── Logo wave animation ──
+    let waveOffset = 0;
+    let waveTimer;
+    function renderLogoWave() {
+        try {
+            const coloredChars = LOGO_CHARS.map((ch, i) => {
+                const colorIdx = (i + waveOffset) % WAVE_COLORS.length;
+                return `{${WAVE_COLORS[colorIdx]}-fg}${ch}{/${WAVE_COLORS[colorIdx]}-fg}`;
+            });
+            const logoStr = ` ${coloredChars.join('')} `;
+            const rightLabel = ' Swarm Setup ';
+            const boxW = screen.width - 2;
+            const pad = Math.max(1, boxW - (LOGO_CHARS.length + 2) - rightLabel.length);
+            headerBox.setLabel(logoStr + '─'.repeat(pad) + `{gray-fg}${rightLabel}{/gray-fg}`);
+            waveOffset = (waveOffset + 1) % WAVE_COLORS.length;
+            screen.render();
+        }
+        catch { }
+    }
+    function scheduleWave() {
+        waveTimer = setTimeout(() => {
+            renderLogoWave();
+            scheduleWave();
+        }, 200);
+    }
+    scheduleWave();
+    // ── Helper: render step indicator ──
+    function renderStepIndicator() {
+        const parts = STEP_LABELS.map((label, i) => {
+            if (i < state.currentStep)
+                return `{green-fg}[✓ ${label}]{/green-fg}`;
+            if (i === state.currentStep)
+                return `{cyan-fg}{bold}[${i + 1} ${label}]{/bold}{/cyan-fg}`;
+            return `{gray-fg}[${i + 1} ${label}]{/gray-fg}`;
+        });
+        stepsBox.setContent(' ' + parts.join(' ── '));
+    }
+    // ── Helper: render tmux preview ──
+    function renderPreview() {
+        const n = state.workers;
+        const cells = ['{white-fg}[0] dash{/white-fg}'];
+        for (let i = 0; i < n; i++) {
+            const color = WORKER_COLORS[i % WORKER_COLORS.length];
+            const model = state.sameForAll ? state.globalModel : state.perWorkerModels[i];
+            const m = model[0].toUpperCase(); // O/S/H
+            cells.push(`{${color}-fg}[${i + 1}] W${i + 1}:${m}{/${color}-fg}`);
+        }
+        if (state.queen)
+            cells.push('{yellow-fg}[Q] queen{/yellow-fg}');
+        previewBox.setContent(' ' + cells.join('  '));
+    }
+    // ── Helper: render footer ──
+    function renderFooter() {
+        const isStep0 = state.currentStep === 0;
+        const isStep3 = state.currentStep === 3;
+        const nav = isStep0 ? '' : '{cyan-fg}←{/cyan-fg}:prev  ';
+        const navR = isStep3 ? '' : '{cyan-fg}→{/cyan-fg}:next  ';
+        const action = isStep3 ? '{green-fg}Enter{/green-fg}:launch  ' : '';
+        footerBox.setContent(` {cyan-fg}Tab{/cyan-fg}:focus  ${nav}${navR}${action}{red-fg}q{/red-fg}:quit`);
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // WIDGET FACTORIES (manual focus management)
+    // ══════════════════════════════════════════════════════════════════════════
+    function createTextInput(opts) {
+        const labelBox = blessed.box({
+            parent: opts.parent,
+            top: opts.top, left: opts.left, width: opts.label.length + 1, height: 1,
+            content: `{white-fg}${opts.label}{/white-fg}`,
+            tags: true,
+        });
+        const inputBox = blessed.box({
+            parent: opts.parent,
+            top: opts.top, left: opts.left + opts.label.length + 1,
+            width: opts.width - opts.label.length - 1, height: 3,
+            tags: true,
+            style: { fg: 'white', border: { fg: 'gray' } },
+            border: { type: 'line' },
+        });
+        let value = opts.value;
+        let cursorPos = value.length;
+        let isEditing = false;
+        function renderInput() {
+            const displayW = inputBox.width - 4;
+            let display = value;
+            if (display.length > displayW) {
+                display = display.slice(display.length - displayW);
+            }
+            if (isEditing) {
+                inputBox.setContent(`{cyan-fg}${display}{/cyan-fg}{white-fg}▏{/white-fg}`);
+            }
+            else if (value.length === 0) {
+                inputBox.setContent('{gray-fg}Type your task...{/gray-fg}');
+            }
+            else {
+                inputBox.setContent(`{white-fg}${display}{/white-fg}`);
+            }
+        }
+        renderInput();
+        return {
+            element: inputBox,
+            type: 'textbox',
+            key: 'task',
+            onActivate: () => {
+                isEditing = !isEditing;
+                if (isEditing) {
+                    inputBox.style.border = { fg: 'green' };
+                }
+                else {
+                    inputBox.style.border = { fg: 'cyan' };
+                }
+                renderInput();
+            },
+            getValue: () => {
+                return { value, isEditing, handleKey: (ch, key) => {
+                        if (!isEditing)
+                            return false;
+                        if (key.name === 'backspace') {
+                            value = value.slice(0, -1);
+                            cursorPos = Math.max(0, cursorPos - 1);
+                        }
+                        else if (key.name === 'return' || key.name === 'escape') {
+                            isEditing = false;
+                            inputBox.style.border = { fg: 'cyan' };
+                        }
+                        else if (ch && !key.ctrl && !key.meta && ch.length === 1) {
+                            value += ch;
+                            cursorPos = value.length;
+                        }
+                        else {
+                            return false;
+                        }
+                        opts.onChange(value);
+                        state.task = value;
+                        renderInput();
+                        return true;
+                    } };
+            },
+        };
+    }
+    function createNumberSelector(opts) {
+        const box = blessed.box({
+            parent: opts.parent,
+            top: opts.top, left: opts.left, width: opts.label.length + 14, height: 3,
+            tags: true,
+            style: { fg: 'white', border: { fg: 'gray' } },
+            border: { type: 'line' },
+        });
+        let value = opts.value;
+        function render() {
+            box.setContent(`{white-fg}${opts.label} {cyan-fg}< {bold}${value}{/bold} >{/cyan-fg}{/white-fg}`);
+        }
+        render();
+        return {
+            element: box,
+            type: 'number',
+            key: 'workers',
+            onLeft: () => {
+                if (value > opts.min) {
+                    value--;
+                    opts.onChange(value);
+                    render();
+                }
+            },
+            onRight: () => {
+                if (value < opts.max) {
+                    value++;
+                    opts.onChange(value);
+                    render();
+                }
+            },
+            getValue: () => value,
+        };
+    }
+    function createToggle(opts) {
+        const box = blessed.box({
+            parent: opts.parent,
+            top: opts.top, left: opts.left, width: opts.label.length + 8, height: 1,
+            tags: true,
+            style: { fg: 'white' },
+        });
+        let value = opts.value;
+        function render() {
+            const check = value ? '{green-fg}[✓]{/green-fg}' : '{gray-fg}[ ]{/gray-fg}';
+            box.setContent(`${check} {white-fg}${opts.label}{/white-fg}`);
+        }
+        render();
+        return {
+            element: box,
+            type: 'toggle',
+            key: opts.label,
+            onActivate: () => {
+                value = !value;
+                opts.onChange(value);
+                render();
+            },
+            getValue: () => value,
+        };
+    }
+    function createListSelector(opts) {
+        const maxItemLen = Math.max(...opts.items.map(s => s.length));
+        const box = blessed.box({
+            parent: opts.parent,
+            top: opts.top, left: opts.left, width: opts.label.length + maxItemLen + 10, height: opts.items.length + 2,
+            tags: true,
+            style: { fg: 'white', border: { fg: 'gray' } },
+            border: { type: 'line' },
+            label: ` ${opts.label} `,
+        });
+        let selected = opts.selectedIndex;
+        function render() {
+            const lines = opts.items.map((item, i) => {
+                const marker = i === selected ? '{cyan-fg}▸{/cyan-fg}' : ' ';
+                const style = i === selected ? '{cyan-fg}{bold}' : '{gray-fg}';
+                const end = i === selected ? '{/bold}{/cyan-fg}' : '{/gray-fg}';
+                return ` ${marker} ${style}${item}${end}`;
+            });
+            box.setContent(lines.join('\n'));
+        }
+        render();
+        return {
+            element: box,
+            type: 'list',
+            key: opts.label,
+            onActivate: () => {
+                selected = (selected + 1) % opts.items.length;
+                opts.onChange(selected, opts.items[selected]);
+                render();
+            },
+            onLeft: () => {
+                selected = (selected - 1 + opts.items.length) % opts.items.length;
+                opts.onChange(selected, opts.items[selected]);
+                render();
+            },
+            onRight: () => {
+                selected = (selected + 1) % opts.items.length;
+                opts.onChange(selected, opts.items[selected]);
+                render();
+            },
+            getValue: () => opts.items[selected],
+        };
+    }
+    function createModelCycler(opts) {
+        const color = WORKER_COLORS[opts.workerIndex % WORKER_COLORS.length];
+        const box = blessed.box({
+            parent: opts.parent,
+            top: opts.top, left: opts.left, width: 28, height: 1,
+            tags: true,
+            style: { fg: 'white' },
+        });
+        let value = opts.value;
+        function render() {
+            const modelColor = value === 'opus' ? 'magenta' : value === 'sonnet' ? 'blue' : 'green';
+            box.setContent(`{${color}-fg}${opts.label}{/${color}-fg}  {${modelColor}-fg}{bold}${value}{/bold}{/${modelColor}-fg}`);
+        }
+        render();
+        return {
+            element: box,
+            type: 'model-cycler',
+            key: `worker-${opts.workerIndex}`,
+            onActivate: () => {
+                const idx = MODEL_TIERS.indexOf(value);
+                value = MODEL_TIERS[(idx + 1) % MODEL_TIERS.length];
+                opts.onChange(value);
+                render();
+            },
+            getValue: () => value,
+        };
+    }
+    function createButton(opts) {
+        const box = blessed.box({
+            parent: opts.parent,
+            top: opts.top, left: opts.left, width: opts.label.length + 6, height: 3,
+            tags: true,
+            style: { fg: 'white', border: { fg: 'gray' } },
+            border: { type: 'line' },
+        });
+        function render() {
+            box.setContent(` {green-fg}{bold}${opts.label}{/bold}{/green-fg}`);
+        }
+        render();
+        return {
+            element: box,
+            type: 'button',
+            key: 'launch',
+            onActivate: opts.onPress,
+            getValue: () => null,
+        };
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // STEP BUILDERS
+    // ══════════════════════════════════════════════════════════════════════════
+    function clearForm() {
+        // Remove all children from formBox except errorBox
+        const children = formBox.children.slice();
+        for (const child of children) {
+            if (child !== errorBox)
+                formBox.remove(child);
+        }
+        errorBox.setContent('');
+    }
+    function setFocus(widgets, index) {
+        for (let i = 0; i < widgets.length; i++) {
+            const w = widgets[i];
+            if (w.element.border) {
+                w.element.style.border = { fg: i === index ? 'cyan' : 'gray' };
+            }
+        }
+        state.focusIndex = index;
+    }
+    // ── Step 0: Task & Workers ──
+    function buildStep0() {
+        clearForm();
+        formBox.setLabel(' Step 1: Task & Workers ');
+        const taskInput = createTextInput({
+            parent: formBox,
+            top: 1, left: 2, width: formBox.width - 6,
+            label: 'Task:',
+            value: state.task,
+            onChange: (val) => { state.task = val; },
+        });
+        const workerSelector = createNumberSelector({
+            parent: formBox,
+            top: 5, left: 2,
+            label: 'Workers',
+            value: state.workers,
+            min: 2, max: 8,
+            onChange: (val) => {
+                state.workers = val;
+                renderPreview();
+            },
+        });
+        stepWidgets[0] = [taskInput, workerSelector];
+        state.focusIndex = 0;
+        setFocus(stepWidgets[0], 0);
+    }
+    // ── Step 1: Configuration ──
+    function buildStep1() {
+        clearForm();
+        formBox.setLabel(' Step 2: Configuration ');
+        const decomposeToggle = createToggle({
+            parent: formBox, top: 1, left: 2,
+            label: 'AI Decomposition',
+            value: state.decompose,
+            onChange: (val) => { state.decompose = val; },
+        });
+        const queenToggle = createToggle({
+            parent: formBox, top: 3, left: 2,
+            label: 'Queen Coordinator',
+            value: state.queen,
+            onChange: (val) => { state.queen = val; renderPreview(); },
+        });
+        const bypassToggle = createToggle({
+            parent: formBox, top: 5, left: 2,
+            label: 'Bypass Permissions',
+            value: state.bypass,
+            onChange: (val) => { state.bypass = val; },
+        });
+        const strategyList = createListSelector({
+            parent: formBox, top: 7, left: 2,
+            label: 'Queen Strategy',
+            items: [...QUEEN_STRATEGIES],
+            selectedIndex: QUEEN_STRATEGIES.indexOf(state.queenStrategy),
+            onChange: (idx, val) => { state.queenStrategy = val; },
+        });
+        stepWidgets[1] = [decomposeToggle, queenToggle, bypassToggle, strategyList];
+        state.focusIndex = 0;
+        setFocus(stepWidgets[1], 0);
+    }
+    // ── Step 2: Model Selection ──
+    function buildStep2() {
+        clearForm();
+        formBox.setLabel(' Step 3: Model Selection ');
+        const sameToggle = createToggle({
+            parent: formBox, top: 1, left: 2,
+            label: 'Same model for all workers',
+            value: state.sameForAll,
+            onChange: (val) => {
+                state.sameForAll = val;
+                buildStep2(); // rebuild to show/hide per-worker
+                renderPreview();
+            },
+        });
+        const widgets = [sameToggle];
+        if (state.sameForAll) {
+            const globalList = createListSelector({
+                parent: formBox, top: 3, left: 2,
+                label: 'Model',
+                items: [...MODEL_TIERS],
+                selectedIndex: MODEL_TIERS.indexOf(state.globalModel),
+                onChange: (idx, val) => {
+                    state.globalModel = val;
+                    renderPreview();
+                },
+            });
+            widgets.push(globalList);
+        }
+        else {
+            for (let i = 0; i < state.workers; i++) {
+                const cycler = createModelCycler({
+                    parent: formBox,
+                    top: 3 + i, left: 2,
+                    label: `Worker ${i + 1}:`,
+                    workerIndex: i,
+                    value: state.perWorkerModels[i],
+                    onChange: (val) => {
+                        state.perWorkerModels[i] = val;
+                        renderPreview();
+                    },
+                });
+                widgets.push(cycler);
+            }
+        }
+        stepWidgets[2] = widgets;
+        state.focusIndex = 0;
+        setFocus(stepWidgets[2], 0);
+    }
+    // ── Step 3: Review & Launch ──
+    function buildStep3() {
+        clearForm();
+        formBox.setLabel(' Step 4: Review & Launch ');
+        const modelInfo = state.sameForAll
+            ? `{white-fg}${state.globalModel}{/white-fg} (all workers)`
+            : state.perWorkerModels.slice(0, state.workers).map((m, i) => {
+                const c = WORKER_COLORS[i % WORKER_COLORS.length];
+                return `{${c}-fg}W${i + 1}:${m}{/${c}-fg}`;
+            }).join(' ');
+        const lines = [
+            `  {gray-fg}Task:{/gray-fg}       {white-fg}${state.task || '(empty)'}{/white-fg}`,
+            `  {gray-fg}Workers:{/gray-fg}    {cyan-fg}${state.workers}{/cyan-fg}`,
+            `  {gray-fg}Decompose:{/gray-fg}  ${state.decompose ? '{green-fg}ON{/green-fg}' : '{red-fg}OFF{/red-fg}'}`,
+            `  {gray-fg}Queen:{/gray-fg}      ${state.queen ? '{green-fg}ON{/green-fg}' : '{red-fg}OFF{/red-fg}'}  {gray-fg}(${state.queenStrategy}){/gray-fg}`,
+            `  {gray-fg}Bypass:{/gray-fg}     ${state.bypass ? '{green-fg}ON{/green-fg}' : '{red-fg}OFF{/red-fg}'}`,
+            `  {gray-fg}Models:{/gray-fg}     ${modelInfo}`,
+        ];
+        const summaryBox = blessed.box({
+            parent: formBox,
+            top: 1, left: 1, width: '100%-4', height: lines.length + 1,
+            tags: true,
+            content: lines.join('\n'),
+        });
+        const launchButton = createButton({
+            parent: formBox,
+            top: lines.length + 3, left: Math.floor((formBox.width - 18) / 2),
+            label: '🚀 Launch Swarm',
+            onPress: doLaunch,
+        });
+        stepWidgets[3] = [launchButton];
+        state.focusIndex = 0;
+        setFocus(stepWidgets[3], 0);
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // STEP NAVIGATION
+    // ══════════════════════════════════════════════════════════════════════════
+    const stepBuilders = [buildStep0, buildStep1, buildStep2, buildStep3];
+    function goToStep(step) {
+        if (step < 0 || step > 3)
+            return;
+        // Validate current step before advancing
+        if (step > state.currentStep && !validateStep(state.currentStep))
+            return;
+        state.currentStep = step;
+        state.focusIndex = 0;
+        stepBuilders[step]();
+        renderStepIndicator();
+        renderPreview();
+        renderFooter();
+        screen.render();
+    }
+    function validateStep(step) {
+        if (step === 0) {
+            if (!state.task || state.task.trim().length === 0) {
+                errorBox.setContent('{red-fg}Task description is required{/red-fg}');
+                screen.render();
+                return false;
+            }
+        }
+        errorBox.setContent('');
+        return true;
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // LAUNCH
+    // ══════════════════════════════════════════════════════════════════════════
+    let launching = false;
+    async function doLaunch() {
+        if (launching)
+            return;
+        if (!validateStep(0)) {
+            goToStep(0);
+            return;
+        }
+        launching = true;
+        // Show launching state in form
+        clearForm();
+        formBox.setLabel(' Launching... ');
+        const msgBox = blessed.box({
+            parent: formBox,
+            top: 2, left: 2, width: '100%-6', height: 3,
+            tags: true,
+            content: ' {cyan-fg}🚀 Launching swarm with {bold}' + state.workers + '{/bold} workers...{/cyan-fg}\n' +
+                ' {gray-fg}This may take 15-20 seconds{/gray-fg}',
+        });
+        screen.render();
+        // Build model tiers array
+        const modelTiers = [];
+        for (let i = 0; i < state.workers; i++) {
+            modelTiers.push(state.sameForAll ? state.globalModel : state.perWorkerModels[i]);
+        }
+        try {
+            const tmuxSession = await (0, swarm_1.swarmLaunch)({
+                workers: state.workers,
+                task: state.task,
+                bypass: state.bypass,
+                noDecompose: !state.decompose,
+                noQueen: !state.queen,
+                queenStrategy: state.queenStrategy,
+                modelTiers,
+                interactive: true,
+            });
+            // Clean up blessed screen
+            clearTimeout(waveTimer);
+            screen.destroy();
+            if (tmuxSession) {
+                // Launch Ghostty windows for workers + queen (if Ghostty available)
+                const ghostty = findGhostty();
+                if (ghostty) {
+                    launchGhosttyTiled(tmuxSession, state.workers, state.queen);
+                    // Small delay for Ghostty windows to spawn before we take over the main terminal
+                    (0, child_process_1.execSync)('sleep 0.5', { stdio: 'pipe' });
+                }
+                // Main terminal attaches to the dashboard
+                (0, child_process_1.execSync)(`tmux attach -t "${tmuxSession}"`, { stdio: 'inherit' });
+            }
+        }
+        catch (err) {
+            launching = false;
+            clearForm();
+            formBox.setLabel(' Launch Failed ');
+            blessed.box({
+                parent: formBox,
+                top: 2, left: 2, width: '100%-6', height: 3,
+                tags: true,
+                content: ` {red-fg}Launch failed: ${err.message}{/red-fg}\n {gray-fg}Press ← to go back{/gray-fg}`,
+            });
+            screen.render();
+        }
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // KEYBOARD HANDLING
+    // ══════════════════════════════════════════════════════════════════════════
+    screen.on('keypress', (ch, key) => {
+        if (!key)
+            return;
+        // Quit
+        if (key.name === 'q' && !key.ctrl && !key.meta) {
+            // Don't quit if we're in a text input
+            const widgets = stepWidgets[state.currentStep];
+            const focused = widgets[state.focusIndex];
+            if (focused && focused.type === 'textbox') {
+                const data = focused.getValue?.();
+                if (data?.isEditing) {
+                    data.handleKey(ch, key);
+                    screen.render();
+                    return;
+                }
+            }
+            clearTimeout(waveTimer);
+            screen.destroy();
+            process.exit(0);
+        }
+        if (key.full === 'C-c') {
+            clearTimeout(waveTimer);
+            screen.destroy();
+            process.exit(0);
+        }
+        if (launching)
+            return;
+        const widgets = stepWidgets[state.currentStep];
+        const focused = widgets[state.focusIndex];
+        // Text input passthrough
+        if (focused && focused.type === 'textbox') {
+            const data = focused.getValue?.();
+            if (data?.isEditing) {
+                if (key.name === 'tab') {
+                    // Force exit editing on tab
+                    data.handleKey('', { name: 'escape' });
+                }
+                else {
+                    const handled = data.handleKey(ch, key);
+                    if (handled) {
+                        screen.render();
+                        return;
+                    }
+                }
+            }
+        }
+        // Tab / Shift-Tab: cycle focus
+        if (key.name === 'tab') {
+            if (widgets.length > 0) {
+                const next = key.shift
+                    ? (state.focusIndex - 1 + widgets.length) % widgets.length
+                    : (state.focusIndex + 1) % widgets.length;
+                setFocus(widgets, next);
+                screen.render();
+            }
+            return;
+        }
+        // Arrow left/right: step navigation or widget adjustment
+        if (key.name === 'left') {
+            if (focused && (focused.type === 'number' || focused.type === 'list')) {
+                focused.onLeft?.();
+                screen.render();
+                return;
+            }
+            // Ctrl-P or left arrow: prev step
+            goToStep(state.currentStep - 1);
+            return;
+        }
+        if (key.name === 'right') {
+            if (focused && (focused.type === 'number' || focused.type === 'list')) {
+                focused.onRight?.();
+                screen.render();
+                return;
+            }
+            // Ctrl-N or right arrow: next step
+            goToStep(state.currentStep + 1);
+            return;
+        }
+        // Ctrl-N / Ctrl-P: always navigate steps
+        if (key.full === 'C-n') {
+            goToStep(state.currentStep + 1);
+            return;
+        }
+        if (key.full === 'C-p') {
+            goToStep(state.currentStep - 1);
+            return;
+        }
+        // Up/Down on list widgets
+        if (key.name === 'up' && focused && focused.type === 'list') {
+            focused.onLeft?.();
+            screen.render();
+            return;
+        }
+        if (key.name === 'down' && focused && focused.type === 'list') {
+            focused.onRight?.();
+            screen.render();
+            return;
+        }
+        // Enter / Space: activate widget
+        if (key.name === 'return' || key.name === 'space') {
+            if (focused) {
+                focused.onActivate?.();
+                screen.render();
+            }
+            return;
+        }
+    });
+    // Resize handler
+    screen.on('resize', () => {
+        layout = calcLayout();
+        headerBox.top = layout.header.top;
+        headerBox.height = layout.header.height;
+        stepsBox.top = layout.steps.top;
+        stepsBox.height = layout.steps.height;
+        formBox.top = layout.form.top;
+        formBox.height = layout.form.height;
+        previewBox.top = layout.preview.top;
+        previewBox.height = layout.preview.height;
+        footerBox.top = layout.footer.top;
+        footerBox.height = layout.footer.height;
+        screen.render();
+    });
+    // ── Initial render ──
+    goToStep(0);
+}