wave-code 0.13.6 → 0.14.1

package/dist/components/BackgroundTaskManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BackgroundTaskManager.d.ts","sourceRoot":"","sources":["../../src/components/BackgroundTaskManager.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAgBnD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC,0BAA0B,CAyUtE,CAAC"}
+{"version":3,"file":"BackgroundTaskManager.d.ts","sourceRoot":"","sources":["../../src/components/BackgroundTaskManager.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgC,MAAM,OAAO,CAAC;AASrD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC,0BAA0B,CA8UtE,CAAC"}

package/dist/components/BackgroundTaskManager.js

@@ -1,34 +1,41 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useState, useEffect } from "react";
+import { useEffect, useReducer } from "react";
 import { Box, Text, useInput } from "ink";
 import { useChat } from "../contexts/useChat.js";
 import { getLastLines } from "wave-agent-sdk";
+import { backgroundTaskManagerReducer, } from "../reducers/backgroundTaskManagerReducer.js";
 export const BackgroundTaskManager = ({ onCancel, }) => {
     const { backgroundTasks, getBackgroundTaskOutput, stopBackgroundTask } = useChat();
-    const [tasks, setTasks] = useState([]);
-    const [selectedIndex, setSelectedIndex] = useState(0);
     const MAX_VISIBLE_ITEMS = 3;
-    const [viewMode, setViewMode] = useState("list");
-    const [detailTaskId, setDetailTaskId] = useState(null);
-    const [detailOutput, setDetailOutput] = useState(null);
+    const [state, dispatch] = useReducer(backgroundTaskManagerReducer, {
+        tasks: [],
+        selectedIndex: 0,
+        viewMode: "list",
+        detailTaskId: null,
+        detailOutput: null,
+    });
+    const { tasks, selectedIndex, viewMode, detailTaskId, detailOutput } = state;
     // Convert backgroundTasks to local Task format
     useEffect(() => {
-        setTasks(backgroundTasks.map((task) => ({
-            id: task.id,
-            type: task.type,
-            description: task.description,
-            status: task.status,
-            startTime: task.startTime,
-            exitCode: task.exitCode,
-            runtime: task.runtime,
-            outputPath: task.outputPath,
-        })));
+        dispatch({
+            type: "SET_TASKS",
+            tasks: backgroundTasks.map((task) => ({
+                id: task.id,
+                type: task.type,
+                description: task.description,
+                status: task.status,
+                startTime: task.startTime,
+                exitCode: task.exitCode,
+                runtime: task.runtime,
+                outputPath: task.outputPath,
+            })),
+        });
     }, [backgroundTasks]);
     // Load detail output for selected task
     useEffect(() => {
         if (viewMode === "detail" && detailTaskId) {
             const output = getBackgroundTaskOutput(detailTaskId);
-            setDetailOutput(output);
+            dispatch({ type: "SET_DETAIL_OUTPUT", output });
         }
     }, [viewMode, detailTaskId, getBackgroundTaskOutput]);
     const formatDuration = (ms) => {
@@ -55,8 +62,8 @@ export const BackgroundTaskManager = ({ onCancel, }) => {
             if (key.return) {
                 if (tasks.length > 0 && selectedIndex < tasks.length) {
                     const selectedTask = tasks[selectedIndex];
-                    setDetailTaskId(selectedTask.id);
-                    setViewMode("detail");
+                    dispatch({ type: "SET_DETAIL_TASK_ID", id: selectedTask.id });
+                    dispatch({ type: "SET_VIEW_MODE", mode: "detail" });
                 }
                 return;
             }
@@ -65,11 +72,17 @@ export const BackgroundTaskManager = ({ onCancel, }) => {
                 return;
             }
             if (key.upArrow) {
-                setSelectedIndex(Math.max(0, selectedIndex - 1));
+                dispatch({
+                    type: "SELECT_INDEX",
+                    index: Math.max(0, selectedIndex - 1),
+                });
                 return;
             }
             if (key.downArrow) {
-                setSelectedIndex(Math.min(tasks.length - 1, selectedIndex + 1));
+                dispatch({
+                    type: "SELECT_INDEX",
+                    index: Math.min(tasks.length - 1, selectedIndex + 1),
+                });
                 return;
             }
             if (input === "k" && tasks.length > 0 && selectedIndex < tasks.length) {
@@ -83,9 +96,7 @@ export const BackgroundTaskManager = ({ onCancel, }) => {
         else if (viewMode === "detail") {
             // Detail mode navigation
             if (key.escape) {
-                setViewMode("list");
-                setDetailTaskId(null);
-                setDetailOutput(null);
+                dispatch({ type: "RESET_DETAIL" });
                 return;
             }
             if (input === "k" && detailTaskId) {
@@ -100,7 +111,7 @@ export const BackgroundTaskManager = ({ onCancel, }) => {
     if (viewMode === "detail" && detailTaskId && detailOutput) {
         const task = tasks.find((t) => t.id === detailTaskId);
         if (!task) {
-            setViewMode("list");
+            dispatch({ type: "RESET_DETAIL" });
             return null;
         }
         return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", borderBottom: false, borderLeft: false, borderRight: false, paddingTop: 1, gap: 1, children: [_jsx(Box, { children: _jsxs(Text, { color: "cyan", bold: true, children: ["Background Task Details: ", task.id] }) }), _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Type:" }), " ", task.type] }) }), task.description && (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Description:" }), " ", task.description] }) })), _jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Status:" }), " ", task.status, task.exitCode !== undefined && ` (exit code: ${task.exitCode})`] }) }), _jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Started:" }), " ", formatTime(task.startTime), task.runtime !== undefined && (_jsxs(Text, { children: [" ", "| ", _jsx(Text, { color: "blue", children: "Runtime:" }), " ", formatDuration(task.runtime)] }))] }) }), task.outputPath && (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Log File:" }), " ", task.outputPath] }) }))] }), detailOutput.stdout && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "green", bold: true, children: "OUTPUT (last 10 lines):" }), _jsx(Box, { borderStyle: "single", borderColor: "green", padding: 1, children: _jsx(Text, { children: getLastLines(detailOutput.stdout, 10) }) })] })), detailOutput.stderr && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "red", bold: true, children: "ERRORS:" }), _jsx(Box, { borderStyle: "single", borderColor: "red", padding: 1, children: _jsx(Text, { color: "red", children: getLastLines(detailOutput.stderr, 10) }) })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [task.status === "running" ? "k to stop · " : "", "Esc to go back"] }) })] }));

