@qduc/term2 0.7.2 → 0.8.0

package/dist/hooks/use-conversation.js

@@ -1,18 +1,28 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { isAbortLikeError } from '../utils/error-helpers.js';
-import { appendMessagesCapped } from '../utils/message-buffer.js';
+import { useCallback, useEffect, useReducer, useRef } from 'react';
+import { describeError, isAbortLikeError } from '../utils/error-helpers.js';
+import { ASK_USER_DECLINE_RESULT } from '../tools/agent/ask-user-constants.js';
 import { createMessageId } from './message-id.js';
-import { enhanceApiKeyError, isMaxTurnsError } from '../utils/conversation-utils.js';
-import { createStreamingSession } from '../utils/streaming-session-factory.js';
+import { countUndoableUserTurnsFrom, findLastUndoableUserMessage } from '../utils/conversation/message-utils.js';
+import { clearStreamingBotMessage, computeNextMessages } from '../utils/conversation/apply-conversation-result.js';
+import { useConversationMessages } from './use-conversation-messages.js';
+import { useConversationSettings } from './use-conversation-settings.js';
+import { enhanceApiKeyError, isMaxTurnsError } from '../utils/conversation/conversation-utils.js';
+import { createStreamingSession } from '../utils/streaming/streaming-session-factory.js';
+import { isBotMessage, isUserMessage } from '../types/message.js';
 import { useSetting } from './use-setting.js';
-import { annotateApprovedCommandMessage, filterPendingCommandMessagesForApproval, } from '../services/approval-presentation-policy.js';
-import { formatUserTurnForDisplay, hasUserTurnContent, normalizeUserTurn } from '../types/user-turn.js';
+import { annotateApprovedCommandMessage, filterPendingCommandMessagesForApproval, } from '../services/approval/approval-presentation-policy.js';
+import { formatUserTurnForDisplay, hasUserTurnContent, injectSkillIntoTurn, normalizeUserTurn, } from '../types/user-turn.js';
+import { conversationUIReducer, createInitialUIState, getConversationUIFlags } from './conversation-ui-reducer.js';
 const REASONING_RESPONSE_THROTTLE_MS = 200;
 const MAX_MESSAGE_COUNT = 300;
