agent-tempo 1.7.0 → 2.0.0-beta.2

package/dist/tui/store.js

@@ -1,753 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CREATE_ENSEMBLE_ANSWERS = exports.CREATE_ENSEMBLE_STEPS = exports.DEFAULT_SCHEDULE_ANSWERS = exports.SCHEDULE_STEPS = exports.RECRUIT_STEPS = exports.NOTIFICATION_CAP = exports.NOTIFICATION_TTL_MS = void 0;
-exports.toConversationEntry = toConversationEntry;
-exports.defaultRecruitAnswers = defaultRecruitAnswers;
-exports.initialState = initialState;
-exports.tuiReducer = tuiReducer;
-/**
- * Project an `EnsembleChatMessage` into a `ConversationEntry`. Shared by
- * the reducer's incremental path (`APPEND_CHAT_MESSAGE`) and the SSE
- * snapshot/recovery paths (`src/tui/sse-handler.ts`) so both produce the
- * same shape.
- */
-function toConversationEntry(m) {
-    return {
-        id: m.id,
-        from: m.from,
-        to: m.to,
-        text: m.text,
-        timestamp: m.timestamp,
-        direction: m.role === 'maestro-out' ? 'out' : 'in',
-        role: m.role,
-        thirdParty: m.role === 'conductor-out' || m.role === 'conductor-in',
-        // #357: forward broadcastId so the renderer can fold fan-out groups.
-        ...(m.broadcastId !== undefined ? { broadcastId: m.broadcastId } : {}),
-    };
-}
-/** Default TTLs by kind — errors get extra time to read. */
-exports.NOTIFICATION_TTL_MS = {
-    error: 8000,
-    warn: 5000,
-    info: 5000,
-};
-/** Maximum concurrent notifications; oldest is dropped when exceeded. */
-exports.NOTIFICATION_CAP = 3;
-exports.RECRUIT_STEPS = ['name', 'agent', 'type', 'workDir', 'message', 'host', 'confirm'];
-exports.SCHEDULE_STEPS = ['target', 'message', 'schedType', 'timing', 'timezone', 'confirm'];
-exports.DEFAULT_SCHEDULE_ANSWERS = {
-    target: '',
-    message: '',
-    schedType: 'every',
-    timing: '',
-    timezone: '',
-    name: '',
-};
-function defaultRecruitAnswers(defaultAgent = 'claude') {
-    return {
-        name: '',
-        agent: defaultAgent,
-        playerType: '',
-        workDir: process.cwd(),
-        initialMessage: '',
-        host: 'localhost',
-    };
-}
-exports.CREATE_ENSEMBLE_STEPS = ['name', 'workDir', 'lineup', 'confirm'];
-exports.DEFAULT_CREATE_ENSEMBLE_ANSWERS = {
-    name: '',
-    workDir: process.cwd(),
-    lineup: '',
-};
-function initialState(ensemble) {
-    return {
-        phase: ensemble ? 'main' : 'splash',
-        view: ensemble ? 'ensemble' : 'home',
-        splashStatus: 'Starting up...',
-        splashChecks: [],
-        splashConnected: false,
-        splashSummary: undefined,
-        ensembles: null,
-        selectedEnsembleIndex: 0,
-        activeEnsemble: ensemble || null,
-        players: [],
-        playersLoaded: false,
-        messages: [],
-        conductorHistory: [],
-        schedules: [],
-        conversation: null,
-        ensembleChat: [],
-        hasConductor: false,
-        ensemblePaused: false,
-        ensembleHeld: false,
-        selectedPlayerIndex: 0,
-        activePlayer: null,
-        playerMetadata: null,
-        playerMessages: [],
-        playerScrollOffset: 0,
-        staticItems: [],
-        notifications: [],
-        notificationTick: 0,
-        chatTarget: undefined,
-        sentMessages: [],
-        statusOverlay: false,
-        overlay: null,
-        statusScrollOffset: 0,
-        paletteVisible: false,
-        paletteIndex: 0,
-        pickerVisible: false,
-        pickerType: null,
-        pickerIntent: null,
-        pickerIndex: 0,
-        pickerStatusFilter: null,
-        confirmingStop: undefined,
-        confirmingStopReason: undefined,
-        scheduleWizard: undefined,
-    };
-}
-// ── Reducer ──
-function tuiReducer(state, action) {
-    switch (action.type) {
-        case 'SET_PHASE':
-            return { ...state, phase: action.phase, error: action.error };
-        case 'SET_SPLASH_STATUS':
-            return { ...state, splashStatus: action.status };
-        case 'SET_SPLASH_CHECKS':
-            return { ...state, splashChecks: action.checks };
-        case 'SET_SPLASH_CONNECTED':
-            return { ...state, splashConnected: true, splashSummary: action.summary };
-        // ── Navigation ──
-        case 'NAVIGATE_HOME':
-            // Auto-select was removed from the poller (#306 follow-up): HomeView
-            // is the explicit ensemble picker, so once the user lands on home they
-            // stay there until they pick an ensemble themselves. This action just
-            // resets ensemble/player state and the chat shell.
-            return {
-                ...state,
-                view: 'home',
-                phase: 'main',
-                activeEnsemble: null,
-                activePlayer: null,
-                chatTarget: undefined,
-                players: [],
-                playersLoaded: false,
-                messages: [],
-                sentMessages: [],
-                conductorHistory: [],
-                schedules: [],
-                conversation: null,
-                playerMetadata: null,
-                playerMessages: [],
-                ensemblePaused: false,
-                ensembleHeld: false,
-                selectedPlayerIndex: 0,
-            };
-        case 'NAVIGATE_ENSEMBLE':
-            return {
-                ...state,
-                view: 'ensemble',
-                phase: 'main',
-                activeEnsemble: action.ensemble,
-                activePlayer: null,
-                chatTarget: undefined,
-                players: [],
-                playersLoaded: false,
-                messages: [],
-                sentMessages: [],
-                conductorHistory: [],
-                schedules: [],
-                conversation: null,
-                playerMetadata: null,
-                playerMessages: [],
-                ensemblePaused: false,
-                ensembleHeld: false,
-                selectedPlayerIndex: 0,
-            };
-        case 'NAVIGATE_PLAYER':
-            return {
-                ...state,
-                view: 'player',
-                activePlayer: action.playerId,
-                playerMetadata: null,
-                playerMessages: [],
-                playerScrollOffset: 0,
-            };
-        // ── Data refresh ──
-        case 'REFRESH_ENSEMBLES':
-            return {
-                ...state,
-                ensembles: action.ensembles,
-                // Clamp selection index
-                selectedEnsembleIndex: Math.min(state.selectedEnsembleIndex, Math.max(0, action.ensembles.length - 1)),
-            };
-        case 'REFRESH_ENSEMBLE_DATA': {
-            const lastMsg = action.messages.length > 0 ? action.messages[action.messages.length - 1] : null;
-            return {
-                ...state,
-                players: action.players,
-                playersLoaded: true,
-                messages: action.messages,
-                conductorHistory: action.history,
-                schedules: action.schedules ?? state.schedules,
-                lastSeenMessageId: lastMsg?.id ?? state.lastSeenMessageId,
-                // Clamp selection index
-                selectedPlayerIndex: Math.min(state.selectedPlayerIndex, Math.max(0, action.players.length - 1)),
-            };
-        }
-        case 'SET_CONVERSATION':
-            return { ...state, conversation: action.conversation };
-        case 'SET_ENSEMBLE_CHAT':
-            return {
-                ...state,
-                ensembleChat: action.chat.messages,
-                hasConductor: action.chat.hasConductor,
-            };
-        // ── #94/#95 PR-4a — SSE event stream incremental updates ──
-        case 'APPEND_CHAT_MESSAGE': {
-            // `chat.appended` SSE events arrive one-per-message. We push onto
-            // `ensembleChat` and derive a matching conversation entry via
-            // `toConversationEntry` (also used by the snapshot path), so
-            // ChatView/ConversationStream see a continuous timeline. Cap the
-            // in-memory slice at 500 to bound memory on long-running sessions;
-            // PR-4b will adjust this as part of the scroll-view migration.
-            const m = action.message;
-            const newChat = [...state.ensembleChat, m];
-            const cappedChat = newChat.length > 500 ? newChat.slice(-500) : newChat;
-            const baseConv = state.conversation ?? [];
-            const newConv = [...baseConv, toConversationEntry(m)];
-            const cappedConv = newConv.length > 500 ? newConv.slice(-500) : newConv;
-            return { ...state, ensembleChat: cappedChat, conversation: cappedConv };
-        }
-        case 'UPSERT_PLAYER': {
-            // `player.added` and `player.phase_changed` both land here — added
-            // creates a new entry; phase_changed updates fields on the existing
-            // entry. Identity-preserving when the wire payload matches the
-            // current cached entry exactly so StatusBar/MainView don't churn
-            // on duplicate events (e.g. a quick disconnect/reconnect).
-            const incoming = action.player;
-            const idx = state.players.findIndex((p) => p.playerId === incoming.playerId);
-            if (idx === -1) {
-                return { ...state, players: [...state.players, incoming], playersLoaded: true };
-            }
-            const existing = state.players[idx];
-            const merged = { ...existing, ...incoming };
-            const fieldsEqual = existing.phase === merged.phase
-                && existing.part === merged.part
-                && existing.hostname === merged.hostname
-                && existing.workDir === merged.workDir
-                && existing.isConductor === merged.isConductor
-                && existing.gitBranch === merged.gitBranch
-                && existing.playerType === merged.playerType
-                && existing.agentType === merged.agentType;
-            if (fieldsEqual)
-                return state;
-            const next = state.players.slice();
-            next[idx] = merged;
-            return { ...state, players: next };
-        }
-        case 'PATCH_PLAYER_PHASE': {
-            // Rationale on the action type. Identity-preserving guard mirrors
-            // SET_ENSEMBLE_PAUSED — same StatusBar churn rationale.
-            const idx = state.players.findIndex((p) => p.playerId === action.playerId);
-            if (idx === -1)
-                return state;
-            if (state.players[idx].phase === action.phase)
-                return state;
-            const next = state.players.slice();
-            next[idx] = { ...state.players[idx], phase: action.phase };
-            return { ...state, players: next };
-        }
-        case 'REMOVE_PLAYER': {
-            const next = state.players.filter((p) => p.playerId !== action.playerId);
-            if (next.length === state.players.length)
-                return state;
-            return {
-                ...state,
-                players: next,
-                selectedPlayerIndex: Math.min(state.selectedPlayerIndex, Math.max(0, next.length - 1)),
-            };
-        }
-        case 'SET_SCHEDULES':
-            return { ...state, schedules: action.schedules };
-        case 'REFRESH_PLAYER_DATA':
-            return {
-                ...state,
-                playerMetadata: action.metadata,
-                playerMessages: action.messages,
-            };
-        case 'PLAYER_SCROLL_UP':
-            if (state.playerScrollOffset <= 0)
-                return state;
-            return { ...state, playerScrollOffset: state.playerScrollOffset - 1 };
-        case 'PLAYER_SCROLL_DOWN': {
-            const maxScroll = Math.max(0, state.playerMessages.length - 20);
-            if (state.playerScrollOffset >= maxScroll)
-                return state;
-            return { ...state, playerScrollOffset: state.playerScrollOffset + 1 };
-        }
-        // ── Selection & Focus ──
-        // ── Chat shell ──
-        case 'COMMIT_STATIC': {
-            const newItems = [...state.staticItems, action.item];
-            // Trim to last 500 entries for memory management
-            const trimmed = newItems.length > 500 ? newItems.slice(-500) : newItems;
-            return { ...state, staticItems: trimmed };
-        }
-        // ── Bottom-pinned notifications (#306) ──
-        case 'ADD_NOTIFICATION': {
-            const now = Date.now();
-            // Filter out expired entries before appending so the cap check isn't
-            // polluted by stale notifications that should already be gone.
-            const live = state.notifications.filter(n => n.expiresAt > now);
-            const appended = [...live, action.notification];
-            // Cap at NOTIFICATION_CAP — oldest drops off when exceeded.
-            const capped = appended.length > exports.NOTIFICATION_CAP
-                ? appended.slice(appended.length - exports.NOTIFICATION_CAP)
-                : appended;
-            return { ...state, notifications: capped };
-        }
-        case 'DISMISS_NOTIFICATION': {
-            const next = state.notifications.filter(n => n.id !== action.id);
-            if (next.length === state.notifications.length)
-                return state;
-            return { ...state, notifications: next };
-        }
-        case 'DISMISS_OLDEST_NOTIFICATION': {
-            // Filter-expired-first so Esc acts on what the user actually sees.
-            const now = Date.now();
-            const live = state.notifications.filter(n => n.expiresAt > now);
-            if (live.length === 0) {
-                // Still compact if any expired slipped through — keeps the array clean
-                if (live.length !== state.notifications.length) {
-                    return { ...state, notifications: live };
-                }
-                return state;
-            }
-            return { ...state, notifications: live.slice(1) };
-        }
-        case 'CLEAR_NOTIFICATIONS': {
-            if (state.notifications.length === 0)
-                return state;
-            return { ...state, notifications: [] };
-        }
-        case 'NOTIFICATION_TICK': {
-            // Cheap re-render trigger so expired notifications disappear from the
-            // rendered stack without requiring a reducer action per expiration.
-            // The render pass filters by `expiresAt > Date.now()`. Only the counter
-            // changes — we leave the notifications array alone to avoid thrashing
-            // the React children identity.
-            return { ...state, notificationTick: state.notificationTick + 1 };
-        }
-        // ── Command palette ──
-        case 'SHOW_PALETTE':
-            if (state.paletteVisible && state.paletteIndex === 0)
-                return state;
-            return { ...state, paletteVisible: true, paletteIndex: 0 };
-        case 'HIDE_PALETTE':
-            if (!state.paletteVisible && state.paletteIndex === 0)
-                return state;
-            return { ...state, paletteVisible: false, paletteIndex: 0 };
-        case 'PALETTE_UP': {
-            // #108: identity-preserving — returning `{ ...state, paletteIndex: same }`
-            // forces a re-render of the full app tree even when the value didn't change
-            // (e.g. holding arrow-up at index 0). Mirrors the OVERLAY_SELECT pattern
-            // below. See CLAUDE.md "Reducer state identity matters".
-            const next = Math.max(0, state.paletteIndex - 1);
-            if (next === state.paletteIndex)
-                return state;
-            return { ...state, paletteIndex: next };
-        }
-        case 'PALETTE_DOWN': {
-            // #108: same identity-preserving guard — holding arrow-down at the clamped
-            // max must not trigger spurious re-renders.
-            const next = state.paletteIndex + 1;
-            const clamped = action.max != null ? Math.min(next, action.max) : next;
-            if (clamped === state.paletteIndex)
-                return state;
-            return { ...state, paletteIndex: clamped };
-        }
-        case 'PALETTE_SET_INDEX':
-            return { ...state, paletteIndex: action.index };
-        // ── Picker overlay ──
-        case 'SHOW_STATUS':
-            return { ...state, statusOverlay: true, statusScrollOffset: 0 };
-        case 'HIDE_STATUS':
-            return { ...state, statusOverlay: false, statusScrollOffset: 0 };
-        case 'SHOW_COMMAND_OVERLAY':
-            return { ...state, overlay: { type: 'command', title: action.title, items: [{ id: '_', label: action.content }], selectedIndex: 0, hint: 'esc \u2014 close' } };
-        case 'SHOW_OVERLAY':
-            return { ...state, overlay: { ...action.overlay, selectedIndex: 0 } };
-        case 'HIDE_OVERLAY':
-            if (!state.overlay)
-                return state;
-            return { ...state, overlay: null };
-        case 'OVERLAY_SELECT': {
-            if (!state.overlay || state.overlay.items.length === 0)
-                return state;
-            const len = state.overlay.items.length;
-            const idx = action.direction === 'up'
-                ? (state.overlay.selectedIndex - 1 + len) % len
-                : (state.overlay.selectedIndex + 1) % len;
-            if (idx === state.overlay.selectedIndex)
-                return state;
-            return { ...state, overlay: { ...state.overlay, selectedIndex: idx } };
-        }
-        case 'STATUS_SCROLL_UP': {
-            const next = Math.max(0, state.statusScrollOffset - 1);
-            if (next === state.statusScrollOffset)
-                return state;
-            return { ...state, statusScrollOffset: next };
-        }
-        case 'STATUS_SCROLL_DOWN':
-            // #250: intentional — no upper-bound clamp lives in the reducer. The max
-            // offset depends on `players.length` and `contentHeight`, neither of which
-            // the reducer can see. `StatusOverlay` performs the final clamp via
-            // `Math.min(scrollOffset, max)` at render (components/StatusOverlay.tsx).
-            // Leaving the reducer unbounded + render-time clamping is cheaper than
-            // threading the render-time max back through every dispatch.
-            return { ...state, statusScrollOffset: state.statusScrollOffset + 1 };
-        case 'SHOW_PICKER':
-            return { ...state, pickerVisible: true, pickerType: action.pickerType, pickerIntent: action.intent || null, pickerIndex: 0, pickerStatusFilter: action.statusFilter || null };
-        case 'HIDE_PICKER':
-            return { ...state, pickerVisible: false, pickerType: null, pickerIntent: null, pickerIndex: 0, pickerStatusFilter: null };
-        case 'PICKER_UP': {
-            const next = Math.max(0, state.pickerIndex - 1);
-            if (next === state.pickerIndex)
-                return state;
-            return { ...state, pickerIndex: next };
-        }
-        case 'PICKER_DOWN': {
-            const maxIdx = (state.pickerType === 'ensembles' ? (state.ensembles?.length ?? 0) : state.players.length - 1);
-            if (state.pickerIndex >= maxIdx)
-                return state;
-            return { ...state, pickerIndex: state.pickerIndex + 1 };
-        }
-        case 'SET_ENSEMBLE_PAUSED':
-            // Identity-preserving: skip the dispatch when value didn't change so
-            // the StatusBar tree doesn't re-render every poll tick.
-            if (state.ensemblePaused === action.paused)
-                return state;
-            return { ...state, ensemblePaused: action.paused };
-        case 'SET_ENSEMBLE_HELD':
-            // Identity-preserving — same rationale as SET_ENSEMBLE_PAUSED. The
-            // 2s held-poll would otherwise reconcile the StatusBar every tick
-            // even when nothing changed.
-            if (state.ensembleHeld === action.held)
-                return state;
-            return { ...state, ensembleHeld: action.held };
-        case 'APPEND_SENT_MESSAGE': {
-            const newSent = [...state.sentMessages, { to: action.to, text: action.text, timestamp: new Date().toISOString() }];
-            const trimmedSent = newSent.length > 200 ? newSent.slice(-200) : newSent;
-            return { ...state, sentMessages: trimmedSent };
-        }
-        case 'HYDRATE_SENT_MESSAGES': {
-            // Merge server-side sent messages, dedup by text+timestamp
-            const existing = new Set(state.sentMessages.map(m => `${m.text.slice(0, 60)}:${m.timestamp}`));
-            const newMsgs = action.messages.filter(m => !existing.has(`${m.text.slice(0, 60)}:${m.timestamp}`));
-            if (newMsgs.length === 0)
-                return state;
-            return { ...state, sentMessages: [...state.sentMessages, ...newMsgs] };
-        }
-        case 'ENTER_CHAT':
-            return { ...state, phase: 'chat', chatTarget: action.target };
-        case 'EXIT_CHAT':
-            return { ...state, phase: 'main', chatTarget: undefined };
-        // ── Destroy confirmation (PR-H: was `/stop`; renamed to `/destroy`) ──
-        case 'CONFIRM_STOP':
-            return {
-                ...state,
-                confirmingStop: action.player,
-                ...(action.reason !== undefined ? { confirmingStopReason: action.reason } : { confirmingStopReason: undefined }),
-            };
-        case 'CANCEL_STOP':
-            return { ...state, confirmingStop: undefined, confirmingStopReason: undefined };
-        // ── Disband confirmation ──
-        case 'CONFIRM_DISBAND':
-            return { ...state, confirmingDisband: action.ensemble };
-        case 'CANCEL_DISBAND':
-            return { ...state, confirmingDisband: undefined };
-        // ── Lineup confirmation ──
-        case 'CONFIRM_LINEUP':
-            return { ...state, confirmingLineup: { action: action.action, path: action.path, summary: action.summary } };
-        case 'CANCEL_LINEUP':
-            return { ...state, confirmingLineup: undefined };
-        // ── Recruit wizard ──
-        case 'ENTER_RECRUIT':
-            return {
-                ...state,
-                phase: 'recruit',
-                recruitState: {
-                    step: 'name',
-                    answers: { ...defaultRecruitAnswers(action.defaultAgent), ...action.answers },
-                    preRecruitPhase: state.phase,
-                    preRecruitChatTarget: state.chatTarget,
-                },
-            };
-        case 'RECRUIT_NEXT_STEP': {
-            if (!state.recruitState)
-                return state;
-            const answers = { ...state.recruitState.answers, ...action.answer };
-            const currentIdx = exports.RECRUIT_STEPS.indexOf(state.recruitState.step);
-            const nextStep = exports.RECRUIT_STEPS[currentIdx + 1] ?? state.recruitState.step;
-            return {
-                ...state,
-                recruitState: { ...state.recruitState, step: nextStep, answers },
-            };
-        }
-        case 'RECRUIT_PREV_STEP': {
-            if (!state.recruitState)
-                return state;
-            const currentIdx = exports.RECRUIT_STEPS.indexOf(state.recruitState.step);
-            if (currentIdx <= 0)
-                return state;
-            const prevStep = exports.RECRUIT_STEPS[currentIdx - 1];
-            return {
-                ...state,
-                recruitState: { ...state.recruitState, step: prevStep },
-            };
-        }
-        case 'RECRUIT_SUBMIT':
-            if (!state.recruitState)
-                return state;
-            return {
-                ...state,
-                recruitState: { ...state.recruitState, submitting: true },
-            };
-        case 'RECRUIT_DONE':
-            if (!state.recruitState)
-                return state;
-            return {
-                ...state,
-                recruitState: {
-                    ...state.recruitState,
-                    step: 'done',
-                    submitting: false,
-                    error: action.error,
-                },
-            };
-        case 'EXIT_RECRUIT': {
-            const restorePhase = state.recruitState?.preRecruitPhase || 'main';
-            const restoreChat = state.recruitState?.preRecruitChatTarget;
-            return {
-                ...state,
-                phase: restorePhase,
-                chatTarget: restoreChat,
-                recruitState: undefined,
-            };
-        }
-        // ── Schedule wizard ──
-        case 'ENTER_SCHEDULE_WIZARD':
-            return {
-                ...state,
-                phase: 'schedule-create',
-                scheduleWizard: {
-                    step: 'target',
-                    answers: { ...exports.DEFAULT_SCHEDULE_ANSWERS, ...action.answers },
-                    prePhase: state.phase,
-                    preChatTarget: state.chatTarget,
-                },
-            };
-        case 'SCHEDULE_NEXT_STEP': {
-            if (!state.scheduleWizard)
-                return state;
-            const answers = { ...state.scheduleWizard.answers, ...action.answer };
-            const currentIdx = exports.SCHEDULE_STEPS.indexOf(state.scheduleWizard.step);
-            // Skip timezone step for non-cron types
-            let nextIdx = currentIdx + 1;
-            if (exports.SCHEDULE_STEPS[nextIdx] === 'timezone' && answers.schedType !== 'cron') {
-                nextIdx++;
-            }
-            const nextStep = exports.SCHEDULE_STEPS[nextIdx] ?? state.scheduleWizard.step;
-            return {
-                ...state,
-                scheduleWizard: { ...state.scheduleWizard, step: nextStep, answers },
-            };
-        }
-        case 'SCHEDULE_PREV_STEP': {
-            if (!state.scheduleWizard)
-                return state;
-            const currentIdx = exports.SCHEDULE_STEPS.indexOf(state.scheduleWizard.step);
-            if (currentIdx <= 0)
-                return state;
-            let prevIdx = currentIdx - 1;
-            // Skip timezone going back for non-cron
-            if (exports.SCHEDULE_STEPS[prevIdx] === 'timezone' && state.scheduleWizard.answers.schedType !== 'cron') {
-                prevIdx--;
-            }
-            const prevStep = exports.SCHEDULE_STEPS[Math.max(0, prevIdx)];
-            return {
-                ...state,
-                scheduleWizard: { ...state.scheduleWizard, step: prevStep },
-            };
-        }
-        case 'SCHEDULE_SUBMIT':
-            if (!state.scheduleWizard)
-                return state;
-            return {
-                ...state,
-                scheduleWizard: { ...state.scheduleWizard, submitting: true },
-            };
-        case 'SCHEDULE_DONE':
-            if (!state.scheduleWizard)
-                return state;
-            return {
-                ...state,
-                scheduleWizard: {
-                    ...state.scheduleWizard,
-                    step: 'done',
-                    submitting: false,
-                    error: action.error,
-                },
-            };
-        case 'EXIT_SCHEDULE_WIZARD': {
-            const restoreP = state.scheduleWizard?.prePhase || 'main';
-            const restoreC = state.scheduleWizard?.preChatTarget;
-            return {
-                ...state,
-                phase: restoreP,
-                chatTarget: restoreC,
-                scheduleWizard: undefined,
-            };
-        }
-        // ── Create Ensemble wizard ──
-        case 'ENTER_CREATE_ENSEMBLE':
-            return {
-                ...state,
-                phase: 'create-ensemble',
-                createEnsembleState: {
-                    step: 'name',
-                    answers: { ...exports.DEFAULT_CREATE_ENSEMBLE_ANSWERS },
-                    prePhase: state.phase,
-                },
-            };
-        case 'CREATE_ENSEMBLE_NEXT_STEP': {
-            if (!state.createEnsembleState)
-                return state;
-            const answers = { ...state.createEnsembleState.answers, ...action.answer };
-            const currentIdx = exports.CREATE_ENSEMBLE_STEPS.indexOf(state.createEnsembleState.step);
-            const nextStep = exports.CREATE_ENSEMBLE_STEPS[currentIdx + 1] ?? state.createEnsembleState.step;
-            return {
-                ...state,
-                createEnsembleState: { ...state.createEnsembleState, step: nextStep, answers },
-            };
-        }
-        case 'CREATE_ENSEMBLE_PREV_STEP': {
-            if (!state.createEnsembleState)
-                return state;
-            const currentIdx = exports.CREATE_ENSEMBLE_STEPS.indexOf(state.createEnsembleState.step);
-            if (currentIdx <= 0)
-                return state;
-            const prevStep = exports.CREATE_ENSEMBLE_STEPS[currentIdx - 1];
-            return {
-                ...state,
-                createEnsembleState: { ...state.createEnsembleState, step: prevStep },
-            };
-        }
-        case 'CREATE_ENSEMBLE_SUBMIT':
-            if (!state.createEnsembleState)
-                return state;
-            return {
-                ...state,
-                createEnsembleState: { ...state.createEnsembleState, submitting: true },
-            };
-        case 'CREATE_ENSEMBLE_DONE':
-            if (!state.createEnsembleState)
-                return state;
-            if (!action.error && action.ensemble) {
-                // Success — navigate to new ensemble
-                return {
-                    ...state,
-                    phase: 'main',
-                    view: 'ensemble',
-                    activeEnsemble: action.ensemble,
-                    createEnsembleState: undefined,
-                    players: [],
-                    messages: [],
-                    sentMessages: [],
-                    conductorHistory: [],
-                    schedules: [],
-                    conversation: null,
-                    selectedPlayerIndex: 0,
-                };
-            }
-            return {
-                ...state,
-                createEnsembleState: {
-                    ...state.createEnsembleState,
-                    step: 'done',
-                    submitting: false,
-                    error: action.error,
-                },
-            };
-        case 'EXIT_CREATE_ENSEMBLE': {
-            const restoreCE = state.createEnsembleState?.prePhase || 'main';
-            return {
-                ...state,
-                phase: restoreCE,
-                createEnsembleState: undefined,
-            };
-        }
-        case 'OPEN_HOME_MODAL':
-            return {
-                ...state,
-                homeModal: action.modal,
-                homeModalSubmitting: false,
-                homeModalError: undefined,
-            };
-        case 'CLOSE_HOME_MODAL':
-            return {
-                ...state,
-                homeModal: undefined,
-                homeModalSubmitting: false,
-                homeModalError: undefined,
-            };
-        case 'SET_HOME_MODAL_STATUS':
-            return {
-                ...state,
-                homeModalSubmitting: action.submitting ?? state.homeModalSubmitting,
-                homeModalError: action.error,
-            };
-        case 'CONFIRM_ENSEMBLE_DESTROY':
-            return {
-                ...state,
-                confirmingEnsembleDestroy: { ensemble: action.ensemble, input: '' },
-            };
-        case 'ENSEMBLE_DESTROY_INPUT': {
-            if (!state.confirmingEnsembleDestroy)
-                return state;
-            return {
-                ...state,
-                confirmingEnsembleDestroy: {
-                    ...state.confirmingEnsembleDestroy,
-                    input: action.input,
-                    error: undefined,
-                },
-            };
-        }
-        case 'ENSEMBLE_DESTROY_SUBMIT_BUSY': {
-            if (!state.confirmingEnsembleDestroy)
-                return state;
-            return {
-                ...state,
-                confirmingEnsembleDestroy: { ...state.confirmingEnsembleDestroy, submitting: true, error: undefined },
-            };
-        }
-        case 'ENSEMBLE_DESTROY_MISMATCH': {
-            if (!state.confirmingEnsembleDestroy)
-                return state;
-            const { ensemble, input } = state.confirmingEnsembleDestroy;
-            return {
-                ...state,
-                confirmingEnsembleDestroy: {
-                    ...state.confirmingEnsembleDestroy,
-                    submitting: false,
-                    error: `"${input}" \u2260 "${ensemble}" \u2014 type the ensemble name exactly to confirm.`,
-                },
-            };
-        }
-        case 'CANCEL_ENSEMBLE_DESTROY':
-            return { ...state, confirmingEnsembleDestroy: undefined };
-        default:
-            return state;
-    }
-}