package/dist/components/ChatInterface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChatInterface.d.ts","sourceRoot":"","sources":["../../src/components/ChatInterface.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAa3D,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAgIjC,CAAC"}
+{"version":3,"file":"ChatInterface.d.ts","sourceRoot":"","sources":["../../src/components/ChatInterface.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAa3D,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EA+HjC,CAAC"}

package/dist/components/ChatInterface.js

@@ -37,5 +37,5 @@ export const ChatInterface = () => {
     ]);
     if (!sessionId)
         return null;
-    return (_jsxs(Box, { ref: chatInterfaceRef, flexDirection: "column", children: [_jsx(MessageList, { messages: displayMessages, isExpanded: isExpanded, version: version, workdir: workdir, forceStatic: forceStatic }, remountKey), !isConfirmationVisible && !isExpanded && (_jsxs(_Fragment, { children: [(isLoading || isCommandRunning || isCompressing) && (_jsx(LoadingIndicator, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompressing: isCompressing, latestTotalTokens: latestTotalTokens })), _jsx(TaskList, {}), _jsx(QueuedMessageList, {}), _jsx(InputBox, { isLoading: isLoading, isCommandRunning: isCommandRunning, sendMessage: sendMessage, abortMessage: abortMessage, mcpServers: mcpServers, connectMcpServer: connectMcpServer, disconnectMcpServer: disconnectMcpServer, slashCommands: slashCommands, hasSlashCommand: hasSlashCommand })] })), isConfirmationVisible && (_jsxs(_Fragment, { children: [forceStatic ? (_jsx(Static, { items: [{ key: "confirmation-details" }], children: () => (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, isExpanded: isExpanded }, "confirmation-details")) })) : (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, isExpanded: isExpanded })), _jsx(ConfirmationSelector, { toolName: confirmingTool.name, toolInput: confirmingTool.input, suggestedPrefix: confirmingTool.suggestedPrefix, hidePersistentOption: confirmingTool.hidePersistentOption, isExpanded: isExpanded, onDecision: handleConfirmationDecision, onCancel: handleConfirmationCancel, onAbort: abortMessage })] }))] }));
+    return (_jsxs(Box, { ref: chatInterfaceRef, flexDirection: "column", children: [_jsx(MessageList, { messages: displayMessages, isExpanded: isExpanded, version: version, workdir: workdir, forceStatic: forceStatic }, remountKey), !isConfirmationVisible && !isExpanded && (_jsxs(_Fragment, { children: [(isLoading || isCommandRunning || isCompressing) && (_jsx(LoadingIndicator, { isLoading: isLoading, isCommandRunning: isCommandRunning, isCompressing: isCompressing, latestTotalTokens: latestTotalTokens })), _jsx(TaskList, {}), _jsx(QueuedMessageList, {}), _jsx(InputBox, { isLoading: isLoading, isCommandRunning: isCommandRunning, sendMessage: sendMessage, abortMessage: abortMessage, mcpServers: mcpServers, connectMcpServer: connectMcpServer, disconnectMcpServer: disconnectMcpServer, slashCommands: slashCommands, hasSlashCommand: hasSlashCommand })] })), isConfirmationVisible && (_jsxs(_Fragment, { children: [forceStatic ? (_jsx(Static, { items: [{ key: "confirmation-details" }], children: () => (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, isExpanded: isExpanded }, "confirmation-details")) })) : (_jsx(ConfirmationDetails, { toolName: confirmingTool.name, toolInput: confirmingTool.input, planContent: confirmingTool.planContent, isExpanded: isExpanded })), _jsx(ConfirmationSelector, { toolName: confirmingTool.name, toolInput: confirmingTool.input, suggestedPrefix: confirmingTool.suggestedPrefix, hidePersistentOption: confirmingTool.hidePersistentOption, isExpanded: isExpanded, onDecision: handleConfirmationDecision, onCancel: handleConfirmationCancel })] }))] }));
 };