+const clearsThinkingIndicator = (eventType) => eventType === 'text_delta' ||
+    eventType === 'tool_started' ||
+    eventType === 'tool_call_streaming_delta' ||
+    eventType === 'final';
 const getInitialLastUsage = (messages) => {
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
-        if (message.sender !== 'bot') {
+        if (!isBotMessage(message)) {
             continue;
         }
         const usage = message.usage;
@@ -27,25 +37,27 @@ const dummySettingsService = {
     onChange: () => () => { },
 };
 export const useConversation = ({ conversationService, loggingService, usageAccumulator, subagentUsageAccumulator, initialMessages = [], sessionId, onClear, settingsService, onRestoreInput, logWriter, notifier, }) => {
-    const [messages, setMessages] = useState(() => appendMessagesCapped([], initialMessages, MAX_MESSAGE_COUNT));
-    const [waitingForApproval, setWaitingForApproval] = useState(false);
-    const [waitingForRejectionReason, setWaitingForRejectionReason] = useState(false);
-    const [pendingApproval, setPendingApproval] = useState(null);
-    const [isProcessing, setIsProcessing] = useState(false);
-    const [lastUsage, setLastUsage] = useState(() => getInitialLastUsage(initialMessages));
-    const [lastCodexRateLimit, setLastCodexRateLimit] = useState(null);
-    const setCodexRateLimit = setLastCodexRateLimit;
+    const { messages, setMessages, trimMessages, appendMessages, addSystemMessage, addShellMessage, getUserMessages } = useConversationMessages({
+        initialMessages,
+        maxMessageCount: MAX_MESSAGE_COUNT,
+    });
+    const { setModel, setReasoningEffort, setTemperature } = useConversationSettings({
+        conversationService,
+    });
+    const [uiState, dispatch] = useReducer(conversationUIReducer, initialMessages, (init) => createInitialUIState(getInitialLastUsage(init)));
+    const { thinkingStartedAt, toolCallStreamingInfo, lastUsage, lastCodexRateLimit } = uiState;
+    const { isProcessing, waitingForApproval, waitingForRejectionReason, waitingForAskUserAnswer, askUserAnswers, currentAskUserQuestionIndex, pendingApproval, } = getConversationUIFlags(uiState);
     const approvedContextRef = useRef(null);
-    const trimMessages = useCallback((list) => appendMessagesCapped(list, [], MAX_MESSAGE_COUNT), []);
+    // Use a ref to keep askUserAnswers current for the handleApprovalDecision callback
+    // This fixes the stale closure bug in multi-question ask_user flows
+    const askUserAnswersRef = useRef(askUserAnswers);
+    useEffect(() => {
+        askUserAnswersRef.current = askUserAnswers;
+    }, [askUserAnswers]);
     const provider = useSetting(settingsService || dummySettingsService, 'agent.provider') ?? 'openai';
     useEffect(() => {
-        setLastCodexRateLimit(null);
+        dispatch({ type: 'rate_limit/cleared' });
     }, [provider]);
-    const appendMessages = useCallback((additions) => {
-        if (!additions.length)
-            return;
-        setMessages((prev) => trimMessages([...prev, ...additions]));
-    }, [trimMessages]);
     const annotateCommandMessage = useCallback((cmdMsg) => {
         const approvedMessage = annotateApprovedCommandMessage(cmdMsg, approvedContextRef.current);
         const matchedByToolName = approvedMessage !== cmdMsg &&
@@ -59,13 +71,29 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
     }, []);
     const createOnEventWithSubagentTracking = useCallback((baseOnEvent) => {
         return (event) => {
+            const eventType = typeof event?.type === 'string' ? event.type : undefined;
+            if (eventType === 'reasoning_delta') {
+                dispatch({ type: 'streaming/thinking_started', timestamp: Date.now() });
+            }
+            else if (eventType && clearsThinkingIndicator(eventType)) {
+                dispatch({ type: 'streaming/thinking_cleared' });
+            }
+            if (eventType === 'tool_call_streaming_delta') {
+                dispatch({
+                    type: 'streaming/tool_info',
+                    info: { toolName: event.toolName, argumentCharCount: event.argumentCharCount },
+                });
+            }
+            else if (eventType === 'tool_started' || eventType === 'text_delta' || eventType === 'final') {
+                dispatch({ type: 'streaming/tool_info', info: null });
+            }
             baseOnEvent(event);
             if (subagentUsageAccumulator && event?.type === 'subagent_completed' && event?.result?.usage) {
                 subagentUsageAccumulator.add(event.result.usage);
             }
         };
     }, [subagentUsageAccumulator]);
-    const applyServiceResult = useCallback((result, textWasFlushed, latestStreamedUsage) => {
+    const applyServiceResult = useCallback((result, streamingState, latestStreamedUsage) => {
         if (!result) {
             return;
         }
@@ -76,60 +104,51 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
                 // `response` result will carry the full run-cumulative usage once
                 // the run completes, so accumulating here would double-count the
                 // pre-approval turns. Only update the live footer.
-                setLastUsage(latestStreamedUsage ?? result.usage);
+                dispatch({ type: 'usage/updated', usage: latestStreamedUsage ?? result.usage });
             }
             // Don't also show the transient pending/running command message.
             setMessages((prev) => trimMessages(filterPendingCommandMessagesForApproval(prev, result.approval)));
-            setPendingApproval({
-                ...result.approval,
-                llmAdvisory: result.approval.llmAdvisory,
+            dispatch({
+                type: 'approval/requested',
+                approval: { ...result.approval, llmAdvisory: result.approval.llmAdvisory },
             });
-            // Set waiting state AFTER adding approval message to ensure proper render order
-            setWaitingForApproval(true);
             notifier?.approvalNeeded();
             return;
         }
-        const finalText = result.finalText;
-        setMessages((prev) => {
-            const annotatedCommands = result.commandMessages.map(annotateCommandMessage);
-            // Remove stale running/pending messages that are about to be replaced
-            // by completed ones (e.g. after a denied tool where a "running" message
-            // was shown during streaming but the final result never cleaned it up).
-            const completedCallIds = new Set(annotatedCommands.filter((m) => m.callId).map((m) => m.callId));
-            const cleaned = completedCallIds.size > 0
-                ? prev.filter((msg) => {
-                    if (msg.sender !== 'command')
-                        return true;
-                    const cmd = msg;
-                    if (cmd.status !== 'running' && cmd.status !== 'pending')
-                        return true;
-                    return !cmd.callId || !completedCallIds.has(cmd.callId);
-                })
-                : prev;
-            let next = [...cleaned, ...annotatedCommands];
-            // Append finalText only when streaming never pushed it via text_delta/final events.
-            // Providers that skip streaming (synchronous or non-interactive) may return text
-            // solely in result.finalText without emitting any text_delta events.
-            if (finalText?.trim() && !textWasFlushed) {
-                const botMessage = {
-                    id: createMessageId(),
-                    sender: 'bot',
-                    status: 'finalized',
-                    text: finalText,
-                };
-                next = [...next, botMessage];
-            }
-            return trimMessages(next);
-        });
-        setWaitingForApproval(false);
-        setPendingApproval(null);
+        // Apply the response result via the pure helper. The helper finalizes
+        // the live streaming bot message in place when one exists, instead of
+        // appending a duplicate finalized copy. This prevents the assistant's
+        // reply from rendering twice when streaming text never crossed a safe
+        // markdown boundary.
+        setMessages((prev) => computeNextMessages({
+            prev,
+            result,
+            streamingState,
+            createMessageId,
+            trimMessages,
+            annotateCommandMessage,
+        }).next);
+        if (result.type === 'response' && streamingState.currentBotMessageId !== null) {
+            clearStreamingBotMessage(streamingState);
+        }
+        dispatch({ type: 'approval/resolved' });
         notifier?.turnComplete();
         if (result.usage) {
             usageAccumulator?.add(result.usage);
-            setLastUsage(latestStreamedUsage ?? result.usage);
+            dispatch({ type: 'usage/updated', usage: latestStreamedUsage ?? result.usage });
         }
     }, [annotateCommandMessage, trimMessages, usageAccumulator, notifier]);
-    const sendUserMessage = useCallback(async (input) => {
+    const createTurnSession = useCallback((label) => createStreamingSession({
+        appendMessages,
+        setMessages,
+        trimMessages,
+        annotateCommandMessage,
+        loggingService,
+        setLastUsage: (usage) => dispatch({ type: 'usage/updated', usage }),
+        setCodexRateLimit: (rateLimit) => dispatch({ type: 'rate_limit/updated', rateLimit }),
+        reasoningThrottleMs: REASONING_RESPONSE_THROTTLE_MS,
+    }, label), [appendMessages, setMessages, trimMessages, annotateCommandMessage, loggingService]);
+    const sendUserMessage = useCallback(async (input, options) => {
         const turn = normalizeUserTurn(input);
         if (!hasUserTurnContent(turn)) {
             return;
@@ -138,26 +157,18 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
             id: createMessageId(),
             sender: 'user',
             text: formatUserTurnForDisplay(turn),
+            ...(turn.skill ? { skill: turn.skill } : {}),
         };
         appendMessages([userMessage]);
         logWriter?.append({ type: 'user_message', message: userMessage });
-        setIsProcessing(true);
-        const { botResponseUpdater, reasoningUpdater, applyConversationEvent, streamingState } = createStreamingSession({
-            appendMessages,
-            setMessages,
-            trimMessages,
-            annotateCommandMessage,
-            loggingService,
-            setLastUsage,
-            setCodexRateLimit,
-            reasoningThrottleMs: REASONING_RESPONSE_THROTTLE_MS,
-        }, 'sendUserMessage');
+        dispatch({ type: 'turn/started' });
+        const { botResponseUpdater, reasoningUpdater, applyConversationEvent, streamingState } = createTurnSession('sendUserMessage');
         const wrappedOnEvent = (event) => {
             if (event?.type === 'user_message_consumed_for_abort') {
                 setMessages((prev) => {
                     for (let i = prev.length - 1; i >= 0; i--) {
                         const msg = prev[i];
-                        if (msg.sender === 'user') {
+                        if (isUserMessage(msg)) {
                             if (msg.consumedForAbort)
                                 return prev;
                             const next = prev.slice();
@@ -172,25 +183,23 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
             applyConversationEvent(event);
         };
         try {
-            const result = await conversationService.sendMessage(turn, {
+            // Inject skill content into the turn text before sending to AI
+            const turnToSend = turn.skill ? injectSkillIntoTurn(turn) : turn;
+            const result = await conversationService.sendMessage(turnToSend, {
                 onEvent: createOnEventWithSubagentTracking(wrappedOnEvent),
+                bypassInputSurgeGuard: options?.bypassInputSurgeGuard,
             });
             applyConversationEvent({ type: 'final', finalText: '' });
-            applyServiceResult(result, streamingState.textWasFlushed, streamingState.latestUsage);
+            // Flush any throttled bot update so the streaming message reflects the
+            // last delta before we decide whether to finalize it in place.
+            botResponseUpdater.flush();
+            applyServiceResult(result, streamingState, streamingState.latestUsage);
         }
         catch (error) {
             loggingService.error('Error in sendUserMessage', {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : undefined,
                 ...(error instanceof Error && error.eventKind ? { eventKind: error.eventKind } : {}),
-                ...(error instanceof Error && error.rawEvent
-                    ? {
-                        rawEvent: (() => {
-                            const { stack, ...rest } = error.rawEvent;
-                            return rest;
-                        })(),
-                    }
-                    : {}),
             });
             // Don't show error messages for user-initiated aborts
             if (isAbortLikeError(error)) {
@@ -198,7 +207,7 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
                 // The finally block will handle cleanup
                 return;
             }
-            const rawErrorMessage = error instanceof Error ? error.message : String(error);
+            const rawErrorMessage = describeError(error);
             const errorMessage = enhanceApiKeyError(rawErrorMessage);
             // If the session dropped the user turn from the store as part of this
             // error, mirror that in the UI: remove the trailing user message and
@@ -217,14 +226,16 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
             }
             if (isMaxTurnsError(errorMessage)) {
                 // Create an approval prompt for max turns continuation
-                setPendingApproval({
-                    agentName: 'System',
-                    toolName: 'max_turns_exceeded',
-                    argumentsText: errorMessage,
-                    rawInterruption: null,
-                    isMaxTurnsPrompt: true,
+                dispatch({
+                    type: 'approval/requested',
+                    approval: {
+                        agentName: 'System',
+                        toolName: 'max_turns_exceeded',
+                        argumentsText: errorMessage,
+                        rawInterruption: null,
+                        isMaxTurnsPrompt: true,
+                    },
                 });
-                setWaitingForApproval(true);
             }
             else {
                 // For other errors, just show the error message
@@ -236,8 +247,7 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
                 };
                 appendMessages([botErrorMessage]);
                 // Reset approval state on error to allow user to continue
-                setWaitingForApproval(false);
-                setPendingApproval(null);
+                dispatch({ type: 'approval/resolved' });
             }
         }
         finally {
@@ -245,7 +255,7 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
             // flushLog();
             reasoningUpdater.flush();
             botResponseUpdater.cancel();
-            setIsProcessing(false);
+            dispatch({ type: 'turn/completed' });
             // Don't reset waitingForApproval here - it's set by applyServiceResult
             // and should only be cleared by handleApprovalDecision or stopProcessing
         }
@@ -258,38 +268,62 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
         createOnEventWithSubagentTracking,
         onRestoreInput,
     ]);
-    const handleApprovalDecision = useCallback(async (answer, rejectionReason) => {
+    const handleApprovalDecision = useCallback(async (answer, rejectionReason, approvalAnswer) => {
         if (!waitingForApproval || !pendingApproval) {
             return;
         }
         // Check if this is a max turns exceeded prompt
         const isMaxTurnsPrompt = pendingApproval.isMaxTurnsPrompt;
+        const isAskUser = pendingApproval.toolName === 'ask_user';
+        if (isAskUser && answer === 'y' && approvalAnswer !== ASK_USER_DECLINE_RESULT) {
+            // Parse questions
+            let questions = [];
+            try {
+                const parsed = JSON.parse(pendingApproval.argumentsText);
+                questions = parsed.questions || [];
+            }
+            catch { }
+            // Only JSON-parse multi-select arrays; single-select answers are plain strings
+            let parsedAns = approvalAnswer ?? '';
+            const currentQuestion = questions[askUserAnswersRef.current.length];
+            if (currentQuestion?.is_multi_select) {
+                try {
+                    const maybeArray = JSON.parse(approvalAnswer ?? '');
+                    if (Array.isArray(maybeArray)) {
+                        parsedAns = maybeArray;
+                    }
+                }
+                catch {
+                    // Not JSON — keep as plain string
+                }
+            }
+            const nextAnswers = [...askUserAnswersRef.current, parsedAns];
+            if (nextAnswers.length < questions.length) {
+                // More questions to answer!
+                dispatch({ type: 'ask_user/answer_submitted', answer: parsedAns });
+                dispatch({ type: 'ask_user/advance_to_next', nextIndex: nextAnswers.length });
+                return;
+            }
+            // All questions answered — dispatch final answer to complete the ask_user sequence
+            dispatch({ type: 'ask_user/answer_submitted', answer: parsedAns });
+            approvalAnswer = JSON.stringify(nextAnswers);
+        }
         if (answer === 'y') {
             approvedContextRef.current = {
                 callId: pendingApproval.callId,
                 toolName: pendingApproval.toolName,
             };
         }
-        setPendingApproval(null);
-        setWaitingForApproval(false);
+        dispatch({ type: 'approval/resolved' });
         // Handle "n" answer for max turns - return to input
         if (isMaxTurnsPrompt && answer === 'n') {
-            setIsProcessing(false);
+            dispatch({ type: 'turn/completed' });
             return;
         }
         // Handle "y" answer for max turns - continue execution automatically
         if (isMaxTurnsPrompt && answer === 'y') {
-            setIsProcessing(true);
-            const { botResponseUpdater, reasoningUpdater, applyConversationEvent, streamingState } = createStreamingSession({
-                appendMessages,
-                setMessages,
-                trimMessages,
-                annotateCommandMessage,
-                loggingService,
-                setLastUsage,
-                setCodexRateLimit,
-                reasoningThrottleMs: REASONING_RESPONSE_THROTTLE_MS,
-            }, 'maxTurnsContinuation');
+            dispatch({ type: 'turn/started' });
+            const { botResponseUpdater, reasoningUpdater, applyConversationEvent, streamingState } = createTurnSession('maxTurnsContinuation');
             try {
                 // Send a continuation message to resume work
                 const continuationMessage = 'Please continue with your previous task.';
@@ -297,7 +331,7 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
                     onEvent: createOnEventWithSubagentTracking(applyConversationEvent),
                 });
                 applyConversationEvent({ type: 'final', finalText: '' });
-                applyServiceResult(result, streamingState.textWasFlushed, streamingState.latestUsage);
+                applyServiceResult(result, streamingState, streamingState.latestUsage);
             }
             catch (error) {
                 loggingService.error('Error in continuation after max turns', {
@@ -318,34 +352,28 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
                     text: `Error: ${errorMessage}`,
                 };
                 appendMessages([botErrorMessage]);
-                setWaitingForApproval(false);
-                setPendingApproval(null);
+                dispatch({ type: 'approval/resolved' });
             }
             finally {
                 // flushLog();
                 reasoningUpdater.flush();
                 botResponseUpdater.cancel();
-                setIsProcessing(false);
+                dispatch({ type: 'turn/completed' });
             }
             return;
         }
-        setIsProcessing(true);
-        const { botResponseUpdater, reasoningUpdater, applyConversationEvent, streamingState } = createStreamingSession({
-            appendMessages,
-            setMessages,
-            trimMessages,
-            annotateCommandMessage,
-            loggingService,
-            setLastUsage,
-            setCodexRateLimit,
-            reasoningThrottleMs: REASONING_RESPONSE_THROTTLE_MS,
-        }, 'approvalDecision');
+        dispatch({ type: 'turn/started' });
+        const { botResponseUpdater, reasoningUpdater, applyConversationEvent, streamingState } = createTurnSession('approvalDecision');
         try {
             const result = await conversationService.handleApprovalDecision(answer, rejectionReason, {
                 onEvent: createOnEventWithSubagentTracking(applyConversationEvent),
+                approvalAnswer,
             });
             applyConversationEvent({ type: 'final', finalText: '' });
-            applyServiceResult(result, streamingState.textWasFlushed, streamingState.latestUsage);
+            // Flush any throttled bot update so the streaming message reflects the
+            // last delta before we decide whether to finalize it in place.
+            botResponseUpdater.flush();
+            applyServiceResult(result, streamingState, streamingState.latestUsage);
         }
         catch (error) {
             loggingService.error('Error in handleApprovalDecision', {
@@ -367,14 +395,13 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
             };
             appendMessages([botErrorMessage]);
             // Reset approval state on error to allow user to continue
-            setWaitingForApproval(false);
-            setPendingApproval(null);
+            dispatch({ type: 'approval/resolved' });
         }
         finally {
             loggingService.debug('handleApprovalDecision finally block - resetting state');
             reasoningUpdater.flush();
             botResponseUpdater.cancel();
-            setIsProcessing(false);
+            dispatch({ type: 'turn/completed' });
             // Don't reset approval state here - if the result is another approval_required,
             // applyServiceResult will set waitingForApproval=true, but this finally block
             // would immediately clear it, causing the input box to reappear
@@ -389,132 +416,78 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
         loggingService,
         createOnEventWithSubagentTracking,
     ]);
+    const onTypeAnswer = useCallback(() => {
+        dispatch({ type: 'ask_user/set_waiting' });
+    }, []);
     const clearConversation = useCallback(async () => {
         if (onClear) {
             await onClear();
         }
         else {
-            conversationService.resetWithNewId(conversationService.sessionId);
+            conversationService.resetWithNewId(crypto.randomUUID());
         }
         setMessages([]);
-        setWaitingForApproval(false);
-        setWaitingForRejectionReason(false);
-        setPendingApproval(null);
         approvedContextRef.current = null;
-        setIsProcessing(false);
-        setLastUsage(null);
-        setLastCodexRateLimit(null);
+        dispatch({ type: 'reset_all' });
         usageAccumulator?.reset();
         subagentUsageAccumulator?.reset();
     }, [conversationService, usageAccumulator, subagentUsageAccumulator, onClear]);
     const stopProcessing = useCallback(() => {
         conversationService.abort();
-        setWaitingForApproval(false);
-        setWaitingForRejectionReason(false);
-        setPendingApproval(null);
         approvedContextRef.current = null;
-        setIsProcessing(false);
+        dispatch({ type: 'reset_transient' });
     }, [conversationService]);
     const undoLastUserMessage = useCallback(() => {
-        let lastUserIndex = -1;
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const m = messages[i];
-            if (m.sender === 'user' && !m.consumedForAbort) {
-                lastUserIndex = i;
-                break;
-            }
-        }
+        const lastUserIndex = findLastUndoableUserMessage(messages);
         if (lastUserIndex === -1) {
             return null;
         }
         const lastUserMessage = messages[lastUserIndex];
-        const uiText = lastUserMessage.sender === 'user' ? lastUserMessage.text : '';
+        const uiText = isUserMessage(lastUserMessage) ? lastUserMessage.text : '';
         conversationService.abort();
         const removed = conversationService.undoLastUserTurn();
         const restored = removed ?? { text: uiText };
         setMessages((prev) => prev.slice(0, lastUserIndex));
-        setWaitingForApproval(false);
-        setWaitingForRejectionReason(false);
-        setPendingApproval(null);
         approvedContextRef.current = null;
-        setIsProcessing(false);
+        dispatch({ type: 'reset_transient' });
         return restored;
     }, [messages, conversationService]);
-    const getUserMessages = useCallback(() => {
-        const result = [];
-        for (let i = 0; i < messages.length; i++) {
-            const m = messages[i];
-            if (m.sender === 'user' && !m.consumedForAbort) {
-                result.push({ uiIndex: i, text: m.text });
-            }
-        }
-        return result;
-    }, [messages]);
     const undoToUserMessage = useCallback((uiIndex) => {
         // Count how many genuine user turns (excluding abort-consumed messages) are
         // at or after this index — that's what the store needs to roll back.
-        let undoCount = 0;
-        for (let i = uiIndex; i < messages.length; i++) {
-            const m = messages[i];
-            if (m.sender === 'user' && !m.consumedForAbort) {
-                undoCount++;
-            }
-        }
+        const undoCount = countUndoableUserTurnsFrom(messages, uiIndex);
         if (undoCount === 0)
             return null;
         const selectedMessage = messages[uiIndex];
-        const uiText = selectedMessage?.text ?? '';
+        const uiText = isUserMessage(selectedMessage) ? selectedMessage.text : '';
         conversationService.abort();
         const removed = conversationService.undoNUserTurns(undoCount);
         const restored = removed?.text ?? uiText;
         setMessages((prev) => prev.slice(0, uiIndex));
-        setWaitingForApproval(false);
-        setWaitingForRejectionReason(false);
-        setPendingApproval(null);
         approvedContextRef.current = null;
-        setIsProcessing(false);
+        dispatch({ type: 'reset_transient' });
         return restored;
     }, [messages, conversationService]);
-    const setModel = useCallback((model) => {
-        conversationService.setModel(model);
-    }, [conversationService]);
-    const setReasoningEffort = useCallback((effort) => {
-        conversationService.setReasoningEffort(effort);
-    }, [conversationService]);
-    const setTemperature = useCallback((temperature) => {
-        conversationService.setTemperature(temperature);
-    }, [conversationService]);
-    const addSystemMessage = useCallback((text) => {
-        appendMessages([
-            {
-                id: createMessageId(),
-                sender: 'system',
-                text,
-            },
-        ]);
-    }, [appendMessages]);
-    const addShellMessage = useCallback((command, output, exitCode, timedOut) => {
-        const success = !timedOut && exitCode === 0;
-        const failureReason = timedOut
-            ? 'timeout'
-            : exitCode == null
-                ? 'error'
-                : exitCode !== 0
-                    ? `exit ${exitCode}`
-                    : undefined;
-        appendMessages([
-            {
-                id: createMessageId(),
-                sender: 'command',
-                status: success ? 'completed' : 'failed',
-                command,
-                output,
-                success,
-                failureReason,
-                toolName: 'shell',
-            },
-        ]);
-    }, [appendMessages]);
+    // Compatibility wrappers for app.tsx — these dispatch domain actions.
+    const setWaitingForRejectionReason = useCallback((value) => {
+        dispatch({ type: value ? 'rejection/set_waiting' : 'rejection/cleared' });
+    }, []);
+    const setWaitingForAskUserAnswer = useCallback((value) => {
+        dispatch({ type: value ? 'ask_user/set_waiting' : 'ask_user/clear_waiting' });
+    }, []);
+    const goToPreviousQuestion = useCallback(() => {
+        if (currentAskUserQuestionIndex > 0) {
+            dispatch({
+                type: 'ask_user/go_back',
+            });
+        }
+    }, [currentAskUserQuestionIndex]);
+    const goToNextQuestion = useCallback(() => {
+        dispatch({
+            type: 'ask_user/advance_to_next',
+            nextIndex: currentAskUserQuestionIndex + 1,
+        });
+    }, [currentAskUserQuestionIndex]);
     const getSubagentUsage = useCallback(() => subagentUsageAccumulator?.get() ?? null, [subagentUsageAccumulator]);
     return {
         messages,
@@ -524,10 +497,16 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
         pendingApproval,
         waitingForApproval,
         waitingForRejectionReason,
+        waitingForAskUserAnswer,
+        currentAskUserQuestionIndex,
         setWaitingForRejectionReason,
+        setWaitingForAskUserAnswer,
         isProcessing,
+        thinkingStartedAt,
+        toolCallStreamingInfo,
         sendUserMessage,
         handleApprovalDecision,
+        onTypeAnswer,
         clearConversation,
         stopProcessing,
         undoLastUserMessage,
@@ -539,6 +518,8 @@ export const useConversation = ({ conversationService, loggingService, usageAccu
         addSystemMessage,
         addShellMessage,
         getSubagentUsage,
+        goToPreviousQuestion,
+        goToNextQuestion,
     };
 };
 //# sourceMappingURL=use-conversation.js.map