agent-tempo 1.0.1

package/dist/tui/store.js

@@ -0,0 +1,753 @@
+"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;
+    }
+}