package/dist/components/ConfirmationSelector.d.ts

@@ -8,7 +8,6 @@ export interface ConfirmationSelectorProps {
     isExpanded?: boolean;
     onDecision: (decision: PermissionDecision) => void;
     onCancel: () => void;
-    onAbort: () => void;
 }
 export declare const ConfirmationSelector: React.FC<ConfirmationSelectorProps>;
 //# sourceMappingURL=ConfirmationSelector.d.ts.map

package/dist/components/ConfirmationSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConfirmationSelector.d.ts","sourceRoot":"","sources":["../../src/components/ConfirmationSelector.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAE3D,OAAO,KAAK,EAAE,kBAAkB,EAAwB,MAAM,gBAAgB,CAAC;AAiB/E,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACnD,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AASD,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CA6nBpE,CAAC"}
+{"version":3,"file":"ConfirmationSelector.d.ts","sourceRoot":"","sources":["../../src/components/ConfirmationSelector.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgC,MAAM,OAAO,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAwB,MAAM,gBAAgB,CAAC;AAsB/E,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACnD,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CA0cpE,CAAC"}

package/dist/components/ConfirmationSelector.js

@@ -1,7 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useReducer } from "react";
 import { Box, Text, useInput } from "ink";
 import { BASH_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "wave-agent-sdk";
+import { confirmationReducer, } from "../reducers/confirmationReducer.js";
+import { questionReducer } from "../reducers/questionReducer.js";
 const getHeaderColor = (header) => {
     const colors = ["red", "green", "blue", "magenta", "cyan"];
     let hash = 0;
@@ -10,14 +12,16 @@ const getHeaderColor = (header) => {
     }
     return colors[Math.abs(hash) % colors.length];
 };
-export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hidePersistentOption, isExpanded = false, onDecision, onCancel, onAbort, }) => {
-    const [state, setState] = useState({
+export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hidePersistentOption, isExpanded = false, onDecision, onCancel, }) => {
+    const [state, dispatch] = useReducer(confirmationReducer, {
         selectedOption: toolName === EXIT_PLAN_MODE_TOOL_NAME ? "clear" : "allow",
         alternativeText: "",
         alternativeCursorPosition: 0,
         hasUserInput: false,
+        decision: null,
     });
-    const [questionState, setQuestionState] = useState({
+    const questions = toolInput?.questions || [];
+    const [questionState, questionDispatch] = useReducer(questionReducer, {
         currentQuestionIndex: 0,
         selectedOptionIndex: 0,
         selectedOptionIndices: new Set(),
@@ -25,16 +29,19 @@ export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hid
         otherText: "",
         otherCursorPosition: 0,
         savedStates: {},
+        decision: null,
     });
-    const pendingDecisionRef = useRef(null);
+    // Handle decisions from reducers
     useEffect(() => {
-        if (pendingDecisionRef.current) {
-            const decision = pendingDecisionRef.current;
-            pendingDecisionRef.current = null;
-            onDecision(decision);
+        if (state.decision) {
+            onDecision(state.decision);
         }
-    });
-    const questions = toolInput?.questions || [];
+    }, [state.decision, onDecision]);
+    useEffect(() => {
+        if (questionState.decision) {
+            onDecision(questionState.decision);
+        }
+    }, [questionState.decision, onDecision]);
     const currentQuestion = questions[questionState.currentQuestionIndex];
     const getAutoOptionText = () => {
         if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
@@ -58,7 +65,6 @@ export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hid
     useInput((input, key) => {
         if (key.escape) {
             onCancel();
-            onAbort();
             return;
         }
         if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
@@ -67,278 +73,148 @@ export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hid
             const options = [...currentQuestion.options, { label: "Other" }];
             const isMultiSelect = currentQuestion.multiSelect;
             if (key.return) {
-                setQuestionState((prev) => {
-                    const isOtherFocused = prev.selectedOptionIndex === options.length - 1;
-                    let answer = "";
-                    if (isMultiSelect) {
-                        const selectedLabels = Array.from(prev.selectedOptionIndices)
-                            .filter((i) => i < currentQuestion.options.length)
-                            .map((i) => currentQuestion.options[i].label);
-                        const isOtherChecked = prev.selectedOptionIndices.has(options.length - 1);
-                        if (isOtherChecked && prev.otherText.trim()) {
-                            selectedLabels.push(prev.otherText.trim());
-                        }
-                        answer = selectedLabels.join(", ");
-                    }
-                    else {
-                        if (isOtherFocused) {
-                            answer = prev.otherText.trim();
-                        }
-                        else {
-                            answer = options[prev.selectedOptionIndex].label;
-                        }
-                    }
-                    if (!answer)
-                        return prev;
-                    const newAnswers = {
-                        ...prev.userAnswers,
-                        [currentQuestion.question]: answer,
-                    };
-                    if (prev.currentQuestionIndex < questions.length - 1) {
-                        const nextIndex = prev.currentQuestionIndex + 1;
-                        const savedStates = {
-                            ...prev.savedStates,
-                            [prev.currentQuestionIndex]: {
-                                selectedOptionIndex: prev.selectedOptionIndex,
-                                selectedOptionIndices: prev.selectedOptionIndices,
-                                otherText: prev.otherText,
-                                otherCursorPosition: prev.otherCursorPosition,
-                            },
-                        };
-                        const nextState = savedStates[nextIndex] || {
-                            selectedOptionIndex: 0,
-                            selectedOptionIndices: new Set(),
-                            otherText: "",
-                            otherCursorPosition: 0,
-                        };
-                        return {
-                            ...prev,
-                            currentQuestionIndex: nextIndex,
-                            ...nextState,
-                            userAnswers: newAnswers,
-                            savedStates,
-                        };
-                    }
-                    else {
-                        const finalAnswers = { ...newAnswers };
-                        // Also collect from savedStates for any questions that were skipped via Tab
-                        for (const [idxStr, s] of Object.entries(prev.savedStates)) {
-                            const idx = parseInt(idxStr);
-                            const q = questions[idx];
-                            if (q && !finalAnswers[q.question]) {
-                                const opts = [...q.options, { label: "Other" }];
-                                let a = "";
-                                if (q.multiSelect) {
-                                    const selectedLabels = Array.from(s.selectedOptionIndices)
-                                        .filter((i) => i < q.options.length)
-                                        .map((i) => q.options[i].label);
-                                    const isOtherChecked = s.selectedOptionIndices.has(opts.length - 1);
-                                    if (isOtherChecked && s.otherText.trim()) {
-                                        selectedLabels.push(s.otherText.trim());
-                                    }
-                                    a = selectedLabels.join(", ");
-                                }
-                                else {
-                                    if (s.selectedOptionIndex === opts.length - 1) {
-                                        a = s.otherText.trim();
-                                    }
-                                    else {
-                                        a = opts[s.selectedOptionIndex].label;
-                                    }
-                                }
-                                if (a)
-                                    finalAnswers[q.question] = a;
-                            }
-                        }
-                        // Only submit if all questions have been answered
-                        const allAnswered = questions.every((q) => finalAnswers[q.question]);
-                        if (!allAnswered)
-                            return prev;
-                        pendingDecisionRef.current = {
-                            behavior: "allow",
-                            message: JSON.stringify(finalAnswers),
-                        };
-                        return {
-                            ...prev,
-                            userAnswers: finalAnswers,
-                        };
-                    }
+                questionDispatch({
+                    type: "CONFIRM_ANSWER",
+                    currentQuestion,
+                    options,
+                    isMultiSelect: !!isMultiSelect,
+                    questions,
                 });
                 return;
             }
             if (input === " ") {
-                setQuestionState((prev) => {
-                    const isOtherFocused = prev.selectedOptionIndex === options.length - 1;
-                    if (isMultiSelect &&
-                        (!isOtherFocused ||
-                            !prev.selectedOptionIndices.has(prev.selectedOptionIndex))) {
-                        const nextIndices = new Set(prev.selectedOptionIndices);
-                        if (nextIndices.has(prev.selectedOptionIndex))
-                            nextIndices.delete(prev.selectedOptionIndex);
-                        else
-                            nextIndices.add(prev.selectedOptionIndex);
-                        return {
-                            ...prev,
-                            selectedOptionIndices: nextIndices,
-                        };
-                    }
-                    return prev;
-                });
+                const isOtherFocused = questionState.selectedOptionIndex === options.length - 1;
+                if (isMultiSelect &&
+                    (!isOtherFocused ||
+                        !questionState.selectedOptionIndices.has(questionState.selectedOptionIndex))) {
+                    questionDispatch({
+                        type: "TOGGLE_MULTI_SELECT",
+                        optionsLength: options.length,
+                    });
+                    return;
+                }
                 // If it's other and focused, we don't return here, allowing the input handler below to handle it
             }
             if (key.upArrow) {
-                setQuestionState((prev) => ({
-                    ...prev,
-                    selectedOptionIndex: Math.max(0, prev.selectedOptionIndex - 1),
-                }));
+                questionDispatch({
+                    type: "MOVE_OPTION_UP",
+                    maxIndex: options.length - 1,
+                });
                 return;
             }
             if (key.downArrow) {
-                setQuestionState((prev) => ({
-                    ...prev,
-                    selectedOptionIndex: Math.min(options.length - 1, prev.selectedOptionIndex + 1),
-                }));
+                questionDispatch({
+                    type: "MOVE_OPTION_DOWN",
+                    maxIndex: options.length - 1,
+                });
                 return;
             }
             if (key.tab) {
-                setQuestionState((prev) => {
-                    const direction = key.shift ? -1 : 1;
-                    let nextIndex = prev.currentQuestionIndex + direction;
-                    if (nextIndex < 0)
-                        nextIndex = questions.length - 1;
-                    if (nextIndex >= questions.length)
-                        nextIndex = 0;
-                    if (nextIndex === prev.currentQuestionIndex)
-                        return prev;
-                    const savedStates = {
-                        ...prev.savedStates,
-                        [prev.currentQuestionIndex]: {
-                            selectedOptionIndex: prev.selectedOptionIndex,
-                            selectedOptionIndices: prev.selectedOptionIndices,
-                            otherText: prev.otherText,
-                            otherCursorPosition: prev.otherCursorPosition,
-                        },
-                    };
-                    const nextState = savedStates[nextIndex] || {
-                        selectedOptionIndex: 0,
-                        selectedOptionIndices: new Set(),
-                        otherText: "",
-                        otherCursorPosition: 0,
-                    };
-                    return {
-                        ...prev,
-                        currentQuestionIndex: nextIndex,
-                        ...nextState,
-                        savedStates,
-                    };
+                questionDispatch({
+                    type: "CYCLE_QUESTION",
+                    shift: key.shift,
+                    questionCount: questions.length,
+                });
+                return;
+            }
+            // Always dispatch Other actions unconditionally; the reducer checks
+            // isOtherFocused from the latest state, so this works correctly even
+            // when inputs are batched before React re-renders.
+            if (key.leftArrow) {
+                questionDispatch({
+                    type: "MOVE_OTHER_LEFT",
+                    optionsLength: options.length,
+                });
+                return;
+            }
+            if (key.rightArrow) {
+                questionDispatch({
+                    type: "MOVE_OTHER_RIGHT",
+                    optionsLength: options.length,
+                });
+                return;
+            }
+            if (key.backspace || key.delete) {
+                questionDispatch({
+                    type: "DELETE_OTHER",
+                    optionsLength: options.length,
+                });
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                questionDispatch({
+                    type: "INSERT_OTHER",
+                    text: input,
+                    optionsLength: options.length,
                 });
                 return;
             }
-            setQuestionState((prev) => {
-                const isOtherFocused = prev.selectedOptionIndex === options.length - 1;
-                if (isOtherFocused) {
-                    if (key.leftArrow) {
-                        return {
-                            ...prev,
-                            otherCursorPosition: Math.max(0, prev.otherCursorPosition - 1),
-                        };
-                    }
-                    if (key.rightArrow) {
-                        return {
-                            ...prev,
-                            otherCursorPosition: Math.min(prev.otherText.length, prev.otherCursorPosition + 1),
-                        };
-                    }
-                    if (key.backspace || key.delete) {
-                        if (prev.otherCursorPosition > 0) {
-                            return {
-                                ...prev,
-                                otherText: prev.otherText.slice(0, prev.otherCursorPosition - 1) +
-                                    prev.otherText.slice(prev.otherCursorPosition),
-                                otherCursorPosition: prev.otherCursorPosition - 1,
-                            };
-                        }
-                    }
-                    if (input && !key.ctrl && !key.meta) {
-                        return {
-                            ...prev,
-                            otherText: prev.otherText.slice(0, prev.otherCursorPosition) +
-                                input +
-                                prev.otherText.slice(prev.otherCursorPosition),
-                            otherCursorPosition: prev.otherCursorPosition + input.length,
-                        };
-                    }
-                }
-                return prev;
-            });
             return;
         }
         if (key.return) {
+            let decision = null;
             if (state.selectedOption === "clear") {
-                onDecision({
+                decision = {
                     behavior: "allow",
                     newPermissionMode: "acceptEdits",
                     clearContext: true,
-                });
+                };
             }
             else if (state.selectedOption === "allow") {
                 if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
-                    onDecision({ behavior: "allow", newPermissionMode: "default" });
+                    decision = { behavior: "allow", newPermissionMode: "default" };
                 }
                 else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-                    onDecision({ behavior: "allow", newPermissionMode: "plan" });
+                    decision = { behavior: "allow", newPermissionMode: "plan" };
                 }
                 else {
-                    onDecision({ behavior: "allow" });
+                    decision = { behavior: "allow" };
                 }
             }
             else if (state.selectedOption === "auto") {
                 if (toolName === BASH_TOOL_NAME) {
                     const command = toolInput?.command || "";
                     if (command.trim().startsWith("mkdir")) {
-                        onDecision({ behavior: "allow", newPermissionMode: "acceptEdits" });
+                        decision = { behavior: "allow", newPermissionMode: "acceptEdits" };
                     }
                     else {
                         const rule = suggestedPrefix
                             ? `Bash(${suggestedPrefix})`
                             : `Bash(${toolInput?.command})`;
-                        onDecision({ behavior: "allow", newPermissionRule: rule });
+                        decision = { behavior: "allow", newPermissionRule: rule };
                     }
                 }
                 else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-                    onDecision({ behavior: "allow", newPermissionMode: "plan" });
+                    decision = { behavior: "allow", newPermissionMode: "plan" };
                 }
                 else if (toolName.startsWith("mcp__")) {
-                    onDecision({ behavior: "allow", newPermissionRule: toolName });
+                    decision = { behavior: "allow", newPermissionRule: toolName };
                 }
                 else {
-                    onDecision({ behavior: "allow", newPermissionMode: "acceptEdits" });
+                    decision = { behavior: "allow", newPermissionMode: "acceptEdits" };
                 }
             }
             else if (state.alternativeText.trim()) {
-                onDecision({ behavior: "deny", message: state.alternativeText.trim() });
+                decision = { behavior: "deny", message: state.alternativeText.trim() };
             }
             else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-                onDecision({
+                decision = {
                     behavior: "deny",
                     message: "User chose not to enter plan mode",
-                });
+                };
+            }
+            if (decision) {
+                dispatch({ type: "CONFIRM", decision });
             }
             return;
         }
         if (state.selectedOption === "alternative") {
             if (key.leftArrow) {
-                setState((prev) => ({
-                    ...prev,
-                    alternativeCursorPosition: Math.max(0, prev.alternativeCursorPosition - 1),
-                }));
+                dispatch({ type: "MOVE_CURSOR_LEFT" });
                 return;
             }
             if (key.rightArrow) {
-                setState((prev) => ({
-                    ...prev,
-                    alternativeCursorPosition: Math.min(prev.alternativeText.length, prev.alternativeCursorPosition + 1),
-                }));
+                dispatch({ type: "MOVE_CURSOR_RIGHT" });
                 return;
             }
         }
@@ -352,20 +228,20 @@ export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hid
         if (key.upArrow) {
             const currentIndex = availableOptions.indexOf(state.selectedOption);
             if (currentIndex > 0) {
-                setState((prev) => ({
-                    ...prev,
-                    selectedOption: availableOptions[currentIndex - 1],
-                }));
+                dispatch({
+                    type: "SELECT_OPTION",
+                    option: availableOptions[currentIndex - 1],
+                });
             }
             return;
         }
         if (key.downArrow) {
             const currentIndex = availableOptions.indexOf(state.selectedOption);
             if (currentIndex < availableOptions.length - 1) {
-                setState((prev) => ({
-                    ...prev,
-                    selectedOption: availableOptions[currentIndex + 1],
-                }));
+                dispatch({
+                    type: "SELECT_OPTION",
+                    option: availableOptions[currentIndex + 1],
+                });
             }
             return;
         }
@@ -377,42 +253,18 @@ export const ConfirmationSelector = ({ toolName, toolInput, suggestedPrefix, hid
                 nextIndex = availableOptions.length - 1;
             if (nextIndex >= availableOptions.length)
                 nextIndex = 0;
-            setState((prev) => ({
-                ...prev,
-                selectedOption: availableOptions[nextIndex],
-            }));
+            dispatch({
+                type: "SELECT_OPTION",
+                option: availableOptions[nextIndex],
+            });
             return;
         }
         if (input && !key.ctrl && !key.meta && !("alt" in key && key.alt)) {
-            setState((prev) => {
-                const nextText = prev.alternativeText.slice(0, prev.alternativeCursorPosition) +
-                    input +
-                    prev.alternativeText.slice(prev.alternativeCursorPosition);
-                return {
-                    ...prev,
-                    selectedOption: "alternative",
-                    alternativeText: nextText,
-                    alternativeCursorPosition: prev.alternativeCursorPosition + input.length,
-                    hasUserInput: true,
-                };
-            });
+            dispatch({ type: "INSERT_TEXT", text: input });
             return;
         }
         if (key.backspace || key.delete) {
-            setState((prev) => {
-                if (prev.alternativeCursorPosition > 0) {
-                    const nextText = prev.alternativeText.slice(0, prev.alternativeCursorPosition - 1) +
-                        prev.alternativeText.slice(prev.alternativeCursorPosition);
-                    return {
-                        ...prev,
-                        selectedOption: "alternative",
-                        alternativeText: nextText,
-                        alternativeCursorPosition: prev.alternativeCursorPosition - 1,
-                        hasUserInput: nextText.length > 0,
-                    };
-                }
-                return prev;
-            });
+            dispatch({ type: "BACKSPACE" });
             return;
         }
     });