@qduc/term2 0.11.1 → 0.13.0

package/dist/app.js

@@ -7,86 +7,81 @@ import MessageList, { detectStaticCommitBlocker, EMPTY_RESTORED_STATIC_MESSAGE_I
 import BottomArea from './components/layout/BottomArea.js';
 import { ErrorBoundary } from './components/ErrorBoundary.js';
 import { useSetting } from './hooks/use-setting.js';
+import { useDebouncedValue } from './hooks/use-debounced-value.js';
 import { parseInput } from './utils/input-parser.js';
-import { useRuntimeSettings } from './hooks/use-runtime-settings.js';
+import { ConversationConfigurationService } from './services/runtime-setting-router.js';
 import { useShellMode } from './hooks/use-shell-mode.js';
+import { ShellInteractionSession } from './services/shell/shell-interaction-session.js';
 import { useAppCommands } from './hooks/use-app-commands.js';
 import { useHandoffFlow } from './hooks/use-handoff-flow.js';
-import { usePendingTurnGuards } from './hooks/use-pending-turn-guards.js';
 import { useTerminalFocusNotifier } from './hooks/use-terminal-focus-notifier.js';
 import { useAppKeyboardShortcuts } from './hooks/use-app-keyboard-shortcuts.js';
 import { hasUserTurnContent } from './types/user-turn.js';
 import { createUsageAccumulator, formatSessionUsageBreakdown } from './utils/ai/token-usage.js';
-import { resolveSlashCommand } from './slash-commands.js';
+import { createSessionCostAccumulator, formatUsdMicros, } from './services/cost/model-cost.js';
+import { buildRewindItems } from './utils/conversation/rewind-items.js';
+import { tryExecuteSlashCommand } from './utils/slash-command-dispatch.js';
 import { buildTerminalTitleLabel, setTerminalTitle } from './utils/output/terminal-title.js';
+import { deriveInputOwner } from './lib/input-owner.js';
+import { handleSettingsIntent } from './components/input/settings-intent-host.js';
 import { registerSandboxNetworkApprovalHandler, } from './utils/shell/sandbox/sandbox-network-approval.js';
+import { SandboxNetworkApprovalCoordinator } from './utils/shell/sandbox/sandbox-network-approval-coordinator.js';
+import { useFirstRunSetupGate } from './hooks/use-first-run-setup.js';
+import { TOOL_NAME_ASK_USER } from './tools/tool-names.js';
+import { copyToClipboard } from './utils/clipboard.js';
 export { appendStartupBannerId, clearTerminalForRedraw, messagesHaveNonSystemContent, scheduleExitSideEffects, TERMINAL_REDRAW_CLEAR, } from './app-helpers.js';
-const App = ({ conversationService, settingsService, historyService, loggingService, sshInfo, sshService, usageAccumulator, subagentUsageAccumulator, onPrintUsage, onExitUsage, sessionId: initialSessionId, initialMessages = [], restoredStaticMessageIds = EMPTY_RESTORED_STATIC_MESSAGE_IDS, logWriter, onRotateWriter, generateId, onSessionIdChange, onHasConversationContent, skillsService, terminalTitleBase, }) => {
+/**
+ * How long the composer must be quiet before the large-uncached-input advisory
+ * is recomputed. Long enough that a burst of typing costs one pass instead of
+ * one per character, short enough that the notice appears while the user is
+ * still looking at the text that triggered it.
+ */
+const LARGE_UNCACHED_PREVIEW_DEBOUNCE_MS = 250;
+const App = ({ conversationService, settingsService, historyService, loggingService, sshInfo, sshService, usageAccumulator, subagentUsageAccumulator, costAccumulator, onPrintUsage, onExitUsage, sessionId: initialSessionId, initialMessages = [], restoredStaticMessageIds = EMPTY_RESTORED_STATIC_MESSAGE_IDS, logWriter, onRotateWriter, generateId, onSessionIdChange, onHasConversationContent, skillsService, terminalTitleBase, }) => {
     const { exit } = useApp();
     const { stdout } = useStdout();
-    const { setInput, replaceInput, setMode, setTriggerIndex, setImages, setInputAndCursor } = useInputActions();
-    const { input, mode, images } = useInputState();
-    const undoMenuRef = useRef(null);
-    const providersMenuRef = useRef(null);
+    const { setInput, replaceInput, setImages } = useInputActions();
+    const { input, mode, images: _images, controller } = useInputState();
+    const menuOpen = typeof controller.getSnapshot === 'function'
+        ? (controller.getSnapshot().stack?.length ?? 0) > 0
+        : mode !== 'text';
     const [messageListEpoch, setMessageListEpoch] = useState(0);
     const [startupBannerIds, setStartupBannerIds] = useState(['startup-banner-0']);
     const liteMode = useSetting(settingsService, 'app.liteMode') ?? false;
     const displayMode = useSetting(settingsService, 'ui.displayMode') ?? 'standard';
     const sessionUsage = useMemo(() => usageAccumulator ?? createUsageAccumulator(), [usageAccumulator]);
     const subagentUsage = useMemo(() => subagentUsageAccumulator ?? createUsageAccumulator(), [subagentUsageAccumulator]);
+    const sessionCost = useMemo(() => costAccumulator ?? createSessionCostAccumulator(), [costAccumulator]);
     const [sessionId, setSessionId] = useState(initialSessionId);
     const handleClearConversationRef = useRef(null);
     const pendingSkillRef = useRef(null);
+    const sandboxApprovalCoordinatorRef = useRef(null);
     const [sandboxPromptRequest, setSandboxPromptRequest] = useState(null);
-    const sandboxPromptQueueRef = useRef([]);
-    const activeSandboxPromptRef = useRef(null);
     const notifier = useTerminalFocusNotifier({ stdout, settingsService, loggingService });
-    const showNextSandboxPrompt = useCallback(() => {
-        if (activeSandboxPromptRef.current) {
-            return;
-        }
-        const next = sandboxPromptQueueRef.current.shift();
-        if (!next) {
-            return;
-        }
-        activeSandboxPromptRef.current = next;
-        setSandboxPromptRequest(next.request);
-    }, []);
-    const resolveSandboxPrompt = useCallback((answer) => {
-        const active = activeSandboxPromptRef.current;
-        if (!active) {
-            return;
-        }
-        active.resolve(answer);
-        activeSandboxPromptRef.current = null;
-        setSandboxPromptRequest(null);
-        showNextSandboxPrompt();
-    }, [showNextSandboxPrompt]);
     useEffect(() => {
+        const coordinator = new SandboxNetworkApprovalCoordinator();
+        sandboxApprovalCoordinatorRef.current = coordinator;
+        const unsubscribe = coordinator.subscribe(() => {
+            setSandboxPromptRequest(coordinator.getSnapshot().activeRequest);
+        });
         const unregister = registerSandboxNetworkApprovalHandler(async (request) => {
-            return await new Promise((resolve) => {
-                sandboxPromptQueueRef.current.push({ request, resolve });
-                showNextSandboxPrompt();
-            });
+            return await coordinator.request(request);
         });
         return () => {
             unregister();
-            const active = activeSandboxPromptRef.current;
-            if (active) {
-                active.resolve('deny');
-                activeSandboxPromptRef.current = null;
+            unsubscribe();
+            if (sandboxApprovalCoordinatorRef.current === coordinator) {
+                sandboxApprovalCoordinatorRef.current = null;
             }
-            for (const item of sandboxPromptQueueRef.current) {
-                item.resolve('deny');
-            }
-            sandboxPromptQueueRef.current = [];
+            coordinator.dispose();
         };
-    }, [showNextSandboxPrompt]);
-    const { messages, lastUsage, lastCodexRateLimit, pendingApproval, waitingForApproval, waitingForRejectionReason, setWaitingForRejectionReason, waitingForAskUserAnswer, setWaitingForAskUserAnswer, currentAskUserQuestionIndex, isProcessing, thinkingStartedAt, toolCallStreamingInfo, backgroundSubagentTasks, backgroundSubagentTasksNow, sendUserMessage, submitConversationTurn, submitApprovalDecision, onTypeAnswer, clearConversation, stopProcessing, undoLastUserMessage, retryLastToolOutput, getUserMessages, undoToUserMessage, setModel, setReasoningEffort, addSystemMessage, setTemperature, addShellMessage, getSubagentUsage, goToPreviousQuestion, goToNextQuestion, queueActive: _queueActive, queuePaused, queueLength, queuePauseReason, pendingQueuedMessages, resumeQueue, discardQueue, removeLastQueuedPendingMessage, } = useConversation({
+    }, []);
+    const { messages, lastUsage, costSummary, lastCodexRateLimit, pendingApproval, waitingForApproval, waitingForRejectionReason, setWaitingForRejectionReason, waitingForAskUserAnswer, setWaitingForAskUserAnswer, currentAskUserQuestionIndex, isProcessing, thinkingStartedAt, toolCallStreamingInfo, backgroundSubagentTasks, backgroundSubagentTasksNow, backgroundTaskDetails, backgroundTaskDetailsNow, listBackgroundTaskDetails, getBackgroundTaskDetails, stopBackgroundTask, getForegroundTaskTransferCandidate, moveForegroundTaskToBackground, listForegroundTaskTransferCandidates, backgroundSubagentApproval, resolveBackgroundSubagentApproval, sendUserMessage, admissionConfirmation, submitTurnForAdmission, resolveAdmissionConfirmation, submitConversationTurn, submitApprovalDecision, handleApprovalDecision, onTypeAnswer, clearConversation, stopProcessing, cancelAskUser, rewindToTarget, retryLastToolOutput, getUserMessages, setModel, setReasoningEffort, addSystemMessage, setTemperature, addShellMessage, getSubagentUsage, goToPreviousQuestion, goToNextQuestion, queueActive: _queueActive, queuePaused, queueLength, queuePauseReason, pendingQueuedMessages, resumeQueue, discardQueue, retractPendingSubmission, editPendingSubmission, getCostSummary, } = useConversation({
         conversationService,
         loggingService,
         usageAccumulator: sessionUsage,
         subagentUsageAccumulator: subagentUsage,
+        costAccumulator: sessionCost,
         initialMessages,
         sessionId,
         onClear: useCallback(async () => {
@@ -95,10 +90,15 @@ const App = ({ conversationService, settingsService, historyService, loggingServ
             }
         }, []),
         settingsService,
+        historyService,
         onRestoreInput: setInput,
         logWriter,
         notifier,
     });
+    // Keep older test/integration harnesses compatible while the session facade
+    // rolls out the adopted-subagent approval channel.
+    const backgroundApprovalState = backgroundSubagentApproval ?? { revision: 0, current: null, pendingCount: 0, closed: false };
+    const backgroundApprovalEntry = backgroundApprovalState.current;
     // Notify cli.tsx when the conversation has content so it can decide whether
     // to show the "To resume this conversation" message.
     useEffect(() => {
@@ -119,21 +119,34 @@ const App = ({ conversationService, settingsService, historyService, loggingServ
     useEffect(() => {
         handleClearConversationRef.current = handleClearConversation;
     }, [handleClearConversation]);
-    const applyRuntimeSetting = useRuntimeSettings({
+    const configurationService = useMemo(() => new ConversationConfigurationService({
         setModel,
         setReasoningEffort,
         setTemperature,
         conversationService,
         settingsService,
+    }), [setModel, setReasoningEffort, setTemperature, conversationService, settingsService]);
+    const applyRuntimeSetting = useCallback((key, value) => configurationService.applyRuntimeSetting(key, value), [configurationService]);
+    const applySetupProvider = useCallback((provider) => {
+        configurationService.apply([{ key: 'agent.provider', value: provider, persistence: 'runtime' }]);
+    }, [configurationService]);
+    const firstRunSetup = useFirstRunSetupGate({
+        settingsService,
+        controller,
+        applyProvider: applySetupProvider,
     });
-    const { isShellMode, toggleShellMode, handleShellSubmit } = useShellMode({
+    const shellInteractionSession = useMemo(() => new ShellInteractionSession({
         settingsService,
-        conversationService,
-        addShellMessage,
-        replaceInput,
+        conversationSink: conversationService,
         liteMode,
         sshInfo,
         sshService,
+    }), [conversationService, settingsService, sshInfo, sshService]);
+    const { isShellMode, toggleShellMode, handleShellSubmit } = useShellMode({
+        session: shellInteractionSession,
+        addShellMessage,
+        replaceInput,
+        liteMode,
     });
     const clearConversationAndRefreshBanner = useCallback(async () => {
         onPrintUsage?.();
@@ -146,30 +159,86 @@ const App = ({ conversationService, settingsService, historyService, loggingServ
         addSystemMessage,
         sendUserMessage,
         replaceInput,
-        setInputAndCursor,
-        setMode,
-        setTriggerIndex,
-        mode,
+        controller,
         settingsService,
         applyRuntimeSetting,
         setModel,
+        configurationService,
     });
-    const pendingGuards = usePendingTurnGuards({
-        input,
-        mode,
-        images,
-        conversationService,
-        historyService,
-        loggingService,
-        sendUserMessage,
-        replaceInput,
-        setImages,
-    });
+    // The composer owns this live preview because it changes as the user types;
+    // admitted turns and confirmation state belong to ConversationAdmissionWorkflow.
+    //
+    // The preview can cost a full outgoing-history build plus a serialization of
+    // it (when a warning is actually possible), so it scales with conversation
+    // length. Keep it off the keystroke path: debounce the composer text, then
+    // evaluate in an effect so the work never sits inside a render. The
+    // authoritative check still runs at submit time in ConversationAdmissionWorkflow.
+    // An emptied composer flushes immediately so a stale warning never outlives
+    // the text it described.
+    const previewInput = useDebouncedValue(input, LARGE_UNCACHED_PREVIEW_DEBOUNCE_MS, (value) => value === '');
+    const [largeUncachedPreview, setLargeUncachedPreview] = useState(null);
+    useEffect(() => {
+        if (!previewInput || mode !== 'text' || previewInput.startsWith('/') || isProcessing) {
+            setLargeUncachedPreview(null);
+            return;
+        }
+        const preview = conversationService.previewLargeUncachedInput({ text: previewInput }, Date.now());
+        setLargeUncachedPreview(preview.action === 'warn' ? preview : null);
+    }, [conversationService, previewInput, mode, isProcessing]);
+    // Drop the advisory on the same render that empties the composer / leaves text
+    // mode or starts processing; don't wait a frame for the effect to clear a stale warn.
+    const largeUncachedWarning = !previewInput || mode !== 'text' || previewInput.startsWith('/') || isProcessing ? null : largeUncachedPreview;
+    const pendingSurgeTurn = admissionConfirmation?.kind === 'surge' ? admissionConfirmation.turn : null;
+    const pendingSurgeReason = admissionConfirmation?.kind === 'surge' ? admissionConfirmation.reason : '';
+    const pendingLargeUncachedTurn = admissionConfirmation?.kind === 'large_uncached' ? admissionConfirmation.turn : null;
+    const pendingLargeUncachedTokens = admissionConfirmation?.kind === 'large_uncached' ? admissionConfirmation.estimatedTokens : 0;
+    const resolveAdmission = useCallback(async (decision) => {
+        const confirmation = admissionConfirmation;
+        if (!confirmation)
+            return;
+        const result = resolveAdmissionConfirmation(confirmation.id, decision);
+        if (result.kind === 'stale')
+            return;
+        if (result.kind === 'declined') {
+            queueMicrotask(() => replaceInput(result.turn.text || ''));
+            return;
+        }
+        if (result.kind !== 'submitted')
+            return;
+        // Composer attachments are presentation state, and only a decision that
+        // matched the displayed confirmation may clear them.
+        replaceInput('');
+        if (decision === 'approve')
+            setImages([]);
+        await result.completion;
+    }, [admissionConfirmation, replaceInput, resolveAdmissionConfirmation, setImages]);
+    const handleLargeUncachedApprove = useCallback(() => resolveAdmission('approve'), [resolveAdmission]);
+    const handleLargeUncachedDecline = useCallback(() => resolveAdmission('decline'), [resolveAdmission]);
+    const handleSurgeApprove = useCallback(() => resolveAdmission('approve'), [resolveAdmission]);
+    const handleSurgeDecline = useCallback(() => resolveAdmission('decline'), [resolveAdmission]);
+    const submitAdmittedTurn = useCallback(async (turn, options) => {
+        const result = options ? submitTurnForAdmission(turn, options) : submitTurnForAdmission(turn);
+        if (result.kind === 'submitted') {
+            replaceInput('');
+            await result.completion;
+        }
+    }, [replaceInput, submitTurnForAdmission]);
     const redrawMessageList = useCallback(() => {
         clearTerminalForRedraw(stdout);
         setMessageListEpoch((epoch) => epoch + 1);
     }, [stdout]);
-    const getSessionUsage = useCallback(() => formatSessionUsageBreakdown(sessionUsage.get(), getSubagentUsage()), [sessionUsage, getSubagentUsage]);
+    const getSessionUsage = useCallback(() => {
+        const tokenUsage = formatSessionUsageBreakdown(sessionUsage.get(), getSubagentUsage());
+        const summary = getCostSummary();
+        if (!summary || summary.state === 'unavailable') {
+            return tokenUsage;
+        }
+        const costLabel = summary.state === 'exact' ? 'Cost' : 'Estimated cost';
+        const costAmount = `${formatUsdMicros(summary.knownUsdMicros)}${summary.state === 'partial' ? '+' : ''}`;
+        const lowerBound = summary.state === 'partial' ? ' (lower bound)' : '';
+        const costUsage = `${costLabel}: ${costAmount}${lowerBound} (${summary.pricedRequests} priced, ${summary.unpricedRequests} unpriced requests)`;
+        return `${tokenUsage}\n${costUsage}`;
+    }, [getCostSummary, getSubagentUsage, sessionUsage]);
     const staticCommitBlocker = useMemo(() => detectStaticCommitBlocker(messages, { displayMode }), [messages, displayMode]);
     const exitWithUsage = useCallback(() => {
         exit();
@@ -178,6 +247,42 @@ const App = ({ conversationService, settingsService, historyService, loggingServ
     const handleSkillSelected = useCallback((skill) => {
         pendingSkillRef.current = skill;
     }, []);
+    /**
+     * Put a rewound turn back where the user can edit it. Images ride along the
+     * same way history recall restores them, so rewinding a multimodal turn does
+     * not silently drop its attachments.
+     */
+    const restoreTurnToInput = useCallback((turn) => {
+        replaceInput(turn.text);
+        setImages(turn.images ?? []);
+    }, [replaceInput, setImages]);
+    /** Rewind candidates carry a domain target id plus a UI-only trim boundary. */
+    const openRewindPickerItems = useCallback(() => buildRewindItems(getUserMessages(), conversationService.listRewindTargets()), [getUserMessages, conversationService]);
+    const openRewindMenu = useCallback((disposition) => {
+        const items = openRewindPickerItems();
+        if (items.length === 0) {
+            addSystemMessage('Nothing to rewind.');
+            return;
+        }
+        // An external surface owns the interaction from this point; discard any
+        // text-triggered frame that was used to invoke the command.
+        controller.closeAll();
+        controller.open({ kind: 'rewind', items, initialDisposition: disposition });
+    }, [addSystemMessage, controller, openRewindPickerItems]);
+    const openCopyMenu = useCallback((selections) => {
+        controller.closeAll();
+        controller.open({ kind: 'copy', items: selections }, { buffer: { type: 'clear' } });
+    }, [controller]);
+    const handleCopySelection = useCallback((selection) => {
+        void copyToClipboard(selection.text)
+            .then(() => {
+            addSystemMessage(`Copied ${selection.label.toLowerCase()} to the clipboard.`);
+        })
+            .catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            addSystemMessage(`Failed to copy to clipboard: ${message}`);
+        });
+    }, [addSystemMessage]);
     const { slashCommands, cycleAppModes } = useAppCommands({
         settingsService,
         addSystemMessage,
@@ -188,63 +293,134 @@ const App = ({ conversationService, settingsService, historyService, loggingServ
         exit: exitWithUsage,
         messages,
         setModel,
-        undoLastUserMessage,
+        getRewindItems: openRewindPickerItems,
+        rewindToTarget: (item) => rewindToTarget(item.targetId, item.uiIndex),
+        restoreTurnToInput,
         retryLastToolOutput,
-        onUndo: redrawMessageList,
-        openUndoMenu: () => {
-            const userMessages = getUserMessages().map((m) => ({ uiIndex: m.uiIndex, text: m.text }));
-            if (userMessages.length === 0) {
-                addSystemMessage('Nothing to undo.');
-                return;
-            }
-            if (undoMenuRef.current) {
-                undoMenuRef.current.open(userMessages);
-            }
-        },
+        onRewind: redrawMessageList,
+        openRewindMenu,
         openProvidersMenu: () => {
-            if (providersMenuRef.current) {
-                providersMenuRef.current.open();
-            }
+            controller.closeAll();
+            controller.open({ kind: 'providers' });
         },
+        openCopyMenu,
         onHandoff: handoff.startHandoff,
         sendUserMessage,
-        listUserTurns: () => conversationService.listUserTurns(),
         skillsService: skillsService ?? { getAvailableSkills: () => [] },
         onSkillSelected: handleSkillSelected,
     });
-    const handleUndoSelect = useCallback((item) => {
-        const text = undoToUserMessage(item.uiIndex);
-        if (text !== null) {
-            redrawMessageList();
-            replaceInput(text);
+    const handleRewindSelect = useCallback((item, disposition) => {
+        const rewound = rewindToTarget(item.targetId, item.uiIndex);
+        if (!rewound)
+            return;
+        redrawMessageList();
+        if (disposition === 'resend') {
+            replaceInput('');
+            setImages([]);
+            void sendUserMessage({ text: rewound.text, ...(rewound.images?.length ? { images: rewound.images } : {}) });
+            return;
         }
-    }, [undoToUserMessage, redrawMessageList, replaceInput]);
+        restoreTurnToInput(rewound);
+    }, [rewindToTarget, redrawMessageList, replaceInput, restoreTurnToInput, sendUserMessage, setImages]);
     const handleApprove = useCallback(async (answer) => {
         if (sandboxPromptRequest) {
-            resolveSandboxPrompt(answer ?? 'allow-once');
+            sandboxApprovalCoordinatorRef.current?.resolve(sandboxPromptRequest, answer ?? 'allow-once');
+            return;
+        }
+        if (backgroundApprovalEntry) {
+            resolveBackgroundSubagentApproval({
+                revision: backgroundApprovalState.revision,
+                entry: backgroundApprovalEntry,
+                decision: { answer: answer ?? 'yes' },
+            });
             return;
         }
         await submitApprovalDecision(answer);
-    }, [sandboxPromptRequest, resolveSandboxPrompt, submitApprovalDecision]);
+    }, [
+        backgroundApprovalEntry,
+        backgroundApprovalState.revision,
+        resolveBackgroundSubagentApproval,
+        sandboxPromptRequest,
+        submitApprovalDecision,
+    ]);
     const handleReject = useCallback(() => {
         if (sandboxPromptRequest) {
-            resolveSandboxPrompt('deny');
+            sandboxApprovalCoordinatorRef.current?.resolve(sandboxPromptRequest, 'deny');
+            return;
+        }
+        if (backgroundApprovalEntry) {
+            setWaitingForRejectionReason(true);
             return;
         }
         setWaitingForRejectionReason(true);
-    }, [sandboxPromptRequest, resolveSandboxPrompt, setWaitingForRejectionReason]);
+    }, [
+        backgroundApprovalEntry,
+        backgroundApprovalState.revision,
+        resolveBackgroundSubagentApproval,
+        sandboxPromptRequest,
+        setWaitingForRejectionReason,
+    ]);
+    const handleCancelAskUser = useCallback(() => {
+        if (sandboxPromptRequest || pendingApproval?.toolName !== 'ask_user')
+            return;
+        cancelAskUser();
+    }, [cancelAskUser, pendingApproval, sandboxPromptRequest]);
+    const submitBridgedRejectionReason = useCallback(async (reason) => {
+        if (backgroundApprovalEntry) {
+            resolveBackgroundSubagentApproval({
+                revision: backgroundApprovalState.revision,
+                entry: backgroundApprovalEntry,
+                decision: { answer: 'no', rejectionReason: reason },
+            });
+            setWaitingForRejectionReason(false);
+            return;
+        }
+        await handleApprovalDecision('n', reason);
+    }, [
+        backgroundApprovalEntry,
+        backgroundApprovalState.revision,
+        handleApprovalDecision,
+        resolveBackgroundSubagentApproval,
+        setWaitingForRejectionReason,
+    ]);
+    const backgroundPendingApproval = backgroundApprovalEntry
+        ? {
+            agentName: `${backgroundApprovalEntry.runId} (${backgroundApprovalEntry.toolName})`,
+            toolName: backgroundApprovalEntry.toolName,
+            argumentsText: backgroundApprovalEntry.argumentsText,
+            rawInterruption: { runId: backgroundApprovalEntry.runId },
+            callId: backgroundApprovalEntry.toolCallId,
+        }
+        : null;
     const effectivePendingApproval = sandboxPromptRequest === null
-        ? pendingApproval
+        ? backgroundPendingApproval ?? pendingApproval
         : {
             agentName: 'Sandbox',
             toolName: 'sandbox_network_access',
             argumentsText: `Allow network access to ${sandboxPromptRequest.host}${sandboxPromptRequest.port == null ? '' : `:${sandboxPromptRequest.port}`}?`,
             rawInterruption: sandboxPromptRequest,
         };
-    const effectiveWaitingForApproval = sandboxPromptRequest ? true : waitingForApproval;
+    const effectiveWaitingForApproval = sandboxPromptRequest || backgroundPendingApproval ? true : waitingForApproval;
     const effectiveWaitingForRejectionReason = sandboxPromptRequest ? false : waitingForRejectionReason;
     const effectiveWaitingForAskUserAnswer = sandboxPromptRequest ? false : waitingForAskUserAnswer;
-    const effectiveIsProcessing = sandboxPromptRequest ? false : isProcessing;
+    const effectiveIsProcessing = sandboxPromptRequest || backgroundPendingApproval ? false : isProcessing;
+    // Single source of truth for "which surface owns keyboard input right now."
+    // Computed from the same effective state passed to BottomArea so the app
+    // keyboard-shortcuts hook stays suppressed whenever a modal confirmation
+    // prompt is rendered (Closing the Ink fan-out coupling — see input-owner.ts).
+    const inputOwner = deriveInputOwner({
+        handoffStage: handoff.handoffState?.stage ?? null,
+        pendingSurgeTurn,
+        pendingLargeUncachedTurn,
+        waitingForApproval: effectiveWaitingForApproval,
+        waitingForRejectionReason: effectiveWaitingForRejectionReason,
+        waitingForAskUserAnswer: effectiveWaitingForAskUserAnswer,
+        pendingApproval: effectivePendingApproval,
+        queuePaused,
+        firstRunSetupActive: firstRunSetup.active,
+        isProcessing: effectiveIsProcessing,
+        menuOpen,
+    });
     useEffect(() => {
         setTerminalTitle(buildTerminalTitleLabel(terminalTitleBase, effectiveIsProcessing));
     }, [effectiveIsProcessing, terminalTitleBase]);
@@ -256,7 +432,7 @@ const App = ({ conversationService, settingsService, historyService, loggingServ
             goToNextQuestion();
         }
     }, [goToPreviousQuestion, goToNextQuestion]);
-    useAppKeyboardShortcuts({
+    const { interruptConfirmVisible, markRejectionReasonInputReady } = useAppKeyboardShortcuts({
         exitWithUsage,
         pendingSkillRef,
         waitingForAskUserAnswer: effectiveWaitingForAskUserAnswer,
@@ -264,19 +440,35 @@ const App = ({ conversationService, settingsService, historyService, loggingServ
         waitingForRejectionReason: effectiveWaitingForRejectionReason,
         setWaitingForRejectionReason,
         inputMode: mode,
+        inputValue: input,
         isProcessing: effectiveIsProcessing,
         waitingForApproval: effectiveWaitingForApproval,
         stopProcessing,
         handoffState: handoff.handoffState,
         cancelHandoff: handoff.cancelHandoff,
-        pendingLargeUncachedTurn: pendingGuards.pendingLargeUncachedTurn,
+        pendingLargeUncachedTurn,
         liteMode,
         toggleShellMode,
         cycleAppModes,
         replaceInput,
         onSkillActivationCancelled: () => addSystemMessage('Skill activation cancelled.'),
+        approvalShortcutsEnabled: effectivePendingApproval?.toolName !== TOOL_NAME_ASK_USER && !effectivePendingApproval?.dockerHostControl,
+        approvalShortcutApproveAnswer: sandboxPromptRequest || effectivePendingApproval?.deniedRead ? 'allow-once' : undefined,
+        onApprove: handleApprove,
+        onReject: handleReject,
+        submitRejectionReason: submitBridgedRejectionReason,
+        inputOwner,
     });
-    const handleSubmit = async (turn) => {
+    const handleSubmit = async (turn, options) => {
+        if (backgroundApprovalEntry && waitingForRejectionReason) {
+            resolveBackgroundSubagentApproval({
+                revision: backgroundApprovalState.revision,
+                entry: backgroundApprovalEntry,
+                decision: { answer: 'no', rejectionReason: turn.text },
+            });
+            setWaitingForRejectionReason(false);
+            return;
+        }
         if (await submitConversationTurn(turn)) {
             return;
         }
@@ -312,58 +504,94 @@ const App = ({ conversationService, settingsService, historyService, loggingServ
                 if (hasImages) {
                     break;
                 }
-                // Find matching command
-                const command = resolveSlashCommand(slashCommands, parsed.commandName);
-                if (command) {
-                    // Execute the command
-                    const shouldClearInput = command.action(parsed.args || undefined);
-                    // Clear input unless command returned false
-                    if (shouldClearInput !== false) {
-                        replaceInput('');
-                    }
+                if (tryExecuteSlashCommand(value, slashCommands, replaceInput)) {
                     return;
                 }
                 // Command not found, fall through to send as message
                 break;
             }
             case 'message':
-                await pendingGuards.sendGuardedTurn(attachPendingSkill(turn));
-                return;
+                return await submitAdmittedTurn(attachPendingSkill(turn), options);
         }
-        await pendingGuards.sendGuardedTurn(attachPendingSkill(turn));
+        await submitAdmittedTurn(attachPendingSkill(turn), options);
     };
     const handleSettingChange = useCallback((key, value) => {
         applyRuntimeSetting(key, value);
         if (handoff.handoffState?.stage === 'selecting_effort' && key === 'agent.reasoningEffort') {
-            void handoff.completeHandoffWithEffort(value);
+            void handoff.completeHandoffWithEffort(String(value));
         }
     }, [applyRuntimeSetting, handoff]);
-    const cancelQueuedMessage = useCallback(async () => {
-        const restored = await removeLastQueuedPendingMessage();
-        if (restored !== null) {
-            replaceInput(restored);
+    const handleConfigurationSettingChange = useCallback((key, value) => {
+        if (handoff.handoffState?.stage === 'selecting_effort' && key === 'agent.reasoningEffort') {
+            void handoff.completeHandoffWithEffort(String(value));
         }
-        return restored;
-    }, [removeLastQueuedPendingMessage, replaceInput]);
+    }, [handoff]);
+    // The application effect host: executes typed domain intents only after
+    // the controller has committed the required input and stack transition.
+    // Settings/model application is the first production user of a correlated
+    // IntentResult (success or field error) delivered back to the originating
+    // frame; rewind remains fire-and-forget.
+    useEffect(() => {
+        controller.setIntentHost(({ intentRequest }) => {
+            if (intentRequest.intent.type === 'rewind') {
+                handleRewindSelect(intentRequest.intent.item, intentRequest.intent.disposition);
+                return;
+            }
+            if (intentRequest.intent.type === 'submit-prompt') {
+                // A captured handoff intercepts its own model selection here rather
+                // than through `handleSubmit`: the direct `/model ` trigger is
+                // controller-owned, so an accepted selection never routes through a
+                // submitted turn. See `useHandoffFlow`'s `handleModelSubmitPrompt`.
+                if (handoff.handleModelSubmitPrompt(intentRequest.intent.text)) {
+                    return;
+                }
+                // Text composed by a controller-owned menu (e.g. accepting a direct
+                // `/model gpt-4` selection) is exactly what the user would have
+                // typed and pressed Enter on, so it goes through the same slash-
+                // command dispatch as handleSubmit before falling back to sending it
+                // as ordinary content — otherwise a resolved command like `/model`
+                // would be posted to the model as a literal chat message instead of
+                // being executed.
+                if (tryExecuteSlashCommand(intentRequest.intent.text, slashCommands, replaceInput)) {
+                    return;
+                }
+                void submitAdmittedTurn({ text: intentRequest.intent.text });
+                return;
+            }
+            const result = handleSettingsIntent(intentRequest, {
+                settingsService,
+                configurationService,
+                onSettingChange: handleConfigurationSettingChange,
+                onSystemMessage: addSystemMessage,
+                applyRuntimeSetting,
+            });
+            if (result?.ok &&
+                intentRequest.intent.type === 'apply-settings' &&
+                intentRequest.intent.changes.some((change) => change.key === 'agent.model')) {
+                firstRunSetup.completeModelSelection();
+            }
+            return result;
+        });
+        return () => controller.setIntentHost(undefined);
+    }, [
+        controller,
+        handleRewindSelect,
+        submitAdmittedTurn,
+        settingsService,
+        handleSettingChange,
+        addSystemMessage,
+        applyRuntimeSetting,
+        handoff,
+        slashCommands,
+        replaceInput,
+        firstRunSetup,
+    ]);
     return (React.createElement(ErrorBoundary, { loggingService: loggingService },
         React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
             React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
                 React.createElement(MessageList, { key: messageListEpoch, messages: messages, bannerItems: startupBannerIds, settingsService: settingsService, isShellMode: isShellMode, restoredStaticMessageIds: restoredStaticMessageIds })),
             React.createElement(Box, { paddingX: MESSAGE_HORIZONTAL_PADDING },
-                React.createElement(BottomArea, { pendingApproval: effectivePendingApproval, waitingForApproval: effectiveWaitingForApproval, waitingForRejectionReason: effectiveWaitingForRejectionReason, waitingForAskUserAnswer: effectiveWaitingForAskUserAnswer, currentAskUserQuestionIndex: currentAskUserQuestionIndex, isProcessing: effectiveIsProcessing, thinkingStartedAt: thinkingStartedAt, toolCallStreamingInfo: toolCallStreamingInfo, isShellMode: isShellMode, lastUsage: lastUsage, queuePaused: queuePaused, queueLength: queueLength, queuePauseReason: queuePauseReason, onResumeQueue: resumeQueue, onDiscardQueue: discardQueue, pendingQueuedMessages: pendingQueuedMessages, backgroundSubagentTasks: backgroundSubagentTasks, backgroundSubagentTasksNow: backgroundSubagentTasksNow, onCancelQueuedMessage: cancelQueuedMessage, onSubmit: handleSubmit, slashCommands: slashCommands, skillsService: skillsService, settingsService: settingsService, loggingService: loggingService, historyService: historyService, onApprove: handleApprove, onReject: handleReject, onTypeAnswer: onTypeAnswer, onNavigateQuestion: handleNavigateQuestion, sshInfo: sshInfo, lastCodexRateLimit: lastCodexRateLimit, staticCommitBlocker: staticCommitBlocker, undoMenuRef: undoMenuRef, onUndoSelect: handleUndoSelect, providersMenuRef: providersMenuRef, onSettingChange: handleSettingChange, onSystemMessage: addSystemMessage, handoffState: handoff.handoffState, onHandoffConfirm: handoff.confirmHandoff, onHandoffDecline: handoff.declineHandoff, onHandoffCancel: handoff.cancelHandoff, onStandardModeConfirm: handoff.confirmStandardMode, onStandardModeDecline: handoff.declineStandardMode, largeUncachedWarning: pendingGuards.largeUncachedWarning, pendingLargeUncachedTurn: pendingGuards.pendingLargeUncachedTurn, pendingLargeUncachedTokens: pendingGuards.pendingLargeUncachedTokens, onLargeUncachedApprove: pendingGuards.handleLargeUncachedApprove, onLargeUncachedDecline: pendingGuards.handleLargeUncachedDecline, pendingSurgeTurn: pendingGuards.pendingSurgeTurn, pendingSurgeReason: pendingGuards.pendingSurgeReason, onSurgeApprove: pendingGuards.handleSurgeApprove, onSurgeDecline: pendingGuards.handleSurgeDecline, onSlashTabComplete: (command) => {
-                        if (command.name === 'undo') {
-                            const userMessages = getUserMessages().map((m) => ({ uiIndex: m.uiIndex, text: m.text }));
-                            if (userMessages.length === 0) {
-                                addSystemMessage('Nothing to undo.');
-                                return true;
-                            }
-                            if (undoMenuRef.current) {
-                                undoMenuRef.current.open(userMessages);
-                            }
-                            return true;
-                        }
-                        return false;
-                    } })))));
+                React.createElement(BottomArea, { pendingApproval: effectivePendingApproval, waitingForApproval: effectiveWaitingForApproval, waitingForRejectionReason: effectiveWaitingForRejectionReason, waitingForAskUserAnswer: effectiveWaitingForAskUserAnswer, currentAskUserQuestionIndex: currentAskUserQuestionIndex, isProcessing: effectiveIsProcessing, interruptConfirmVisible: interruptConfirmVisible, thinkingStartedAt: thinkingStartedAt, toolCallStreamingInfo: toolCallStreamingInfo, isShellMode: isShellMode, lastUsage: lastUsage, costSummary: costSummary, queuePaused: queuePaused, queueLength: queueLength, queuePauseReason: queuePauseReason, onResumeQueue: resumeQueue, onDiscardQueue: discardQueue, pendingQueuedMessages: pendingQueuedMessages, backgroundSubagentTasks: backgroundSubagentTasks, backgroundSubagentTasksNow: backgroundSubagentTasksNow, backgroundTaskDetails: backgroundTaskDetails, backgroundTaskDetailsNow: backgroundTaskDetailsNow, listBackgroundTaskDetails: listBackgroundTaskDetails, getBackgroundTaskDetails: getBackgroundTaskDetails, stopBackgroundTask: stopBackgroundTask, getForegroundTaskTransferCandidate: getForegroundTaskTransferCandidate, moveForegroundTaskToBackground: moveForegroundTaskToBackground, listForegroundTaskTransferCandidates: listForegroundTaskTransferCandidates, backgroundApprovalPendingCount: backgroundApprovalState.pendingCount, onRetractQueuedMessage: retractPendingSubmission, onEditQueuedMessage: editPendingSubmission, onSubmit: handleSubmit, onRejectionReasonInputReady: markRejectionReasonInputReady, slashCommands: slashCommands, skillsService: skillsService, settingsService: settingsService, loggingService: loggingService, historyService: historyService, onApprove: handleApprove, onReject: handleReject, onCancel: handleCancelAskUser, onTypeAnswer: onTypeAnswer, onNavigateQuestion: handleNavigateQuestion, sshInfo: sshInfo, lastCodexRateLimit: lastCodexRateLimit, staticCommitBlocker: staticCommitBlocker, firstRunSetup: firstRunSetup, onProviderSelected: firstRunSetup.active ? firstRunSetup.onProviderSelected : undefined, onUnavailableModelSelected: firstRunSetup.requestSetup, onSkillSelected: handleSkillSelected, onCopySelection: handleCopySelection, onSettingChange: handleSettingChange, onSystemMessage: addSystemMessage, handoffState: handoff.handoffState, onHandoffConfirm: handoff.confirmHandoff, onHandoffDecline: handoff.declineHandoff, onHandoffCancel: handoff.cancelHandoff, onStandardModeConfirm: handoff.confirmStandardMode, onStandardModeDecline: handoff.declineStandardMode, largeUncachedWarning: largeUncachedWarning, pendingLargeUncachedTurn: pendingLargeUncachedTurn, pendingLargeUncachedTokens: pendingLargeUncachedTokens, onLargeUncachedApprove: handleLargeUncachedApprove, onLargeUncachedDecline: handleLargeUncachedDecline, pendingSurgeTurn: pendingSurgeTurn, pendingSurgeReason: pendingSurgeReason, onSurgeApprove: handleSurgeApprove, onSurgeDecline: handleSurgeDecline })))));
 };
 export default App;
 //# sourceMappingURL=app.js.map