@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/screens/REPL.js

@@ -0,0 +1,4434 @@
+import { feature } from '../recovery/bunBundleShim.js';
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+import { c as _c } from "react/compiler-runtime";
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { spawnSync } from 'child_process';
+import { snapshotOutputTokensForTurn, getCurrentTurnTokenBudget, getTurnOutputTokens, getBudgetContinuationCount, getTotalInputTokens } from '../bootstrap/state.js';
+import { parseTokenBudget } from '../utils/tokenBudget.js';
+import { count } from '../utils/array.js';
+import { dirname, join } from 'path';
+import { tmpdir } from 'os';
+import figures from 'figures';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- / n N Esc [ v are bare letters in transcript modal context, same class as g/G/j/k in ScrollKeybindingHandler
+import { useInput } from '../ink.js';
+import { useSearchInput } from '../hooks/useSearchInput.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { useSearchHighlight } from '../ink/hooks/use-search-highlight.js';
+import { renderMessagesToPlainText } from '../utils/exportRenderer.js';
+import { openFileInExternalEditor } from '../utils/editor.js';
+import { writeFile } from 'fs/promises';
+import { Box, Text, useStdin, useTheme, useTerminalFocus, useTerminalTitle, useTabStatus } from '../ink.js';
+import { CostThresholdDialog } from '../components/CostThresholdDialog.js';
+import { IdleReturnDialog } from '../components/IdleReturnDialog.js';
+import * as React from 'react';
+import { useEffect, useMemo, useRef, useState, useCallback, useDeferredValue, useLayoutEffect } from 'react';
+import { useNotifications } from '../context/notifications.js';
+import { sendNotification } from '../services/notifier.js';
+import { startPreventSleep, stopPreventSleep } from '../services/preventSleep.js';
+import { useTerminalNotification } from '../ink/useTerminalNotification.js';
+import { hasCursorUpViewportYankBug } from '../ink/terminal.js';
+import { createFileStateCacheWithSizeLimit, mergeFileStateCaches, READ_FILE_STATE_CACHE_SIZE } from '../utils/fileStateCache.js';
+import { updateLastInteractionTime, getLastInteractionTime, getOriginalCwd, getProjectRoot, getSessionId, switchSession, setCostStateForRestore, getTurnHookDurationMs, getTurnHookCount, resetTurnHookDuration, getTurnToolDurationMs, getTurnToolCount, resetTurnToolDuration, getTurnClassifierDurationMs, getTurnClassifierCount, resetTurnClassifierDuration } from '../bootstrap/state.js';
+import { asSessionId, asAgentId } from '../types/ids.js';
+import { logForDebugging } from '../utils/debug.js';
+import { QueryGuard } from '../utils/QueryGuard.js';
+import { isEnvTruthy } from '../utils/envUtils.js';
+import { formatTokens, truncateToWidth } from '../utils/format.js';
+import { consumeEarlyInput } from '../utils/earlyInput.js';
+import { setMemberActive } from '../utils/swarm/teamHelpers.js';
+import { isSwarmWorker, generateSandboxRequestId, sendSandboxPermissionRequestViaMailbox, sendSandboxPermissionResponseViaMailbox } from '../utils/swarm/permissionSync.js';
+import { registerSandboxPermissionCallback } from '../hooks/useSwarmPermissionPoller.js';
+import { getTeamName, getAgentName } from '../utils/teammate.js';
+import { WorkerPendingPermission } from '../components/permissions/WorkerPendingPermission.js';
+import { injectUserMessageToTeammate, getAllInProcessTeammateTasks } from '../tasks/InProcessTeammateTask/InProcessTeammateTask.js';
+import { isLocalAgentTask, queuePendingMessage, appendMessageToLocalAgent } from '../tasks/LocalAgentTask/LocalAgentTask.js';
+import { registerLeaderToolUseConfirmQueue, unregisterLeaderToolUseConfirmQueue, registerLeaderSetToolPermissionContext, unregisterLeaderSetToolPermissionContext } from '../utils/swarm/leaderPermissionBridge.js';
+import { endInteractionSpan } from '../utils/telemetry/sessionTracing.js';
+import { useLogMessages } from '../hooks/useLogMessages.js';
+import { useReplBridge } from '../hooks/useReplBridge.js';
+import { useTelegramMirror } from '../hooks/useTelegramMirror.js';
+import { useWhatsAppMirror } from '../hooks/useWhatsAppMirror.js';
+import { getCommandName, isCommandEnabled } from '../commands.js';
+import { MessageSelector, selectableUserMessagesFilter, messagesAfterAreOnlySynthetic } from '../components/MessageSelector.js';
+import { useIdeLogging } from '../hooks/useIdeLogging.js';
+import { PermissionRequest } from '../components/permissions/PermissionRequest.js';
+import { ElicitationDialog } from '../components/mcp/ElicitationDialog.js';
+import { PromptDialog } from '../components/hooks/PromptDialog.js';
+import PromptInput from '../components/PromptInput/PromptInput.js';
+import { PromptInputQueuedCommands } from '../components/PromptInput/PromptInputQueuedCommands.js';
+import { useRemoteSession } from '../hooks/useRemoteSession.js';
+import { useDirectConnect } from '../hooks/useDirectConnect.js';
+import { useSSHSession } from '../hooks/useSSHSession.js';
+import { useAssistantHistory } from '../hooks/useAssistantHistory.js';
+import { SkillImprovementSurvey } from '../components/SkillImprovementSurvey.js';
+import { useSkillImprovementSurvey } from '../hooks/useSkillImprovementSurvey.js';
+import { useMoreRight } from '../moreright/useMoreRight.js';
+import { SpinnerWithVerb, BriefIdleStatus } from '../components/Spinner.js';
+import { getSystemPrompt } from '../constants/prompts.js';
+import { buildEffectiveSystemPrompt } from '../utils/systemPrompt.js';
+import { getSystemContext, getUserContext } from '../context.js';
+import { getMemoryFiles } from '../utils/claudemd.js';
+import { startBackgroundHousekeeping } from '../utils/backgroundHousekeeping.js';
+import { getTotalCost, saveCurrentSessionCosts, resetCostState, getStoredSessionCosts } from '../cost-tracker.js';
+import { useCostSummary } from '../costHook.js';
+import { useFpsMetrics } from '../context/fpsMetrics.js';
+import { useAfterFirstRender } from '../hooks/useAfterFirstRender.js';
+import { useDeferredHookMessages } from '../hooks/useDeferredHookMessages.js';
+import { addToHistory, removeLastFromHistory, expandPastedTextRefs, parseReferences } from '../history.js';
+import { prependModeCharacterToInput } from '../components/PromptInput/inputModes.js';
+import { prependToShellHistoryCache } from '../utils/suggestions/shellHistoryCompletion.js';
+import { useApiKeyVerification } from '../hooks/useApiKeyVerification.js';
+import { GlobalKeybindingHandlers } from '../hooks/useGlobalKeybindings.js';
+import { CommandKeybindingHandlers } from '../hooks/useCommandKeybindings.js';
+import { KeybindingSetup } from '../keybindings/KeybindingProviderSetup.js';
+import { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js';
+import { getShortcutDisplay } from '../keybindings/shortcutFormat.js';
+import { CancelRequestHandler } from '../hooks/useCancelRequest.js';
+import { useBackgroundTaskNavigation } from '../hooks/useBackgroundTaskNavigation.js';
+import { useSwarmInitialization } from '../hooks/useSwarmInitialization.js';
+import { useTeammateViewAutoExit } from '../hooks/useTeammateViewAutoExit.js';
+import { errorMessage } from '../utils/errors.js';
+import { isHumanTurn } from '../utils/messagePredicates.js';
+import { logError } from '../utils/log.js';
+// Dead code elimination: conditional imports
+/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+const useVoiceIntegration = feature('VOICE_MODE') ? require('../hooks/useVoiceIntegration.js').useVoiceIntegration : () => ({
+    stripTrailing: () => 0,
+    handleKeyEvent: () => { },
+    resetAnchor: () => { }
+});
+const VoiceKeybindingHandler = feature('VOICE_MODE') ? require('../hooks/useVoiceIntegration.js').VoiceKeybindingHandler : () => null;
+// Frustration detection is ant-only (dogfooding). Conditional require so external
+// builds eliminate the module entirely (including its two O(n) useMemos that run
+// on every messages change, plus the GrowthBook fetch).
+const useFrustrationDetection = "external" === 'ant' ? require('../components/FeedbackSurvey/useFrustrationDetection.js').useFrustrationDetection : () => ({
+    state: 'closed',
+    handleTranscriptSelect: () => { }
+});
+// Ant-only org warning. Conditional require so the org UUID list is
+// eliminated from external builds (one UUID is on excluded-strings).
+const useAntOrgWarningNotification = "external" === 'ant' ? require('../hooks/notifs/useAntOrgWarningNotification.js').useAntOrgWarningNotification : () => { };
+// Dead code elimination: conditional import for coordinator mode
+const getCoordinatorUserContext = feature('COORDINATOR_MODE') ? require('../coordinator/coordinatorMode.js').getCoordinatorUserContext : () => ({});
+/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+import useCanUseTool from '../hooks/useCanUseTool.js';
+import { applyPermissionUpdate, applyPermissionUpdates, persistPermissionUpdate } from '../utils/permissions/PermissionUpdate.js';
+import { buildPermissionUpdates } from '../components/permissions/ExitPlanModePermissionRequest/ExitPlanModePermissionRequest.js';
+import { stripDangerousPermissionsForAutoMode } from '../utils/permissions/permissionSetup.js';
+import { getScratchpadDir, isScratchpadEnabled } from '../utils/permissions/filesystem.js';
+import { WEB_FETCH_TOOL_NAME } from '../tools/WebFetchTool/prompt.js';
+import { SLEEP_TOOL_NAME } from '../tools/SleepTool/prompt.js';
+import { clearSpeculativeChecks } from '../tools/BashTool/bashPermissions.js';
+import { getGlobalConfig, saveGlobalConfig, getGlobalConfigWriteCount } from '../utils/config.js';
+import { hasConsoleBillingAccess } from '../utils/billing.js';
+import { logEvent } from '../services/analytics/index.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
+import { textForResubmit, handleMessageFromStream, isCompactBoundaryMessage, getMessagesAfterCompactBoundary, getContentText, createUserMessage, createAssistantMessage, createTurnDurationMessage, createAgentsKilledMessage, createApiMetricsMessage, createSystemMessage, createCommandInputMessage, formatCommandInputTags } from '../utils/messages.js';
+import { generateSessionTitle } from '../utils/sessionTitle.js';
+import { BASH_INPUT_TAG, COMMAND_MESSAGE_TAG, COMMAND_NAME_TAG, LOCAL_COMMAND_STDOUT_TAG } from '../constants/xml.js';
+import { escapeXml } from '../utils/xml.js';
+import { gracefulShutdownSync } from '../utils/gracefulShutdown.js';
+import { handlePromptSubmit } from '../utils/handlePromptSubmit.js';
+import { useQueueProcessor } from '../hooks/useQueueProcessor.js';
+import { useMailboxBridge } from '../hooks/useMailboxBridge.js';
+import { queryCheckpoint, logQueryProfileReport } from '../utils/queryProfiler.js';
+import { query } from '../query.js';
+import { mergeClients, useMergedClients } from '../hooks/useMergedClients.js';
+import { getQuerySourceForREPL } from '../utils/promptCategory.js';
+import { useMergedTools } from '../hooks/useMergedTools.js';
+import { mergeAndFilterTools } from '../utils/toolPool.js';
+import { useMergedCommands } from '../hooks/useMergedCommands.js';
+import { useSkillsChange } from '../hooks/useSkillsChange.js';
+import { useManagePlugins } from '../hooks/useManagePlugins.js';
+import { Messages } from '../components/Messages.js';
+import { TaskListV2 } from '../components/TaskListV2.js';
+import { TeammateViewHeader } from '../components/TeammateViewHeader.js';
+import { useTasksV2WithCollapseEffect } from '../hooks/useTasksV2.js';
+import { maybeMarkProjectOnboardingComplete } from '../projectOnboardingState.js';
+import { randomUUID } from 'crypto';
+import { processSessionStartHooks } from '../utils/sessionStart.js';
+import { executeSessionEndHooks, getSessionEndHookTimeoutMs } from '../utils/hooks.js';
+import { useIdeSelection } from '../hooks/useIdeSelection.js';
+import { getTools, assembleToolPool } from '../tools.js';
+import { resolveAgentTools } from '../tools/AgentTool/agentToolUtils.js';
+import { resumeAgentBackground } from '../tools/AgentTool/resumeAgent.js';
+import { useMainLoopModel } from '../hooks/useMainLoopModel.js';
+import { useAppState, useSetAppState, useAppStateStore } from '../state/AppState.js';
+import { copyPlanForFork, copyPlanForResume, getPlanSlug, setPlanSlug } from '../utils/plans.js';
+import { clearSessionMetadata, resetSessionFilePointer, adoptResumedSessionFile, removeTranscriptMessage, restoreSessionMetadata, getCurrentSessionTitle, isEphemeralToolProgress, isLoggableMessage, saveWorktreeState, getAgentTranscript } from '../utils/sessionStorage.js';
+import { deserializeMessages } from '../utils/conversationRecovery.js';
+import { extractReadFilesFromMessages, extractBashToolsFromMessages } from '../utils/queryHelpers.js';
+import { resetMicrocompactState } from '../services/compact/microCompact.js';
+import { runPostCompactCleanup } from '../services/compact/postCompactCleanup.js';
+import { provisionContentReplacementState, reconstructContentReplacementState } from '../utils/toolResultStorage.js';
+import { partialCompactConversation } from '../services/compact/compact.js';
+import { fileHistoryMakeSnapshot, fileHistoryRewind, copyFileHistoryForResume, fileHistoryEnabled, fileHistoryHasAnyChanges } from '../utils/fileHistory.js';
+import { incrementPromptCount } from '../utils/commitAttribution.js';
+import { recordAttributionSnapshot } from '../utils/sessionStorage.js';
+import { computeStandaloneAgentContext, restoreAgentFromSession, restoreSessionStateFromLog, restoreWorktreeForResume, exitRestoredWorktree } from '../utils/sessionRestore.js';
+import { isBgSession, updateSessionName, updateSessionActivity } from '../utils/concurrentSessions.js';
+import { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js';
+import { restoreRemoteAgentTasks } from '../tasks/RemoteAgentTask/RemoteAgentTask.js';
+import { useInboxPoller } from '../hooks/useInboxPoller.js';
+// Dead code elimination: conditional import for loop mode
+/* eslint-disable @typescript-eslint/no-require-imports */
+const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/index.js') : null;
+const PROACTIVE_NO_OP_SUBSCRIBE = (_cb) => () => { };
+const PROACTIVE_FALSE = () => false;
+const SUGGEST_BG_PR_NOOP = (_p, _n) => false;
+const useProactive = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/useProactive.js').useProactive : null;
+const useScheduledTasks = feature('AGENT_TRIGGERS') ? require('../hooks/useScheduledTasks.js').useScheduledTasks : null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js';
+import { useTaskListWatcher } from '../hooks/useTaskListWatcher.js';
+import { closeOpenDiffs, getConnectedIdeClient } from '../utils/ide.js';
+import { useIDEIntegration } from '../hooks/useIDEIntegration.js';
+import exit from '../commands/exit/index.js';
+import { ExitFlow } from '../components/ExitFlow.js';
+import { getCurrentWorktreeSession } from '../utils/worktree.js';
+import { popAllEditable, enqueue, getCommandQueue, getCommandQueueLength, removeByFilter } from '../utils/messageQueueManager.js';
+import { useCommandQueue } from '../hooks/useCommandQueue.js';
+import { SessionBackgroundHint } from '../components/SessionBackgroundHint.js';
+import { startBackgroundSession } from '../tasks/LocalMainSessionTask.js';
+import { useSessionBackgrounding } from '../hooks/useSessionBackgrounding.js';
+import { diagnosticTracker } from '../services/diagnosticTracking.js';
+import { handleSpeculationAccept } from '../services/PromptSuggestion/speculation.js';
+import { IdeOnboardingDialog } from '../components/IdeOnboardingDialog.js';
+import { EffortCallout, shouldShowEffortCallout } from '../components/EffortCallout.js';
+import { RemoteCallout } from '../components/RemoteCallout.js';
+/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+const AntModelSwitchCallout = "external" === 'ant' ? require('../components/AntModelSwitchCallout.js').AntModelSwitchCallout : null;
+const shouldShowAntModelSwitch = "external" === 'ant' ? require('../components/AntModelSwitchCallout.js').shouldShowModelSwitchCallout : () => false;
+const UndercoverAutoCallout = "external" === 'ant' ? require('../components/UndercoverAutoCallout.js').UndercoverAutoCallout : null;
+/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+import { activityManager } from '../utils/activityManager.js';
+import { createAbortController } from '../utils/abortController.js';
+import { MCPConnectionManager } from '../services/mcp/MCPConnectionManager.js';
+import { useFeedbackSurvey } from '../components/FeedbackSurvey/useFeedbackSurvey.js';
+import { useMemorySurvey } from '../components/FeedbackSurvey/useMemorySurvey.js';
+import { usePostCompactSurvey } from '../components/FeedbackSurvey/usePostCompactSurvey.js';
+import { FeedbackSurvey } from '../components/FeedbackSurvey/FeedbackSurvey.js';
+import { useInstallMessages } from '../hooks/notifs/useInstallMessages.js';
+import { useAwaySummary } from '../hooks/useAwaySummary.js';
+import { useChromeExtensionNotification } from '../hooks/useChromeExtensionNotification.js';
+import { useOfficialMarketplaceNotification } from '../hooks/useOfficialMarketplaceNotification.js';
+import { usePromptsFromClaudeInChrome } from '../hooks/usePromptsFromClaudeInChrome.js';
+import { getTipToShowOnSpinner, recordShownTip } from '../services/tips/tipScheduler.js';
+import { checkAndDisableBypassPermissionsIfNeeded, checkAndDisableAutoModeIfNeeded, useKickOffCheckAndDisableBypassPermissionsIfNeeded, useKickOffCheckAndDisableAutoModeIfNeeded } from '../utils/permissions/bypassPermissionsKillswitch.js';
+import { SandboxManager } from '../utils/sandbox/sandbox-adapter.js';
+import { SANDBOX_NETWORK_ACCESS_TOOL_NAME } from '../cli/structuredIO.js';
+import { useFileHistorySnapshotInit } from '../hooks/useFileHistorySnapshotInit.js';
+import { SandboxPermissionRequest } from '../components/permissions/SandboxPermissionRequest.js';
+import { SandboxViolationExpandedView } from '../components/SandboxViolationExpandedView.js';
+import { useSettingsErrors } from '../hooks/notifs/useSettingsErrors.js';
+import { useMcpConnectivityStatus } from '../hooks/notifs/useMcpConnectivityStatus.js';
+import { useAutoModeUnavailableNotification } from '../hooks/notifs/useAutoModeUnavailableNotification.js';
+import { AUTO_MODE_DESCRIPTION } from '../components/AutoModeOptInDialog.js';
+import { useLspInitializationNotification } from '../hooks/notifs/useLspInitializationNotification.js';
+import { useLspPluginRecommendation } from '../hooks/useLspPluginRecommendation.js';
+import { LspRecommendationMenu } from '../components/LspRecommendation/LspRecommendationMenu.js';
+import { useClaudeCodeHintRecommendation } from '../hooks/useClaudeCodeHintRecommendation.js';
+import { PluginHintMenu } from '../components/ClaudeCodeHint/PluginHintMenu.js';
+import { DesktopUpsellStartup, shouldShowDesktopUpsellStartup } from '../components/DesktopUpsell/DesktopUpsellStartup.js';
+import { usePluginInstallationStatus } from '../hooks/notifs/usePluginInstallationStatus.js';
+import { usePluginAutoupdateNotification } from '../hooks/notifs/usePluginAutoupdateNotification.js';
+import { performStartupChecks } from '../utils/plugins/performStartupChecks.js';
+import { UserTextMessage } from '../components/messages/UserTextMessage.js';
+import { AwsAuthStatusBox } from '../components/AwsAuthStatusBox.js';
+import { useRateLimitWarningNotification } from '../hooks/notifs/useRateLimitWarningNotification.js';
+import { useDeprecationWarningNotification } from '../hooks/notifs/useDeprecationWarningNotification.js';
+import { useNpmDeprecationNotification } from '../hooks/notifs/useNpmDeprecationNotification.js';
+import { useIDEStatusIndicator } from '../hooks/notifs/useIDEStatusIndicator.js';
+import { useModelMigrationNotifications } from '../hooks/notifs/useModelMigrationNotifications.js';
+import { useCanSwitchToExistingSubscription } from '../hooks/notifs/useCanSwitchToExistingSubscription.js';
+import { useTeammateLifecycleNotification } from '../hooks/notifs/useTeammateShutdownNotification.js';
+import { useFastModeNotification } from '../hooks/notifs/useFastModeNotification.js';
+import { AutoRunIssueNotification, shouldAutoRunIssue, getAutoRunIssueReasonText, getAutoRunCommand } from '../utils/autoRunIssue.js';
+import { TungstenLiveMonitor } from '../tools/TungstenTool/TungstenLiveMonitor.js';
+/* eslint-disable @typescript-eslint/no-require-imports */
+const WebBrowserPanelModule = feature('WEB_BROWSER_TOOL') ? require('../tools/WebBrowserTool/WebBrowserPanel.js') : null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { IssueFlagBanner } from '../components/PromptInput/IssueFlagBanner.js';
+import { useIssueFlagBanner } from '../hooks/useIssueFlagBanner.js';
+import { CompanionSprite, CompanionFloatingBubble, MIN_COLS_FOR_FULL_SPRITE } from '../buddy/CompanionSprite.js';
+import { DevBar } from '../components/DevBar.js';
+import { REMOTE_SAFE_COMMANDS } from '../commands.js';
+import { FullscreenLayout, useUnseenDivider, computeUnseenDivider } from '../components/FullscreenLayout.js';
+import { isFullscreenEnvEnabled, maybeGetTmuxMouseHint, isMouseTrackingEnabled } from '../utils/fullscreen.js';
+import { AlternateScreen } from '../ink/components/AlternateScreen.js';
+import { ScrollKeybindingHandler } from '../components/ScrollKeybindingHandler.js';
+import { useMessageActions, MessageActionsKeybindings, MessageActionsBar } from '../components/messageActions.js';
+import { setClipboard } from '../ink/termio/osc.js';
+import { createAttachmentMessage, getQueuedCommandAttachments } from '../utils/attachments.js';
+// Stable empty array for hooks that accept MCPServerConnection[] — avoids
+// creating a new [] literal on every render in remote mode, which would
+// cause useEffect dependency changes and infinite re-render loops.
+const EMPTY_MCP_CLIENTS = [];
+// Stable stub for useAssistantHistory's non-KAIROS branch — avoids a new
+// function identity each render, which would break composedOnScroll's memo.
+const HISTORY_STUB = {
+    maybeLoadOlder: (_) => { }
+};
+// Window after a user-initiated scroll during which type-into-empty does NOT
+// repin to bottom. Josh Rosen's workflow: Claude emits long output → scroll
+// up to read the start → start typing → before this fix, snapped to bottom.
+// https://anthropic.slack.com/archives/C07VBSHV7EV/p1773545449871739
+const RECENT_SCROLL_REPIN_WINDOW_MS = 3000;
+// Use LRU cache to prevent unbounded memory growth
+// 100 files should be sufficient for most coding sessions while preventing
+// memory issues when working across many files in large projects
+function median(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? Math.round((sorted[mid - 1] + sorted[mid]) / 2) : sorted[mid];
+}
+/**
+ * Small component to display transcript mode footer with dynamic keybinding.
+ * Must be rendered inside KeybindingSetup to access keybinding context.
+ */
+function TranscriptModeFooter(t0) {
+    const $ = _c(9);
+    const { showAllInTranscript, virtualScroll, searchBadge, suppressShowAll: t1, status } = t0;
+    const suppressShowAll = t1 === undefined ? false : t1;
+    const toggleShortcut = useShortcutDisplay("app:toggleTranscript", "Global", "ctrl+o");
+    const showAllShortcut = useShortcutDisplay("transcript:toggleShowAll", "Transcript", "ctrl+e");
+    const t2 = searchBadge ? " \xB7 n/N para navegar" : virtualScroll ? ` · ${figures.arrowUp}${figures.arrowDown} desplazar · inicio/fin extremo` : suppressShowAll ? "" : ` · ${showAllShortcut} para ${showAllInTranscript ? "contraer" : "mostrar todo"}`;
+    let t3;
+    if ($[0] !== t2 || $[1] !== toggleShortcut) {
+        t3 = _jsxs(Text, { dimColor: true, children: ["Mostrando transcripci\u00F3n detallada \u00B7 ", toggleShortcut, " para alternar", t2] });
+        $[0] = t2;
+        $[1] = toggleShortcut;
+        $[2] = t3;
+    }
+    else {
+        t3 = $[2];
+    }
+    let t4;
+    if ($[3] !== searchBadge || $[4] !== status) {
+        t4 = status ? _jsxs(_Fragment, { children: [_jsx(Box, { flexGrow: 1 }), _jsxs(Text, { children: [status, " "] })] }) : searchBadge ? _jsxs(_Fragment, { children: [_jsx(Box, { flexGrow: 1 }), _jsxs(Text, { dimColor: true, children: [searchBadge.current, "/", searchBadge.count, "  "] })] }) : null;
+        $[3] = searchBadge;
+        $[4] = status;
+        $[5] = t4;
+    }
+    else {
+        t4 = $[5];
+    }
+    let t5;
+    if ($[6] !== t3 || $[7] !== t4) {
+        t5 = _jsxs(Box, { noSelect: true, alignItems: "center", alignSelf: "center", borderTopDimColor: true, borderBottom: false, borderLeft: false, borderRight: false, borderStyle: "single", marginTop: 1, paddingLeft: 2, width: "100%", children: [t3, t4] });
+        $[6] = t3;
+        $[7] = t4;
+        $[8] = t5;
+    }
+    else {
+        t5 = $[8];
+    }
+    return t5;
+}
+/** less-style / bar. 1-row, same border-top styling as TranscriptModeFooter
+ *  so swapping them in the bottom slot doesn't shift ScrollBox height.
+ *  useSearchInput handles readline editing; we report query changes and
+ *  render the counter. Incremental — re-search + highlight per keystroke. */
+function TranscriptSearchBar({ jumpRef, count, current, onClose, onCancel, setHighlight, initialQuery }) {
+    const { query, cursorOffset } = useSearchInput({
+        isActive: true,
+        initialQuery,
+        onExit: () => onClose(query),
+        onCancel
+    });
+    // Index warm-up runs before the query effect so it measures the real
+    // cost — otherwise setSearchQuery fills the cache first and warm
+    // reports ~0ms while the user felt the actual lag.
+    // First / in a transcript session pays the extractSearchText cost.
+    // Subsequent / return 0 immediately (indexWarmed ref in VML).
+    // Transcript is frozen at ctrl+o so the cache stays valid.
+    // Initial 'building' so warmDone is false on mount — the [query] effect
+    // waits for the warm effect's first resolve instead of racing it. With
+    // null initial, warmDone would be true on mount → [query] fires →
+    // setSearchQuery fills cache → warm reports ~0ms while the user felt
+    // the real lag.
+    const [indexStatus, setIndexStatus] = React.useState('building');
+    React.useEffect(() => {
+        let alive = true;
+        const warm = jumpRef.current?.warmSearchIndex;
+        if (!warm) {
+            setIndexStatus(null); // VML not mounted yet — rare, skip indicator
+            return;
+        }
+        setIndexStatus('building');
+        warm().then(ms => {
+            if (!alive)
+                return;
+            // <20ms = imperceptible. No point showing "indexed in 3ms".
+            if (ms < 20) {
+                setIndexStatus(null);
+            }
+            else {
+                setIndexStatus({
+                    ms
+                });
+                setTimeout(() => alive && setIndexStatus(null), 2000);
+            }
+        });
+        return () => {
+            alive = false;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []); // mount-only: bar opens once per /
+    // Gate the query effect on warm completion. setHighlight stays instant
+    // (screen-space overlay, no indexing). setSearchQuery (the scan) waits.
+    const warmDone = indexStatus !== 'building';
+    useEffect(() => {
+        if (!warmDone)
+            return;
+        jumpRef.current?.setSearchQuery(query);
+        setHighlight(query);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [query, warmDone]);
+    const off = cursorOffset;
+    const cursorChar = off < query.length ? query[off] : ' ';
+    return _jsxs(Box, { borderTopDimColor: true, borderBottom: false, borderLeft: false, borderRight: false, borderStyle: "single", marginTop: 1, paddingLeft: 2, width: "100%", 
+        // applySearchHighlight scans the whole screen buffer. The query
+        // text rendered here IS on screen — /foo matches its own 'foo' in
+        // the bar. With no content matches that's the ONLY visible match →
+        // gets CURRENT → underlined. noSelect makes searchHighlight.ts:76
+        // skip these cells (same exclusion as gutters). You can't text-
+        // select the bar either; it's transient chrome, fine.
+        noSelect: true, children: [_jsx(Text, { children: "/" }), _jsx(Text, { children: query.slice(0, off) }), _jsx(Text, { inverse: true, children: cursorChar }), off < query.length && _jsx(Text, { children: query.slice(off + 1) }), _jsx(Box, { flexGrow: 1 }), indexStatus === 'building' ? _jsx(Text, { dimColor: true, children: "indexando\u2026 " }) : indexStatus ? _jsxs(Text, { dimColor: true, children: ["indexado en ", indexStatus.ms, "ms "] }) : count === 0 && query ? _jsx(Text, { color: "error", children: "sin coincidencias " }) : count > 0 ?
+                _jsxs(Text, { dimColor: true, children: [current, "/", count, '  '] }) : null] });
+}
+const TITLE_ANIMATION_FRAMES = ['⠂', '⠐'];
+const TITLE_STATIC_PREFIX = '✳';
+const TITLE_ANIMATION_INTERVAL_MS = 960;
+/**
+ * Sets the terminal tab title, with an animated prefix glyph while a query
+ * is running. Isolated from REPL so the 960ms animation tick re-renders only
+ * this leaf component (which returns null — pure side-effect) instead of the
+ * entire REPL tree. Before extraction, the tick was ~1 REPL render/sec for
+ * the duration of every turn, dragging PromptInput and friends along.
+ */
+function AnimatedTerminalTitle(t0) {
+    const $ = _c(6);
+    const { isAnimating, title, disabled, noPrefix } = t0;
+    const terminalFocused = useTerminalFocus();
+    const [frame, setFrame] = useState(0);
+    let t1;
+    let t2;
+    if ($[0] !== disabled || $[1] !== isAnimating || $[2] !== noPrefix || $[3] !== terminalFocused) {
+        t1 = () => {
+            if (disabled || noPrefix || !isAnimating || !terminalFocused) {
+                return;
+            }
+            const interval = setInterval(_temp2, TITLE_ANIMATION_INTERVAL_MS, setFrame);
+            return () => clearInterval(interval);
+        };
+        t2 = [disabled, noPrefix, isAnimating, terminalFocused];
+        $[0] = disabled;
+        $[1] = isAnimating;
+        $[2] = noPrefix;
+        $[3] = terminalFocused;
+        $[4] = t1;
+        $[5] = t2;
+    }
+    else {
+        t1 = $[4];
+        t2 = $[5];
+    }
+    useEffect(t1, t2);
+    const prefix = isAnimating ? TITLE_ANIMATION_FRAMES[frame] ?? TITLE_STATIC_PREFIX : TITLE_STATIC_PREFIX;
+    useTerminalTitle(disabled ? null : noPrefix ? title : `${prefix} ${title}`);
+    return null;
+}
+function _temp2(setFrame_0) {
+    return setFrame_0(_temp);
+}
+function _temp(f) {
+    return (f + 1) % TITLE_ANIMATION_FRAMES.length;
+}
+export function REPL({ commands: initialCommands, debug, initialTools, initialMessages, pendingHookMessages, initialFileHistorySnapshots, initialContentReplacements, initialAgentName, initialAgentColor, mcpClients: initialMcpClients, dynamicMcpConfig: initialDynamicMcpConfig, autoConnectIdeFlag, strictMcpConfig = false, systemPrompt: customSystemPrompt, appendSystemPrompt, onBeforeQuery, onTurnComplete, disabled = false, mainThreadAgentDefinition: initialMainThreadAgentDefinition, disableSlashCommands = false, taskListId, remoteSessionConfig, directConnectConfig, sshSession, thinkingConfig }) {
+    const isRemoteSession = !!remoteSessionConfig;
+    // Env-var gates hoisted to mount-time — isEnvTruthy does toLowerCase+trim+
+    // includes, and these were on the render path (hot during PageUp spam).
+    const titleDisabled = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE), []);
+    const moreRightEnabled = useMemo(() => "external" === 'ant' && isEnvTruthy(process.env.CLAUDE_MORERIGHT), []);
+    const disableVirtualScroll = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL), []);
+    const disableMessageActions = feature('MESSAGE_ACTIONS') ?
+        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+        useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_MESSAGE_ACTIONS), []) : false;
+    // Log REPL mount/unmount lifecycle
+    useEffect(() => {
+        logForDebugging(`[REPL:mount] REPL mounted, disabled=${disabled}`);
+        return () => logForDebugging(`[REPL:unmount] REPL unmounting`);
+    }, [disabled]);
+    // Agent definition is state so /resume can update it mid-session
+    const [mainThreadAgentDefinition, setMainThreadAgentDefinition] = useState(initialMainThreadAgentDefinition);
+    const toolPermissionContext = useAppState(s => s.toolPermissionContext);
+    const verbose = useAppState(s => s.verbose);
+    const mcp = useAppState(s => s.mcp);
+    const plugins = useAppState(s => s.plugins);
+    const agentDefinitions = useAppState(s => s.agentDefinitions);
+    const fileHistory = useAppState(s => s.fileHistory);
+    const initialMessage = useAppState(s => s.initialMessage);
+    const queuedCommands = useCommandQueue();
+    // feature() is a build-time constant — dead code elimination removes the hook
+    // call entirely in external builds, so this is safe despite looking conditional.
+    // These fields contain excluded strings that must not appear in external builds.
+    const spinnerTip = useAppState(s => s.spinnerTip);
+    const showExpandedTodos = useAppState(s => s.expandedView) === 'tasks';
+    const pendingWorkerRequest = useAppState(s => s.pendingWorkerRequest);
+    const pendingSandboxRequest = useAppState(s => s.pendingSandboxRequest);
+    const teamContext = useAppState(s => s.teamContext);
+    const tasks = useAppState(s => s.tasks);
+    const workerSandboxPermissions = useAppState(s => s.workerSandboxPermissions);
+    const elicitation = useAppState(s => s.elicitation);
+    const ultraplanPendingChoice = useAppState(s => s.ultraplanPendingChoice);
+    const ultraplanLaunchPending = useAppState(s => s.ultraplanLaunchPending);
+    const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId);
+    const setAppState = useSetAppState();
+    // Bootstrap: retained local_agent that hasn't loaded disk yet → read
+    // sidechain JSONL and UUID-merge with whatever stream has appended so far.
+    // Stream appends immediately on retain (no defer); bootstrap fills the
+    // prefix. Disk-write-before-yield means live is always a suffix of disk.
+    const viewedLocalAgent = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined;
+    const needsBootstrap = isLocalAgentTask(viewedLocalAgent) && viewedLocalAgent.retain && !viewedLocalAgent.diskLoaded;
+    useEffect(() => {
+        if (!viewingAgentTaskId || !needsBootstrap)
+            return;
+        const taskId = viewingAgentTaskId;
+        void getAgentTranscript(asAgentId(taskId)).then(result => {
+            setAppState(prev => {
+                const t = prev.tasks[taskId];
+                if (!isLocalAgentTask(t) || t.diskLoaded || !t.retain)
+                    return prev;
+                const live = t.messages ?? [];
+                const liveUuids = new Set(live.map(m => m.uuid));
+                const diskOnly = result ? result.messages.filter(m => !liveUuids.has(m.uuid)) : [];
+                return {
+                    ...prev,
+                    tasks: {
+                        ...prev.tasks,
+                        [taskId]: {
+                            ...t,
+                            messages: [...diskOnly, ...live],
+                            diskLoaded: true
+                        }
+                    }
+                };
+            });
+        });
+    }, [viewingAgentTaskId, needsBootstrap, setAppState]);
+    const store = useAppStateStore();
+    const terminal = useTerminalNotification();
+    const mainLoopModel = useMainLoopModel();
+    // Note: standaloneAgentContext is initialized in main.tsx (via initialState) or
+    // ResumeConversation.tsx (via setAppState before rendering REPL) to avoid
+    // useEffect-based state initialization on mount (per CLAUDE.md guidelines)
+    // Local state for commands (hot-reloadable when skill files change)
+    const [localCommands, setLocalCommands] = useState(initialCommands);
+    // Watch for skill file changes and reload all commands
+    useSkillsChange(isRemoteSession ? undefined : getProjectRoot(), setLocalCommands);
+    // Track proactive mode for tools dependency - SleepTool filters by proactive state
+    const proactiveActive = React.useSyncExternalStore(proactiveModule?.subscribeToProactiveChanges ?? PROACTIVE_NO_OP_SUBSCRIBE, proactiveModule?.isProactiveActive ?? PROACTIVE_FALSE);
+    // BriefTool.isEnabled() reads getUserMsgOptIn() from bootstrap state, which
+    // /brief flips mid-session alongside isBriefOnly. The memo below needs a
+    // React-visible dep to re-run getTools() when that happens; isBriefOnly is
+    // the AppState mirror that triggers the re-render. Without this, toggling
+    // /brief mid-session leaves the stale tool list (no SendUserMessage) and
+    // the model emits plain text the brief filter hides.
+    const isBriefOnly = useAppState(s => s.isBriefOnly);
+    const localTools = useMemo(() => getTools(toolPermissionContext), [toolPermissionContext, proactiveActive, isBriefOnly]);
+    useKickOffCheckAndDisableBypassPermissionsIfNeeded();
+    useKickOffCheckAndDisableAutoModeIfNeeded();
+    const [dynamicMcpConfig, setDynamicMcpConfig] = useState(initialDynamicMcpConfig);
+    const onChangeDynamicMcpConfig = useCallback((config) => {
+        setDynamicMcpConfig(config);
+    }, [setDynamicMcpConfig]);
+    const [screen, setScreen] = useState('prompt');
+    const [showAllInTranscript, setShowAllInTranscript] = useState(false);
+    // [ forces the dump-to-scrollback path inside transcript mode. Separate
+    // from CLAUDE_CODE_NO_FLICKER=0 (which is process-lifetime) — this is
+    // ephemeral, reset on transcript exit. Diagnostic escape hatch so
+    // terminal/tmux native cmd-F can search the full flat render.
+    const [dumpMode, setDumpMode] = useState(false);
+    // v-for-editor render progress. Inline in the footer — notifications
+    // render inside PromptInput which isn't mounted in transcript.
+    const [editorStatus, setEditorStatus] = useState('');
+    // Incremented on transcript exit. Async v-render captures this at start;
+    // each status write no-ops if stale (user left transcript mid-render —
+    // the stable setState would otherwise stamp a ghost toast into the next
+    // session). Also clears any pending 4s auto-clear.
+    const editorGenRef = useRef(0);
+    const editorTimerRef = useRef(undefined);
+    const editorRenderingRef = useRef(false);
+    const { addNotification, removeNotification } = useNotifications();
+    // eslint-disable-next-line prefer-const
+    let trySuggestBgPRIntercept = SUGGEST_BG_PR_NOOP;
+    const mcpClients = useMergedClients(initialMcpClients, mcp.clients);
+    // IDE integration
+    const [ideSelection, setIDESelection] = useState(undefined);
+    const [ideToInstallExtension, setIDEToInstallExtension] = useState(null);
+    const [ideInstallationStatus, setIDEInstallationStatus] = useState(null);
+    const [showIdeOnboarding, setShowIdeOnboarding] = useState(false);
+    // Dead code elimination: model switch callout state (ant-only)
+    const [showModelSwitchCallout, setShowModelSwitchCallout] = useState(() => {
+        if ("external" === 'ant') {
+            return shouldShowAntModelSwitch();
+        }
+        return false;
+    });
+    const [showEffortCallout, setShowEffortCallout] = useState(() => shouldShowEffortCallout(mainLoopModel));
+    const showRemoteCallout = useAppState(s => s.showRemoteCallout);
+    const [showDesktopUpsellStartup, setShowDesktopUpsellStartup] = useState(() => shouldShowDesktopUpsellStartup());
+    // notifications
+    useModelMigrationNotifications();
+    useCanSwitchToExistingSubscription();
+    useIDEStatusIndicator({
+        ideSelection,
+        mcpClients,
+        ideInstallationStatus
+    });
+    useMcpConnectivityStatus({
+        mcpClients
+    });
+    useAutoModeUnavailableNotification();
+    usePluginInstallationStatus();
+    usePluginAutoupdateNotification();
+    useSettingsErrors();
+    useRateLimitWarningNotification(mainLoopModel);
+    useFastModeNotification();
+    useDeprecationWarningNotification(mainLoopModel);
+    useNpmDeprecationNotification();
+    useAntOrgWarningNotification();
+    useInstallMessages();
+    useChromeExtensionNotification();
+    useOfficialMarketplaceNotification();
+    useLspInitializationNotification();
+    useTeammateLifecycleNotification();
+    const { recommendation: lspRecommendation, handleResponse: handleLspResponse } = useLspPluginRecommendation();
+    const { recommendation: hintRecommendation, handleResponse: handleHintResponse } = useClaudeCodeHintRecommendation();
+    // Memoize the combined initial tools array to prevent reference changes
+    const combinedInitialTools = useMemo(() => {
+        return [...localTools, ...initialTools];
+    }, [localTools, initialTools]);
+    // Initialize plugin management
+    useManagePlugins({
+        enabled: !isRemoteSession
+    });
+    const tasksV2 = useTasksV2WithCollapseEffect();
+    // Start background plugin installations
+    // SECURITY: This code is guaranteed to run ONLY after the "trust this folder" dialog
+    // has been confirmed by the user. The trust dialog is shown in cli.tsx (line ~387)
+    // before the REPL component is rendered. The dialog blocks execution until the user
+    // accepts, and only then is the REPL component mounted and this effect runs.
+    // This ensures that plugin installations from repository and user settings only
+    // happen after explicit user consent to trust the current working directory.
+    useEffect(() => {
+        if (isRemoteSession)
+            return;
+        void performStartupChecks(setAppState);
+    }, [setAppState, isRemoteSession]);
+    // Allow Claude in Chrome MCP to send prompts through MCP notifications
+    // and sync permission mode changes to the Chrome extension
+    usePromptsFromClaudeInChrome(isRemoteSession ? EMPTY_MCP_CLIENTS : mcpClients, toolPermissionContext.mode);
+    // Initialize swarm features: teammate hooks and context
+    // Handles both fresh spawns and resumed teammate sessions
+    useSwarmInitialization(setAppState, initialMessages, {
+        enabled: !isRemoteSession
+    });
+    const mergedTools = useMergedTools(combinedInitialTools, mcp.tools, toolPermissionContext);
+    // Apply agent tool restrictions if mainThreadAgentDefinition is set
+    const { tools, allowedAgentTypes } = useMemo(() => {
+        if (!mainThreadAgentDefinition) {
+            return {
+                tools: mergedTools,
+                allowedAgentTypes: undefined
+            };
+        }
+        const resolved = resolveAgentTools(mainThreadAgentDefinition, mergedTools, false, true);
+        return {
+            tools: resolved.resolvedTools,
+            allowedAgentTypes: resolved.allowedAgentTypes
+        };
+    }, [mainThreadAgentDefinition, mergedTools]);
+    // Merge commands from local state, plugins, and MCP
+    const commandsWithPlugins = useMergedCommands(localCommands, plugins.commands);
+    const mergedCommands = useMergedCommands(commandsWithPlugins, mcp.commands);
+    // Filter out all commands if disableSlashCommands is true
+    const commands = useMemo(() => disableSlashCommands ? [] : mergedCommands, [disableSlashCommands, mergedCommands]);
+    useIdeLogging(isRemoteSession ? EMPTY_MCP_CLIENTS : mcp.clients);
+    useIdeSelection(isRemoteSession ? EMPTY_MCP_CLIENTS : mcp.clients, setIDESelection);
+    const [streamMode, setStreamMode] = useState('responding');
+    // Ref mirror so onSubmit can read the latest value without adding
+    // streamMode to its deps. streamMode flips between
+    // requesting/responding/tool-use ~10x per turn during streaming; having it
+    // in onSubmit's deps was recreating onSubmit on every flip, which
+    // cascaded into PromptInput prop churn and downstream useCallback/useMemo
+    // invalidation. The only consumers inside callbacks are debug logging and
+    // telemetry (handlePromptSubmit.ts), so a stale-by-one-render value is
+    // harmless — but ref mirrors sync on every render anyway so it's fresh.
+    const streamModeRef = useRef(streamMode);
+    streamModeRef.current = streamMode;
+    const [streamingToolUses, setStreamingToolUses] = useState([]);
+    const [streamingThinking, setStreamingThinking] = useState(null);
+    // Auto-hide streaming thinking after 30 seconds of being completed
+    useEffect(() => {
+        if (streamingThinking && !streamingThinking.isStreaming && streamingThinking.streamingEndedAt) {
+            const elapsed = Date.now() - streamingThinking.streamingEndedAt;
+            const remaining = 30000 - elapsed;
+            if (remaining > 0) {
+                const timer = setTimeout(setStreamingThinking, remaining, null);
+                return () => clearTimeout(timer);
+            }
+            else {
+                setStreamingThinking(null);
+            }
+        }
+    }, [streamingThinking]);
+    const [abortController, setAbortController] = useState(null);
+    // Ref that always points to the current abort controller, used by the
+    // REPL bridge to abort the active query when a remote interrupt arrives.
+    const abortControllerRef = useRef(null);
+    abortControllerRef.current = abortController;
+    // Ref for the bridge result callback — set after useReplBridge initializes,
+    // read in the onQuery finally block to notify mobile clients that a turn ended.
+    const sendBridgeResultRef = useRef(() => { });
+    // Ref for the synchronous restore callback — set after restoreMessageSync is
+    // defined, read in the onQuery finally block for auto-restore on interrupt.
+    const restoreMessageSyncRef = useRef(() => { });
+    // Ref to the fullscreen layout's scroll box for keyboard scrolling.
+    // Null when fullscreen mode is disabled (ref never attached).
+    const scrollRef = useRef(null);
+    // Separate ref for the modal slot's inner ScrollBox — passed through
+    // FullscreenLayout → ModalContext so Tabs can attach it to its own
+    // ScrollBox for tall content (e.g. /status's MCP-server list). NOT
+    // keyboard-driven — ScrollKeybindingHandler stays on the outer ref so
+    // PgUp/PgDn/wheel always scroll the transcript behind the modal.
+    // Plumbing kept for future modal-scroll wiring.
+    const modalScrollRef = useRef(null);
+    // Timestamp of the last user-initiated scroll (wheel, PgUp/PgDn, ctrl+u,
+    // End/Home, G, drag-to-scroll). Stamped in composedOnScroll — the single
+    // chokepoint ScrollKeybindingHandler calls for every user scroll action.
+    // Programmatic scrolls (repinScroll's scrollToBottom, sticky auto-follow)
+    // do NOT go through composedOnScroll, so they don't stamp this. Ref not
+    // state: no re-render on every wheel tick.
+    const lastUserScrollTsRef = useRef(0);
+    // Synchronous state machine for the query lifecycle. Replaces the
+    // error-prone dual-state pattern where isLoading (React state, async
+    // batched) and isQueryRunning (ref, sync) could desync. See QueryGuard.ts.
+    const queryGuard = React.useRef(new QueryGuard()).current;
+    // Subscribe to the guard — true during dispatching or running.
+    // This is the single source of truth for "is a local query in flight".
+    const isQueryActive = React.useSyncExternalStore(queryGuard.subscribe, queryGuard.getSnapshot);
+    // Separate loading flag for operations outside the local query guard:
+    // remote sessions (useRemoteSession / useDirectConnect) and foregrounded
+    // background tasks (useSessionBackgrounding). These don't route through
+    // onQuery / queryGuard, so they need their own spinner-visibility state.
+    // Initialize true if remote mode with initial prompt (CCR processing it).
+    const [isExternalLoading, setIsExternalLoadingRaw] = React.useState(remoteSessionConfig?.hasInitialPrompt ?? false);
+    // Derived: any loading source active. Read-only — no setter. Local query
+    // loading is driven by queryGuard (reserve/tryStart/end/cancelReservation),
+    // external loading by setIsExternalLoading.
+    const isLoading = isQueryActive || isExternalLoading;
+    // Elapsed time is computed by SpinnerWithVerb from these refs on each
+    // animation frame, avoiding a useInterval that re-renders the entire REPL.
+    const [userInputOnProcessing, setUserInputOnProcessingRaw] = React.useState(undefined);
+    // messagesRef.current.length at the moment userInputOnProcessing was set.
+    // The placeholder hides once displayedMessages grows past this — i.e. the
+    // real user message has landed in the visible transcript.
+    const userInputBaselineRef = React.useRef(0);
+    // True while the submitted prompt is being processed but its user message
+    // hasn't reached setMessages yet. setMessages uses this to keep the
+    // baseline in sync when unrelated async messages (bridge status, hook
+    // results, scheduled tasks) land during that window.
+    const userMessagePendingRef = React.useRef(false);
+    // Wall-clock time tracking refs for accurate elapsed time calculation
+    const loadingStartTimeRef = React.useRef(0);
+    const totalPausedMsRef = React.useRef(0);
+    const pauseStartTimeRef = React.useRef(null);
+    const resetTimingRefs = React.useCallback(() => {
+        loadingStartTimeRef.current = Date.now();
+        totalPausedMsRef.current = 0;
+        pauseStartTimeRef.current = null;
+    }, []);
+    // Reset timing refs inline when isQueryActive transitions false→true.
+    // queryGuard.reserve() (in executeUserInput) fires BEFORE processUserInput's
+    // first await, but the ref reset in onQuery's try block runs AFTER. During
+    // that gap, React renders the spinner with loadingStartTimeRef=0, computing
+    // elapsedTimeMs = Date.now() - 0 ≈ 56 years. This inline reset runs on the
+    // first render where isQueryActive is observed true — the same render that
+    // first shows the spinner — so the ref is correct by the time the spinner
+    // reads it. See INC-4549.
+    const wasQueryActiveRef = React.useRef(false);
+    if (isQueryActive && !wasQueryActiveRef.current) {
+        resetTimingRefs();
+    }
+    wasQueryActiveRef.current = isQueryActive;
+    // Wrapper for setIsExternalLoading that resets timing refs on transition
+    // to true — SpinnerWithVerb reads these for elapsed time, so they must be
+    // reset for remote sessions / foregrounded tasks too (not just local
+    // queries, which reset them in onQuery). Without this, a remote-only
+    // session would show ~56 years elapsed (Date.now() - 0).
+    const setIsExternalLoading = React.useCallback((value) => {
+        setIsExternalLoadingRaw(value);
+        if (value)
+            resetTimingRefs();
+    }, [resetTimingRefs]);
+    // Start time of the first turn that had swarm teammates running
+    // Used to compute total elapsed time (including teammate execution) for the deferred message
+    const swarmStartTimeRef = React.useRef(null);
+    const swarmBudgetInfoRef = React.useRef(undefined);
+    // Ref to track current focusedInputDialog for use in callbacks
+    // This avoids stale closures when checking dialog state in timer callbacks
+    const focusedInputDialogRef = React.useRef(undefined);
+    // How long after the last keystroke before deferred dialogs are shown
+    const PROMPT_SUPPRESSION_MS = 1500;
+    // True when user is actively typing — defers interrupt dialogs so keystrokes
+    // don't accidentally dismiss or answer a permission prompt the user hasn't read yet.
+    const [isPromptInputActive, setIsPromptInputActive] = React.useState(false);
+    const [autoUpdaterResult, setAutoUpdaterResult] = useState(null);
+    useEffect(() => {
+        if (autoUpdaterResult?.notifications) {
+            autoUpdaterResult.notifications.forEach(notification => {
+                addNotification({
+                    key: 'auto-updater-notification',
+                    text: notification,
+                    priority: 'low'
+                });
+            });
+        }
+    }, [autoUpdaterResult, addNotification]);
+    // tmux + fullscreen + `mouse off`: one-time hint that wheel won't scroll.
+    // We no longer mutate tmux's session-scoped mouse option (it poisoned
+    // sibling panes); tmux users already know this tradeoff from vim/less.
+    useEffect(() => {
+        if (isFullscreenEnvEnabled()) {
+            void maybeGetTmuxMouseHint().then(hint => {
+                if (hint) {
+                    addNotification({
+                        key: 'tmux-mouse-hint',
+                        text: hint,
+                        priority: 'low'
+                    });
+                }
+            });
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const [showUndercoverCallout, setShowUndercoverCallout] = useState(false);
+    useEffect(() => {
+        if ("external" === 'ant') {
+            void (async () => {
+                // Wait for repo classification to settle (memoized, no-op if primed).
+                const { isInternalModelRepo } = await import('../utils/commitAttribution.js');
+                await isInternalModelRepo();
+                const { shouldShowUndercoverAutoNotice } = await import('../utils/undercover.js');
+                if (shouldShowUndercoverAutoNotice()) {
+                    setShowUndercoverCallout(true);
+                }
+            })();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const [toolJSX, setToolJSXInternal] = useState(null);
+    // Track local JSX commands separately so tools can't overwrite them.
+    // This enables "immediate" commands (like /btw) to persist while Claude is processing.
+    const localJSXCommandRef = useRef(null);
+    // Wrapper for setToolJSX that preserves local JSX commands (like /btw).
+    // When a local JSX command is active, we ignore updates from tools
+    // unless they explicitly set clearLocalJSX: true (from onDone callbacks).
+    //
+    // TO ADD A NEW IMMEDIATE COMMAND:
+    // 1. Set `immediate: true` in the command definition
+    // 2. Set `isLocalJSXCommand: true` when calling setToolJSX in the command's JSX
+    // 3. In the onDone callback, use `setToolJSX({ jsx: null, shouldHidePromptInput: false, clearLocalJSX: true })`
+    //    to explicitly clear the overlay when the user dismisses it
+    const setToolJSX = useCallback((args) => {
+        // If setting a local JSX command, store it in the ref
+        if (args?.isLocalJSXCommand) {
+            const { clearLocalJSX: _, ...rest } = args;
+            localJSXCommandRef.current = {
+                ...rest,
+                isLocalJSXCommand: true
+            };
+            setToolJSXInternal(rest);
+            return;
+        }
+        // If there's an active local JSX command in the ref
+        if (localJSXCommandRef.current) {
+            // Allow clearing only if explicitly requested (from onDone callbacks)
+            if (args?.clearLocalJSX) {
+                localJSXCommandRef.current = null;
+                setToolJSXInternal(null);
+                return;
+            }
+            // Otherwise, keep the local JSX command visible - ignore tool updates
+            return;
+        }
+        // No active local JSX command, allow any update
+        if (args?.clearLocalJSX) {
+            setToolJSXInternal(null);
+            return;
+        }
+        setToolJSXInternal(args);
+    }, []);
+    const [toolUseConfirmQueue, setToolUseConfirmQueue] = useState([]);
+    // Sticky footer JSX registered by permission request components (currently
+    // only ExitPlanModePermissionRequest). Renders in FullscreenLayout's `bottom`
+    // slot so response options stay visible while the user scrolls a long plan.
+    const [permissionStickyFooter, setPermissionStickyFooter] = useState(null);
+    const [sandboxPermissionRequestQueue, setSandboxPermissionRequestQueue] = useState([]);
+    const [promptQueue, setPromptQueue] = useState([]);
+    // Track bridge cleanup functions for sandbox permission requests so the
+    // local dialog handler can cancel the remote prompt when the local user
+    // responds first. Keyed by host to support concurrent same-host requests.
+    const sandboxBridgeCleanupRef = useRef(new Map());
+    // -- Terminal title management
+    // Session title (set via /rename or restored on resume) wins over
+    // the agent name, which wins over the Haiku-extracted topic;
+    // all fall back to the product name.
+    const terminalTitleFromRename = useAppState(s => s.settings.terminalTitleFromRename) !== false;
+    const sessionTitle = terminalTitleFromRename ? getCurrentSessionTitle(getSessionId()) : undefined;
+    const [haikuTitle, setHaikuTitle] = useState();
+    // Gates the one-shot Haiku call that generates the tab title. Seeded true
+    // on resume (initialMessages present) so we don't re-title a resumed
+    // session from mid-conversation context.
+    const haikuTitleAttemptedRef = useRef((initialMessages?.length ?? 0) > 0);
+    const agentTitle = mainThreadAgentDefinition?.agentType;
+    const terminalTitle = sessionTitle ?? agentTitle ?? haikuTitle ?? 'Context Code';
+    const isWaitingForApproval = toolUseConfirmQueue.length > 0 || promptQueue.length > 0 || pendingWorkerRequest || pendingSandboxRequest;
+    // Local-jsx commands (like /plugin, /config) show user-facing dialogs that
+    // wait for input. Require jsx != null — if the flag is stuck true but jsx
+    // is null, treat as not-showing so TextInput focus and queue processor
+    // aren't deadlocked by a phantom overlay.
+    const isShowingLocalJSXCommand = toolJSX?.isLocalJSXCommand === true && toolJSX?.jsx != null;
+    const titleIsAnimating = isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand;
+    // Title animation state lives in <AnimatedTerminalTitle> so the 960ms tick
+    // doesn't re-render REPL. titleDisabled/terminalTitle are still computed
+    // here because onQueryImpl reads them (background session description,
+    // haiku title extraction gate).
+    // Prevent macOS from sleeping while Claude is working
+    useEffect(() => {
+        if (isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand) {
+            startPreventSleep();
+            return () => stopPreventSleep();
+        }
+    }, [isLoading, isWaitingForApproval, isShowingLocalJSXCommand]);
+    const sessionStatus = isWaitingForApproval || isShowingLocalJSXCommand ? 'waiting' : isLoading ? 'busy' : 'idle';
+    const waitingFor = sessionStatus !== 'waiting' ? undefined : toolUseConfirmQueue.length > 0 ? `approve ${toolUseConfirmQueue[0].tool.name}` : pendingWorkerRequest ? 'worker request' : pendingSandboxRequest ? 'sandbox request' : isShowingLocalJSXCommand ? 'dialog open' : 'input needed';
+    // Push status to the PID file for `claude ps`. Fire-and-forget; ps falls
+    // back to transcript-tail derivation when this is missing/stale.
+    useEffect(() => {
+        if (feature('BG_SESSIONS')) {
+            void updateSessionActivity({
+                status: sessionStatus,
+                waitingFor
+            });
+        }
+    }, [sessionStatus, waitingFor]);
+    // 3P default: off — OSC 21337 is ant-only while the spec stabilizes.
+    // Gated so we can roll back if the sidebar indicator conflicts with
+    // the title spinner in terminals that render both. When the flag is
+    // on, the user-facing config setting controls whether it's active.
+    const tabStatusGateEnabled = getFeatureValue_CACHED_MAY_BE_STALE('tengu_terminal_sidebar', false);
+    const showStatusInTerminalTab = tabStatusGateEnabled && (getGlobalConfig().showStatusInTerminalTab ?? false);
+    useTabStatus(titleDisabled || !showStatusInTerminalTab ? null : sessionStatus);
+    // Register the leader's setToolUseConfirmQueue for in-process teammates
+    useEffect(() => {
+        registerLeaderToolUseConfirmQueue(setToolUseConfirmQueue);
+        return () => unregisterLeaderToolUseConfirmQueue();
+    }, [setToolUseConfirmQueue]);
+    const [messages, rawSetMessages] = useState(initialMessages ?? []);
+    const messagesRef = useRef(messages);
+    // Stores the willowMode variant that was shown (or false if no hint shown).
+    // Captured at hint_shown time so hint_converted telemetry reports the same
+    // variant — the GrowthBook value shouldn't change mid-session, but reading
+    // it once guarantees consistency between the paired events.
+    const idleHintShownRef = useRef(false);
+    // Wrap setMessages so messagesRef is always current the instant the
+    // call returns — not when React later processes the batch.  Apply the
+    // updater eagerly against the ref, then hand React the computed value
+    // (not the function).  rawSetMessages batching becomes last-write-wins,
+    // and the last write is correct because each call composes against the
+    // already-updated ref.  This is the Zustand pattern: ref is source of
+    // truth, React state is the render projection.  Without this, paths
+    // that queue functional updaters then synchronously read the ref
+    // (e.g. handleSpeculationAccept → onQuery) see stale data.
+    const setMessages = useCallback((action) => {
+        const prev = messagesRef.current;
+        const next = typeof action === 'function' ? action(messagesRef.current) : action;
+        messagesRef.current = next;
+        if (next.length < userInputBaselineRef.current) {
+            // Shrank (compact/rewind/clear) — clamp so placeholderText's length
+            // check can't go stale.
+            userInputBaselineRef.current = 0;
+        }
+        else if (next.length > prev.length && userMessagePendingRef.current) {
+            // Grew while the submitted user message hasn't landed yet. If the
+            // added messages don't include it (bridge status, hook results,
+            // scheduled tasks landing async during processUserInputBase), bump
+            // baseline so the placeholder stays visible. Once the user message
+            // lands, stop tracking — later additions (assistant stream) should
+            // not re-show the placeholder.
+            const delta = next.length - prev.length;
+            const added = prev.length === 0 || next[0] === prev[0] ? next.slice(-delta) : next.slice(0, delta);
+            if (added.some(isHumanTurn)) {
+                userMessagePendingRef.current = false;
+            }
+            else {
+                userInputBaselineRef.current = next.length;
+            }
+        }
+        rawSetMessages(next);
+    }, []);
+    // Capture the baseline message count alongside the placeholder text so
+    // the render can hide it once displayedMessages grows past the baseline.
+    const setUserInputOnProcessing = useCallback((input) => {
+        if (input !== undefined) {
+            userInputBaselineRef.current = messagesRef.current.length;
+            userMessagePendingRef.current = true;
+        }
+        else {
+            userMessagePendingRef.current = false;
+        }
+        setUserInputOnProcessingRaw(input);
+    }, []);
+    // Fullscreen: track the unseen-divider position. dividerIndex changes
+    // only ~twice/scroll-session (first scroll-away + repin). pillVisible
+    // and stickyPrompt now live in FullscreenLayout — they subscribe to
+    // ScrollBox directly so per-frame scroll never re-renders REPL.
+    const { dividerIndex, dividerYRef, onScrollAway, onRepin, jumpToNew, shiftDivider } = useUnseenDivider(messages.length);
+    if (feature('AWAY_SUMMARY')) {
+        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+        useAwaySummary(messages, setMessages, isLoading);
+    }
+    const [cursor, setCursor] = useState(null);
+    const cursorNavRef = useRef(null);
+    // Memoized so Messages' React.memo holds.
+    const unseenDivider = useMemo(() => computeUnseenDivider(messages, dividerIndex), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- length change covers appends; useUnseenDivider's count-drop guard clears dividerIndex on replace/rewind
+    [dividerIndex, messages.length]);
+    // Re-pin scroll to bottom and clear the unseen-messages baseline. Called
+    // on any user-driven return-to-live action (submit, type-into-empty,
+    // overlay appear/dismiss).
+    const repinScroll = useCallback(() => {
+        scrollRef.current?.scrollToBottom();
+        onRepin();
+        setCursor(null);
+    }, [onRepin, setCursor]);
+    // Backstop for the submit-handler repin at onSubmit. If a buffered stdin
+    // event (wheel/drag) races between handler-fire and state-commit, the
+    // handler's scrollToBottom can be undone. This effect fires on the render
+    // where the user's message actually lands — tied to React's commit cycle,
+    // so it can't race with stdin. Keyed on lastMsg identity (not messages.length)
+    // so useAssistantHistory's prepends don't spuriously repin.
+    const lastMsg = messages.at(-1);
+    const lastMsgIsHuman = lastMsg != null && isHumanTurn(lastMsg);
+    useEffect(() => {
+        if (lastMsgIsHuman) {
+            repinScroll();
+        }
+    }, [lastMsgIsHuman, lastMsg, repinScroll]);
+    // Assistant-chat: lazy-load remote history on scroll-up. No-op unless
+    // KAIROS build + config.viewerOnly. feature() is build-time constant so
+    // the branch is dead-code-eliminated in non-KAIROS builds (same pattern
+    // as useUnseenDivider above).
+    const { maybeLoadOlder } = feature('KAIROS') ?
+        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+        useAssistantHistory({
+            config: remoteSessionConfig,
+            setMessages,
+            scrollRef,
+            onPrepend: shiftDivider
+        }) : HISTORY_STUB;
+    // Compose useUnseenDivider's callbacks with the lazy-load trigger.
+    const composedOnScroll = useCallback((sticky, handle) => {
+        lastUserScrollTsRef.current = Date.now();
+        if (sticky) {
+            onRepin();
+        }
+        else {
+            onScrollAway(handle);
+            if (feature('KAIROS'))
+                maybeLoadOlder(handle);
+            // Dismiss the companion bubble on scroll — it's absolute-positioned
+            // at bottom-right and covers transcript content. Scrolling = user is
+            // trying to read something under it.
+            if (feature('BUDDY')) {
+                setAppState(prev => prev.companionReaction === undefined ? prev : {
+                    ...prev,
+                    companionReaction: undefined
+                });
+            }
+        }
+    }, [onRepin, onScrollAway, maybeLoadOlder, setAppState]);
+    // Deferred SessionStart hook messages — REPL renders immediately and
+    // hook messages are injected when they resolve. awaitPendingHooks()
+    // must be called before the first API call so the model sees hook context.
+    const awaitPendingHooks = useDeferredHookMessages(pendingHookMessages, setMessages);
+    // Deferred messages for the Messages component — renders at transition
+    // priority so the reconciler yields every 5ms, keeping input responsive
+    // while the expensive message processing pipeline runs.
+    const deferredMessages = useDeferredValue(messages);
+    const deferredBehind = messages.length - deferredMessages.length;
+    if (deferredBehind > 0) {
+        logForDebugging(`[useDeferredValue] Messages deferred by ${deferredBehind} (${deferredMessages.length}→${messages.length})`);
+    }
+    // Frozen state for transcript mode - stores lengths instead of cloning arrays for memory efficiency
+    const [frozenTranscriptState, setFrozenTranscriptState] = useState(null);
+    // Initialize input with any early input that was captured before REPL was ready.
+    // Using lazy initialization ensures cursor offset is set correctly in PromptInput.
+    const [inputValue, setInputValueRaw] = useState(() => consumeEarlyInput());
+    const inputValueRef = useRef(inputValue);
+    inputValueRef.current = inputValue;
+    const insertTextRef = useRef(null);
+    // Wrap setInputValue to co-locate suppression state updates.
+    // Both setState calls happen in the same synchronous context so React
+    // batches them into a single render, eliminating the extra render that
+    // the previous useEffect → setState pattern caused.
+    const setInputValue = useCallback((value) => {
+        if (trySuggestBgPRIntercept(inputValueRef.current, value))
+            return;
+        // In fullscreen mode, typing into an empty prompt re-pins scroll to
+        // bottom. Only fires on empty→non-empty so scrolling up to reference
+        // something while composing a message doesn't yank the view back on
+        // every keystroke. Restores the pre-fullscreen muscle memory of
+        // typing to snap back to the end of the conversation.
+        // Skipped if the user scrolled within the last 3s — they're actively
+        // reading, not lost. lastUserScrollTsRef starts at 0 so the first-
+        // ever keypress (no scroll yet) always repins.
+        if (inputValueRef.current === '' && value !== '' && Date.now() - lastUserScrollTsRef.current >= RECENT_SCROLL_REPIN_WINDOW_MS) {
+            repinScroll();
+        }
+        // Sync ref immediately (like setMessages) so callers that read
+        // inputValueRef before React commits — e.g. the auto-restore finally
+        // block's `=== ''` guard — see the fresh value, not the stale render.
+        inputValueRef.current = value;
+        setInputValueRaw(value);
+        setIsPromptInputActive(value.trim().length > 0);
+    }, [setIsPromptInputActive, repinScroll, trySuggestBgPRIntercept]);
+    // Schedule a timeout to stop suppressing dialogs after the user stops typing.
+    // Only manages the timeout — the immediate activation is handled by setInputValue above.
+    useEffect(() => {
+        if (inputValue.trim().length === 0)
+            return;
+        const timer = setTimeout(setIsPromptInputActive, PROMPT_SUPPRESSION_MS, false);
+        return () => clearTimeout(timer);
+    }, [inputValue]);
+    const [inputMode, setInputMode] = useState('prompt');
+    const [stashedPrompt, setStashedPrompt] = useState();
+    // Callback to filter commands based on CCR's available slash commands
+    const handleRemoteInit = useCallback((remoteSlashCommands) => {
+        const remoteCommandSet = new Set(remoteSlashCommands);
+        // Keep commands that CCR lists OR that are in the local-safe set
+        setLocalCommands(prev => prev.filter(cmd => remoteCommandSet.has(cmd.name) || REMOTE_SAFE_COMMANDS.has(cmd)));
+    }, [setLocalCommands]);
+    const [inProgressToolUseIDs, setInProgressToolUseIDs] = useState(new Set());
+    const hasInterruptibleToolInProgressRef = useRef(false);
+    // Remote session hook - manages WebSocket connection and message handling for --remote mode
+    const remoteSession = useRemoteSession({
+        config: remoteSessionConfig,
+        setMessages,
+        setIsLoading: setIsExternalLoading,
+        onInit: handleRemoteInit,
+        setToolUseConfirmQueue,
+        tools: combinedInitialTools,
+        setStreamingToolUses,
+        setStreamMode,
+        setInProgressToolUseIDs
+    });
+    // Direct connect hook - manages WebSocket to a claude server for `claude connect` mode
+    const directConnect = useDirectConnect({
+        config: directConnectConfig,
+        setMessages,
+        setIsLoading: setIsExternalLoading,
+        setToolUseConfirmQueue,
+        tools: combinedInitialTools
+    });
+    // SSH session hook - manages ssh child process for `claude ssh` mode.
+    // Same callback shape as useDirectConnect; only the transport under the
+    // hood differs (ChildProcess stdin/stdout vs WebSocket).
+    const sshRemote = useSSHSession({
+        session: sshSession,
+        setMessages,
+        setIsLoading: setIsExternalLoading,
+        setToolUseConfirmQueue,
+        tools: combinedInitialTools
+    });
+    // Use whichever remote mode is active
+    const activeRemote = sshRemote.isRemoteMode ? sshRemote : directConnect.isRemoteMode ? directConnect : remoteSession;
+    const [pastedContents, setPastedContents] = useState({});
+    const [submitCount, setSubmitCount] = useState(0);
+    // Ref instead of state to avoid triggering React re-renders on every
+    // streaming text_delta. The spinner reads this via its animation timer.
+    const responseLengthRef = useRef(0);
+    // API performance metrics ref for ant-only spinner display (TTFT/OTPS).
+    // Accumulates metrics from all API requests in a turn for P50 aggregation.
+    const apiMetricsRef = useRef([]);
+    const setResponseLength = useCallback((f) => {
+        const prev = responseLengthRef.current;
+        responseLengthRef.current = f(prev);
+        // When content is added (not a compaction reset), update the latest
+        // metrics entry so OTPS reflects all content generation activity.
+        // Updating lastTokenTime here ensures the denominator includes both
+        // streaming time AND subagent execution time, preventing inflation.
+        if (responseLengthRef.current > prev) {
+            const entries = apiMetricsRef.current;
+            if (entries.length > 0) {
+                const lastEntry = entries.at(-1);
+                lastEntry.lastTokenTime = Date.now();
+                lastEntry.endResponseLength = responseLengthRef.current;
+            }
+        }
+    }, []);
+    // Streaming text display: set state directly per delta (Ink's 16ms render
+    // throttle batches rapid updates). Cleared on message arrival (messages.ts)
+    // so displayedMessages switches from deferredMessages to messages atomically.
+    const [streamingText, setStreamingText] = useState(null);
+    const reducedMotion = useAppState(s => s.settings.prefersReducedMotion) ?? false;
+    const showStreamingText = !reducedMotion && !hasCursorUpViewportYankBug();
+    const onStreamingText = useCallback((f) => {
+        if (!showStreamingText)
+            return;
+        setStreamingText(f);
+    }, [showStreamingText]);
+    // Hide the in-progress source line so text streams line-by-line, not
+    // char-by-char. lastIndexOf returns -1 when no newline, giving '' → null.
+    // Guard on showStreamingText so toggling reducedMotion mid-stream
+    // immediately hides the streaming preview.
+    const visibleStreamingText = streamingText && showStreamingText ? streamingText.substring(0, streamingText.lastIndexOf('\n') + 1) || null : null;
+    const [lastQueryCompletionTime, setLastQueryCompletionTime] = useState(0);
+    const [spinnerMessage, setSpinnerMessage] = useState(null);
+    const [spinnerColor, setSpinnerColor] = useState(null);
+    const [spinnerShimmerColor, setSpinnerShimmerColor] = useState(null);
+    const [isMessageSelectorVisible, setIsMessageSelectorVisible] = useState(false);
+    const [messageSelectorPreselect, setMessageSelectorPreselect] = useState(undefined);
+    const [showCostDialog, setShowCostDialog] = useState(false);
+    const [conversationId, setConversationId] = useState(randomUUID());
+    // Idle-return dialog: shown when user submits after a long idle gap
+    const [idleReturnPending, setIdleReturnPending] = useState(null);
+    const skipIdleCheckRef = useRef(false);
+    const lastQueryCompletionTimeRef = useRef(lastQueryCompletionTime);
+    lastQueryCompletionTimeRef.current = lastQueryCompletionTime;
+    // Aggregate tool result budget: per-conversation decision tracking.
+    // When the GrowthBook flag is on, query.ts enforces the budget; when
+    // off (undefined), enforcement is skipped entirely. Stale entries after
+    // /clear, rewind, or compact are harmless (tool_use_ids are UUIDs, stale
+    // keys are never looked up). Memory is bounded by total replacement count
+    // × ~2KB preview over the REPL lifetime — negligible.
+    //
+    // Lazy init via useState initializer — useRef(expr) evaluates expr on every
+    // render (React ignores it after first, but the computation still runs).
+    // For large resumed sessions, reconstruction does O(messages × blocks)
+    // work; we only want that once.
+    const [contentReplacementStateRef] = useState(() => ({
+        current: provisionContentReplacementState(initialMessages, initialContentReplacements)
+    }));
+    const [haveShownCostDialog, setHaveShownCostDialog] = useState(getGlobalConfig().hasAcknowledgedCostThreshold);
+    const [vimMode, setVimMode] = useState('INSERT');
+    const [showBashesDialog, setShowBashesDialog] = useState(false);
+    const [isSearchingHistory, setIsSearchingHistory] = useState(false);
+    const [isHelpOpen, setIsHelpOpen] = useState(false);
+    // showBashesDialog is REPL-level so it survives PromptInput unmounting.
+    // When ultraplan approval fires while the pill dialog is open, PromptInput
+    // unmounts (focusedInputDialog → 'ultraplan-choice') but this stays true;
+    // after accepting, PromptInput remounts into an empty "No tasks" dialog
+    // (the completed ultraplan task has been filtered out). Close it here.
+    useEffect(() => {
+        if (ultraplanPendingChoice && showBashesDialog) {
+            setShowBashesDialog(false);
+        }
+    }, [ultraplanPendingChoice, showBashesDialog]);
+    const isTerminalFocused = useTerminalFocus();
+    const terminalFocusRef = useRef(isTerminalFocused);
+    terminalFocusRef.current = isTerminalFocused;
+    const [theme] = useTheme();
+    // resetLoadingState runs twice per turn (onQueryImpl tail + onQuery finally).
+    // Without this guard, both calls pick a tip → two recordShownTip → two
+    // saveGlobalConfig writes back-to-back. Reset at submit in onSubmit.
+    const tipPickedThisTurnRef = React.useRef(false);
+    const pickNewSpinnerTip = useCallback(() => {
+        if (tipPickedThisTurnRef.current)
+            return;
+        tipPickedThisTurnRef.current = true;
+        const newMessages = messagesRef.current.slice(bashToolsProcessedIdx.current);
+        for (const tool of extractBashToolsFromMessages(newMessages)) {
+            bashTools.current.add(tool);
+        }
+        bashToolsProcessedIdx.current = messagesRef.current.length;
+        void getTipToShowOnSpinner({
+            theme,
+            readFileState: readFileState.current,
+            bashTools: bashTools.current
+        }).then(async (tip) => {
+            if (tip) {
+                const content = await tip.content({
+                    theme
+                });
+                setAppState(prev => ({
+                    ...prev,
+                    spinnerTip: content
+                }));
+                recordShownTip(tip);
+            }
+            else {
+                setAppState(prev => {
+                    if (prev.spinnerTip === undefined)
+                        return prev;
+                    return {
+                        ...prev,
+                        spinnerTip: undefined
+                    };
+                });
+            }
+        });
+    }, [setAppState, theme]);
+    // Resets UI loading state. Does NOT call onTurnComplete - that should be
+    // called explicitly only when a query turn actually completes.
+    const resetLoadingState = useCallback(() => {
+        // isLoading is now derived from queryGuard — no setter call needed.
+        // queryGuard.end() (onQuery finally) or cancelReservation() (executeUserInput
+        // finally) have already transitioned the guard to idle by the time this runs.
+        // External loading (remote/backgrounding) is reset separately by those hooks.
+        setIsExternalLoading(false);
+        setUserInputOnProcessing(undefined);
+        responseLengthRef.current = 0;
+        apiMetricsRef.current = [];
+        setStreamingText(null);
+        setStreamingToolUses([]);
+        setSpinnerMessage(null);
+        setSpinnerColor(null);
+        setSpinnerShimmerColor(null);
+        pickNewSpinnerTip();
+        endInteractionSpan();
+        // Speculative bash classifier checks are only valid for the current
+        // turn's commands — clear after each turn to avoid accumulating
+        // Promise chains for unconsumed checks (denied/aborted paths).
+        clearSpeculativeChecks();
+    }, [pickNewSpinnerTip]);
+    // Session backgrounding — hook is below, after getToolUseContext
+    const hasRunningTeammates = useMemo(() => getAllInProcessTeammateTasks(tasks).some(t => t.status === 'running'), [tasks]);
+    // Show deferred turn duration message once all swarm teammates finish
+    useEffect(() => {
+        if (!hasRunningTeammates && swarmStartTimeRef.current !== null) {
+            const totalMs = Date.now() - swarmStartTimeRef.current;
+            const deferredBudget = swarmBudgetInfoRef.current;
+            swarmStartTimeRef.current = null;
+            swarmBudgetInfoRef.current = undefined;
+            setMessages(prev => [...prev, createTurnDurationMessage(totalMs, deferredBudget, 
+                // Count only what recordTranscript will persist — ephemeral
+                // progress ticks and non-ant attachments are filtered by
+                // isLoggableMessage and never reach disk. Using raw prev.length
+                // would make checkResumeConsistency report false delta<0 for
+                // every turn that ran a progress-emitting tool.
+                count(prev, isLoggableMessage))]);
+        }
+    }, [hasRunningTeammates, setMessages]);
+    // Show auto permissions warning when entering auto mode
+    // (either via Shift+Tab toggle or on startup). Debounced to avoid
+    // flashing when the user is cycling through modes quickly.
+    // Only shown 3 times total across sessions.
+    const safeYoloMessageShownRef = useRef(false);
+    useEffect(() => {
+        if (feature('TRANSCRIPT_CLASSIFIER')) {
+            if (toolPermissionContext.mode !== 'auto') {
+                safeYoloMessageShownRef.current = false;
+                return;
+            }
+            if (safeYoloMessageShownRef.current)
+                return;
+            const config = getGlobalConfig();
+            const count = config.autoPermissionsNotificationCount ?? 0;
+            if (count >= 3)
+                return;
+            const timer = setTimeout((ref, setMessages) => {
+                ref.current = true;
+                saveGlobalConfig(prev => {
+                    const prevCount = prev.autoPermissionsNotificationCount ?? 0;
+                    if (prevCount >= 3)
+                        return prev;
+                    return {
+                        ...prev,
+                        autoPermissionsNotificationCount: prevCount + 1
+                    };
+                });
+                setMessages(prev => [...prev, createSystemMessage(AUTO_MODE_DESCRIPTION, 'warning')]);
+            }, 800, safeYoloMessageShownRef, setMessages);
+            return () => clearTimeout(timer);
+        }
+    }, [toolPermissionContext.mode, setMessages]);
+    // If worktree creation was slow and sparse-checkout isn't configured,
+    // nudge the user toward settings.worktree.sparsePaths.
+    const worktreeTipShownRef = useRef(false);
+    useEffect(() => {
+        if (worktreeTipShownRef.current)
+            return;
+        const wt = getCurrentWorktreeSession();
+        if (!wt?.creationDurationMs || wt.usedSparsePaths)
+            return;
+        if (wt.creationDurationMs < 15_000)
+            return;
+        worktreeTipShownRef.current = true;
+        const secs = Math.round(wt.creationDurationMs / 1000);
+        setMessages(prev => [...prev, createSystemMessage(`Worktree creation took ${secs}s. For large repos, set \`worktree.sparsePaths\` in .claude/settings.json to check out only the directories you need — e.g. \`{"worktree": {"sparsePaths": ["src", "packages/foo"]}}\`.`, 'info')]);
+    }, [setMessages]);
+    // Hide spinner when the only in-progress tool is Sleep
+    const onlySleepToolActive = useMemo(() => {
+        const lastAssistant = messages.findLast(m => m.type === 'assistant');
+        if (lastAssistant?.type !== 'assistant')
+            return false;
+        const inProgressToolUses = lastAssistant.message.content.filter(b => b.type === 'tool_use' && inProgressToolUseIDs.has(b.id));
+        return inProgressToolUses.length > 0 && inProgressToolUses.every(b => b.type === 'tool_use' && b.name === SLEEP_TOOL_NAME);
+    }, [messages, inProgressToolUseIDs]);
+    const { onBeforeQuery: mrOnBeforeQuery, onTurnComplete: mrOnTurnComplete, render: mrRender } = useMoreRight({
+        enabled: moreRightEnabled,
+        setMessages,
+        inputValue,
+        setInputValue,
+        setToolJSX
+    });
+    const showSpinner = (!toolJSX || toolJSX.showSpinner === true) && toolUseConfirmQueue.length === 0 && promptQueue.length === 0 && (
+    // Show spinner during input processing, API call, while teammates are running,
+    // or while pending task notifications are queued (prevents spinner bounce between consecutive notifications)
+    isLoading || userInputOnProcessing || hasRunningTeammates ||
+        // Keep spinner visible while task notifications are queued for processing.
+        // Without this, the spinner briefly disappears between consecutive notifications
+        // (e.g., multiple background agents completing in rapid succession) because
+        // isLoading goes false momentarily between processing each one.
+        getCommandQueueLength() > 0) &&
+        // Hide spinner when waiting for leader to approve permission request
+        !pendingWorkerRequest && !onlySleepToolActive && (
+    // Hide spinner when streaming text is visible (the text IS the feedback),
+    // but keep it when isBriefOnly suppresses the streaming text display
+    !visibleStreamingText || isBriefOnly);
+    // Check if any permission or ask question prompt is currently visible
+    // This is used to prevent the survey from opening while prompts are active
+    const hasActivePrompt = toolUseConfirmQueue.length > 0 || promptQueue.length > 0 || sandboxPermissionRequestQueue.length > 0 || elicitation.queue.length > 0 || workerSandboxPermissions.queue.length > 0;
+    const feedbackSurveyOriginal = useFeedbackSurvey(messages, isLoading, submitCount, 'session', hasActivePrompt);
+    const skillImprovementSurvey = useSkillImprovementSurvey(setMessages);
+    const showIssueFlagBanner = useIssueFlagBanner(messages, submitCount);
+    // Wrap feedback survey handler to trigger auto-run /issue
+    const feedbackSurvey = useMemo(() => ({
+        ...feedbackSurveyOriginal,
+        handleSelect: (selected) => {
+            // Reset the ref when a new survey response comes in
+            didAutoRunIssueRef.current = false;
+            const showedTranscriptPrompt = feedbackSurveyOriginal.handleSelect(selected);
+            // Auto-run /issue for "bad" if transcript prompt wasn't shown
+            if (selected === 'bad' && !showedTranscriptPrompt && shouldAutoRunIssue('feedback_survey_bad')) {
+                setAutoRunIssueReason('feedback_survey_bad');
+                didAutoRunIssueRef.current = true;
+            }
+        }
+    }), [feedbackSurveyOriginal]);
+    // Post-compact survey: shown after compaction if feature gate is enabled
+    const postCompactSurvey = usePostCompactSurvey(messages, isLoading, hasActivePrompt, {
+        enabled: !isRemoteSession
+    });
+    // Memory survey: shown when the assistant mentions memory and a memory file
+    // was read this conversation
+    const memorySurvey = useMemorySurvey(messages, isLoading, hasActivePrompt, {
+        enabled: !isRemoteSession
+    });
+    // Frustration detection: show transcript sharing prompt after detecting frustrated messages
+    const frustrationDetection = useFrustrationDetection(messages, isLoading, hasActivePrompt, feedbackSurvey.state !== 'closed' || postCompactSurvey.state !== 'closed' || memorySurvey.state !== 'closed');
+    // Initialize IDE integration
+    useIDEIntegration({
+        autoConnectIdeFlag,
+        ideToInstallExtension,
+        setDynamicMcpConfig,
+        setShowIdeOnboarding,
+        setIDEInstallationState: setIDEInstallationStatus
+    });
+    useFileHistorySnapshotInit(initialFileHistorySnapshots, fileHistory, fileHistoryState => setAppState(prev => ({
+        ...prev,
+        fileHistory: fileHistoryState
+    })));
+    const resume = useCallback(async (sessionId, log, entrypoint) => {
+        const resumeStart = performance.now();
+        try {
+            // Deserialize messages to properly clean up the conversation
+            // This filters unresolved tool uses and adds a synthetic assistant message if needed
+            const messages = deserializeMessages(log.messages);
+            // Match coordinator/normal mode to the resumed session
+            if (feature('COORDINATOR_MODE')) {
+                /* eslint-disable @typescript-eslint/no-require-imports */
+                const coordinatorModule = require('../coordinator/coordinatorMode.js');
+                /* eslint-enable @typescript-eslint/no-require-imports */
+                const warning = coordinatorModule.matchSessionMode(log.mode);
+                if (warning) {
+                    // Re-derive agent definitions after mode switch so built-in agents
+                    // reflect the new coordinator/normal mode
+                    /* eslint-disable @typescript-eslint/no-require-imports */
+                    const { getAgentDefinitionsWithOverrides, getActiveAgentsFromList } = require('../tools/AgentTool/loadAgentsDir.js');
+                    /* eslint-enable @typescript-eslint/no-require-imports */
+                    getAgentDefinitionsWithOverrides.cache.clear?.();
+                    const freshAgentDefs = await getAgentDefinitionsWithOverrides(getOriginalCwd());
+                    setAppState(prev => ({
+                        ...prev,
+                        agentDefinitions: {
+                            ...freshAgentDefs,
+                            allAgents: freshAgentDefs.allAgents,
+                            activeAgents: getActiveAgentsFromList(freshAgentDefs.allAgents)
+                        }
+                    }));
+                    messages.push(createSystemMessage(warning, 'warning'));
+                }
+            }
+            // Fire SessionEnd hooks for the current session before starting the
+            // resumed one, mirroring the /clear flow in conversation.ts.
+            const sessionEndTimeoutMs = getSessionEndHookTimeoutMs();
+            await executeSessionEndHooks('resume', {
+                getAppState: () => store.getState(),
+                setAppState,
+                signal: AbortSignal.timeout(sessionEndTimeoutMs),
+                timeoutMs: sessionEndTimeoutMs
+            });
+            // Process session start hooks for resume
+            const hookMessages = await processSessionStartHooks('resume', {
+                sessionId,
+                agentType: mainThreadAgentDefinition?.agentType,
+                model: mainLoopModel
+            });
+            // Append hook messages to the conversation
+            messages.push(...hookMessages);
+            // For forks, generate a new plan slug and copy the plan content so the
+            // original and forked sessions don't clobber each other's plan files.
+            // For regular resumes, reuse the original session's plan slug.
+            if (entrypoint === 'fork') {
+                void copyPlanForFork(log, asSessionId(sessionId));
+            }
+            else {
+                void copyPlanForResume(log, asSessionId(sessionId));
+            }
+            // Restore file history and attribution state from the resumed conversation
+            restoreSessionStateFromLog(log, setAppState);
+            if (log.fileHistorySnapshots) {
+                void copyFileHistoryForResume(log);
+            }
+            // Restore agent setting from the resumed conversation
+            // Always reset to the new session's values (or clear if none),
+            // matching the standaloneAgentContext pattern below
+            const { agentDefinition: restoredAgent } = restoreAgentFromSession(log.agentSetting, initialMainThreadAgentDefinition, agentDefinitions);
+            setMainThreadAgentDefinition(restoredAgent);
+            setAppState(prev => ({
+                ...prev,
+                agent: restoredAgent?.agentType
+            }));
+            // Restore standalone agent context from the resumed conversation
+            // Always reset to the new session's values (or clear if none)
+            setAppState(prev => ({
+                ...prev,
+                standaloneAgentContext: computeStandaloneAgentContext(log.agentName, log.agentColor)
+            }));
+            void updateSessionName(log.agentName);
+            // Restore read file state from the message history
+            restoreReadFileState(messages, log.projectPath ?? getOriginalCwd());
+            // Clear any active loading state (no queryId since we're not in a query)
+            resetLoadingState();
+            setAbortController(null);
+            setConversationId(sessionId);
+            // Get target session's costs BEFORE saving current session
+            // (saveCurrentSessionCosts overwrites the config, so we need to read first)
+            const targetSessionCosts = getStoredSessionCosts(sessionId);
+            // Save current session's costs before switching to avoid losing accumulated costs
+            saveCurrentSessionCosts();
+            // Reset cost state for clean slate before restoring target session
+            resetCostState();
+            // Switch session (id + project dir atomically). fullPath may point to
+            // a different project (cross-worktree, /branch); null derives from
+            // current originalCwd.
+            switchSession(asSessionId(sessionId), log.fullPath ? dirname(log.fullPath) : null);
+            // Rename asciicast recording to match the resumed session ID
+            const { renameRecordingForSession } = await import('../utils/asciicast.js');
+            await renameRecordingForSession();
+            await resetSessionFilePointer();
+            // Clear then restore session metadata so it's re-appended on exit via
+            // reAppendSessionMetadata. clearSessionMetadata must be called first:
+            // restoreSessionMetadata only sets-if-truthy, so without the clear,
+            // a session without an agent name would inherit the previous session's
+            // cached name and write it to the wrong transcript on first message.
+            clearSessionMetadata();
+            restoreSessionMetadata(log);
+            // Resumed sessions shouldn't re-title from mid-conversation context
+            // (same reasoning as the useRef seed), and the previous session's
+            // Haiku title shouldn't carry over.
+            haikuTitleAttemptedRef.current = true;
+            setHaikuTitle(undefined);
+            // Exit any worktree a prior /resume entered, then cd into the one
+            // this session was in. Without the exit, resuming from worktree B
+            // to non-worktree C leaves cwd/currentWorktreeSession stale;
+            // resuming B→C where C is also a worktree fails entirely
+            // (getCurrentWorktreeSession guard blocks the switch).
+            //
+            // Skipped for /branch: forkLog doesn't carry worktreeSession, so
+            // this would kick the user out of a worktree they're still working
+            // in. Same fork skip as processResumedConversation for the adopt —
+            // fork materializes its own file via recordTranscript on REPL mount.
+            if (entrypoint !== 'fork') {
+                exitRestoredWorktree();
+                restoreWorktreeForResume(log.worktreeSession);
+                adoptResumedSessionFile();
+                void restoreRemoteAgentTasks({
+                    abortController: new AbortController(),
+                    getAppState: () => store.getState(),
+                    setAppState
+                });
+            }
+            else {
+                // Fork: same re-persist as /clear (conversation.ts). The clear
+                // above wiped currentSessionWorktree, forkLog doesn't carry it,
+                // and the process is still in the same worktree.
+                const ws = getCurrentWorktreeSession();
+                if (ws)
+                    saveWorktreeState(ws);
+            }
+            // Persist the current mode so future resumes know what mode this session was in
+            if (feature('COORDINATOR_MODE')) {
+                /* eslint-disable @typescript-eslint/no-require-imports */
+                const { saveMode } = require('../utils/sessionStorage.js');
+                const { isCoordinatorMode } = require('../coordinator/coordinatorMode.js');
+                /* eslint-enable @typescript-eslint/no-require-imports */
+                saveMode(isCoordinatorMode() ? 'coordinator' : 'normal');
+            }
+            // Restore target session's costs from the data we read earlier
+            if (targetSessionCosts) {
+                setCostStateForRestore(targetSessionCosts);
+            }
+            // Reconstruct replacement state for the resumed session. Runs after
+            // setSessionId so any NEW replacements post-resume write to the
+            // resumed session's tool-results dir. Gated on ref.current: the
+            // initial mount already read the feature flag, so we don't re-read
+            // it here (mid-session flag flips stay unobservable in both
+            // directions).
+            //
+            // Skipped for in-session /branch: the existing ref is already correct
+            // (branch preserves tool_use_ids), so there's no need to reconstruct.
+            // createFork() does write content-replacement entries to the forked
+            // JSONL with the fork's sessionId, so `claude -r {forkId}` also works.
+            if (contentReplacementStateRef.current && entrypoint !== 'fork') {
+                contentReplacementStateRef.current = reconstructContentReplacementState(messages, log.contentReplacements ?? []);
+            }
+            // Reset messages to the provided initial messages
+            // Use a callback to ensure we're not dependent on stale state
+            setMessages(() => messages);
+            // Clear any active tool JSX
+            setToolJSX(null);
+            // Clear input to ensure no residual state
+            setInputValue('');
+            logEvent('tengu_session_resumed', {
+                entrypoint: entrypoint,
+                success: true,
+                resume_duration_ms: Math.round(performance.now() - resumeStart)
+            });
+        }
+        catch (error) {
+            logEvent('tengu_session_resumed', {
+                entrypoint: entrypoint,
+                success: false
+            });
+            throw error;
+        }
+    }, [resetLoadingState, setAppState]);
+    // Lazy init: useRef(createX()) would call createX on every render and
+    // discard the result. LRUCache construction inside FileStateCache is
+    // expensive (~170ms), so we use useState's lazy initializer to create
+    // it exactly once, then feed that stable reference into useRef.
+    const [initialReadFileState] = useState(() => createFileStateCacheWithSizeLimit(READ_FILE_STATE_CACHE_SIZE));
+    const readFileState = useRef(initialReadFileState);
+    const bashTools = useRef(new Set());
+    const bashToolsProcessedIdx = useRef(0);
+    // Session-scoped skill discovery tracking (feeds was_discovered on
+    // tengu_skill_tool_invocation). Must persist across getToolUseContext
+    // rebuilds within a session: turn-0 discovery writes via processUserInput
+    // before onQuery builds its own context, and discovery on turn N must
+    // still attribute a SkillTool call on turn N+k. Cleared in clearConversation.
+    const discoveredSkillNamesRef = useRef(new Set());
+    // Session-level dedup for nested_memory CLAUDE.md attachments.
+    // readFileState is a 100-entry LRU; once it evicts a CLAUDE.md path,
+    // the next discovery cycle re-injects it. Cleared in clearConversation.
+    const loadedNestedMemoryPathsRef = useRef(new Set());
+    // Helper to restore read file state from messages (used for resume flows)
+    // This allows Claude to edit files that were read in previous sessions
+    const restoreReadFileState = useCallback((messages, cwd) => {
+        const extracted = extractReadFilesFromMessages(messages, cwd, READ_FILE_STATE_CACHE_SIZE);
+        readFileState.current = mergeFileStateCaches(readFileState.current, extracted);
+        for (const tool of extractBashToolsFromMessages(messages)) {
+            bashTools.current.add(tool);
+        }
+    }, []);
+    // Extract read file state from initialMessages on mount
+    // This handles CLI flag resume (--resume-session) and ResumeConversation screen
+    // where messages are passed as props rather than through the resume callback
+    useEffect(() => {
+        if (initialMessages && initialMessages.length > 0) {
+            restoreReadFileState(initialMessages, getOriginalCwd());
+            void restoreRemoteAgentTasks({
+                abortController: new AbortController(),
+                getAppState: () => store.getState(),
+                setAppState
+            });
+        }
+        // Only run on mount - initialMessages shouldn't change during component lifetime
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const { status: apiKeyStatus, reverify } = useApiKeyVerification();
+    // Auto-run /issue state
+    const [autoRunIssueReason, setAutoRunIssueReason] = useState(null);
+    // Ref to track if autoRunIssue was triggered this survey cycle,
+    // so we can suppress the [1] follow-up prompt even after
+    // autoRunIssueReason is cleared.
+    const didAutoRunIssueRef = useRef(false);
+    // State for exit feedback flow
+    const [exitFlow, setExitFlow] = useState(null);
+    const [isExiting, setIsExiting] = useState(false);
+    // Calculate if cost dialog should be shown
+    const showingCostDialog = !isLoading && showCostDialog;
+    // Determine which dialog should have focus (if any)
+    // Permission and interactive dialogs can show even when toolJSX is set,
+    // as long as shouldContinueAnimation is true. This prevents deadlocks when
+    // agents set background hints while waiting for user interaction.
+    function getFocusedInputDialog() {
+        // Exit states always take precedence
+        if (isExiting || exitFlow)
+            return undefined;
+        // High priority dialogs (always show regardless of typing)
+        if (isMessageSelectorVisible)
+            return 'message-selector';
+        // Suppress interrupt dialogs while user is actively typing
+        if (isPromptInputActive)
+            return undefined;
+        if (sandboxPermissionRequestQueue[0])
+            return 'sandbox-permission';
+        // Permission/interactive dialogs (show unless blocked by toolJSX)
+        const allowDialogsWithAnimation = !toolJSX || toolJSX.shouldContinueAnimation;
+        if (allowDialogsWithAnimation && toolUseConfirmQueue[0])
+            return 'tool-permission';
+        if (allowDialogsWithAnimation && promptQueue[0])
+            return 'prompt';
+        // Worker sandbox permission prompts (network access) from swarm workers
+        if (allowDialogsWithAnimation && workerSandboxPermissions.queue[0])
+            return 'worker-sandbox-permission';
+        if (allowDialogsWithAnimation && elicitation.queue[0])
+            return 'elicitation';
+        if (allowDialogsWithAnimation && showingCostDialog)
+            return 'cost';
+        if (allowDialogsWithAnimation && idleReturnPending)
+            return 'idle-return';
+        if (feature('ULTRAPLAN') && allowDialogsWithAnimation && !isLoading && ultraplanPendingChoice)
+            return 'ultraplan-choice';
+        if (feature('ULTRAPLAN') && allowDialogsWithAnimation && !isLoading && ultraplanLaunchPending)
+            return 'ultraplan-launch';
+        // Onboarding dialogs (special conditions)
+        if (allowDialogsWithAnimation && showIdeOnboarding)
+            return 'ide-onboarding';
+        // Model switch callout (ant-only, eliminated from external builds)
+        if ("external" === 'ant' && allowDialogsWithAnimation && showModelSwitchCallout)
+            return 'model-switch';
+        // Undercover auto-enable explainer (ant-only, eliminated from external builds)
+        if ("external" === 'ant' && allowDialogsWithAnimation && showUndercoverCallout)
+            return 'undercover-callout';
+        // Effort callout (shown once for Opus 4.6 users when effort is enabled)
+        if (allowDialogsWithAnimation && showEffortCallout)
+            return 'effort-callout';
+        // Remote callout (shown once before first bridge enable)
+        if (allowDialogsWithAnimation && showRemoteCallout)
+            return 'remote-callout';
+        // LSP plugin recommendation (lowest priority - non-blocking suggestion)
+        if (allowDialogsWithAnimation && lspRecommendation)
+            return 'lsp-recommendation';
+        // Plugin hint from CLI/SDK stderr (same priority band as LSP rec)
+        if (allowDialogsWithAnimation && hintRecommendation)
+            return 'plugin-hint';
+        // Desktop app upsell (max 3 launches, lowest priority)
+        if (allowDialogsWithAnimation && showDesktopUpsellStartup)
+            return 'desktop-upsell';
+        return undefined;
+    }
+    const focusedInputDialog = getFocusedInputDialog();
+    // True when permission prompts exist but are hidden because the user is typing
+    const hasSuppressedDialogs = isPromptInputActive && (sandboxPermissionRequestQueue[0] || toolUseConfirmQueue[0] || promptQueue[0] || workerSandboxPermissions.queue[0] || elicitation.queue[0] || showingCostDialog);
+    // Keep ref in sync so timer callbacks can read the current value
+    focusedInputDialogRef.current = focusedInputDialog;
+    // Immediately capture pause/resume when focusedInputDialog changes
+    // This ensures accurate timing even under high system load, rather than
+    // relying on the 100ms polling interval to detect state changes
+    useEffect(() => {
+        if (!isLoading)
+            return;
+        const isPaused = focusedInputDialog === 'tool-permission';
+        const now = Date.now();
+        if (isPaused && pauseStartTimeRef.current === null) {
+            // Just entered pause state - record the exact moment
+            pauseStartTimeRef.current = now;
+        }
+        else if (!isPaused && pauseStartTimeRef.current !== null) {
+            // Just exited pause state - accumulate paused time immediately
+            totalPausedMsRef.current += now - pauseStartTimeRef.current;
+            pauseStartTimeRef.current = null;
+        }
+    }, [focusedInputDialog, isLoading]);
+    // Re-pin scroll to bottom whenever the permission overlay appears or
+    // dismisses. Overlay now renders below messages inside the same
+    // ScrollBox (no remount), so we need an explicit scrollToBottom for:
+    //  - appear: user may have been scrolled up (sticky broken) — the
+    //    dialog is blocking and must be visible
+    //  - dismiss: user may have scrolled up to read context during the
+    //    overlay, and onScroll was suppressed so the pill state is stale
+    // useLayoutEffect so the re-pin commits before the Ink frame renders —
+    // no 1-frame flash of the wrong scroll position.
+    const prevDialogRef = useRef(focusedInputDialog);
+    useLayoutEffect(() => {
+        const was = prevDialogRef.current === 'tool-permission';
+        const now = focusedInputDialog === 'tool-permission';
+        if (was !== now)
+            repinScroll();
+        prevDialogRef.current = focusedInputDialog;
+    }, [focusedInputDialog, repinScroll]);
+    function onCancel() {
+        if (focusedInputDialog === 'elicitation') {
+            // Elicitation dialog handles its own Escape, and closing it shouldn't affect any loading state.
+            return;
+        }
+        logForDebugging(`[onCancel] focusedInputDialog=${focusedInputDialog} streamMode=${streamMode}`);
+        // Pause proactive mode so the user gets control back.
+        // It will resume when they submit their next input (see onSubmit).
+        if (feature('PROACTIVE') || feature('KAIROS')) {
+            proactiveModule?.pauseProactive();
+        }
+        queryGuard.forceEnd();
+        skipIdleCheckRef.current = false;
+        // Preserve partially-streamed text so the user can read what was
+        // generated before pressing Esc. Pushed before resetLoadingState clears
+        // streamingText, and before query.ts yields the async interrupt marker,
+        // giving final order [user, partial-assistant, [Request interrupted by user]].
+        if (streamingText?.trim()) {
+            setMessages(prev => [...prev, createAssistantMessage({
+                    content: streamingText
+                })]);
+        }
+        resetLoadingState();
+        // Clear any active token budget so the backstop doesn't fire on
+        // a stale budget if the query generator hasn't exited yet.
+        if (feature('TOKEN_BUDGET')) {
+            snapshotOutputTokensForTurn(null);
+        }
+        if (focusedInputDialog === 'tool-permission') {
+            // Tool use confirm handles the abort signal itself
+            toolUseConfirmQueue[0]?.onAbort();
+            setToolUseConfirmQueue([]);
+        }
+        else if (focusedInputDialog === 'prompt') {
+            // Reject all pending prompts and clear the queue
+            for (const item of promptQueue) {
+                item.reject(new Error('Prompt cancelled by user'));
+            }
+            setPromptQueue([]);
+            abortController?.abort('user-cancel');
+        }
+        else if (activeRemote.isRemoteMode) {
+            // Remote mode: send interrupt signal to CCR
+            activeRemote.cancelRequest();
+        }
+        else {
+            abortController?.abort('user-cancel');
+        }
+        // Clear the controller so subsequent Escape presses don't see a stale
+        // aborted signal. Without this, canCancelRunningTask is false (signal
+        // defined but .aborted === true), so isActive becomes false if no other
+        // activating conditions hold — leaving the Escape keybinding inactive.
+        setAbortController(null);
+        // forceEnd() skips the finally path — fire directly (aborted=true).
+        void mrOnTurnComplete(messagesRef.current, true);
+    }
+    // Function to handle queued command when canceling a permission request
+    const handleQueuedCommandOnCancel = useCallback(() => {
+        const result = popAllEditable(inputValue, 0);
+        if (!result)
+            return;
+        setInputValue(result.text);
+        setInputMode('prompt');
+        // Restore images from queued commands to pastedContents
+        if (result.images.length > 0) {
+            setPastedContents(prev => {
+                const newContents = {
+                    ...prev
+                };
+                for (const image of result.images) {
+                    newContents[image.id] = image;
+                }
+                return newContents;
+            });
+        }
+    }, [setInputValue, setInputMode, inputValue, setPastedContents]);
+    // CancelRequestHandler props - rendered inside KeybindingSetup
+    const cancelRequestProps = {
+        setToolUseConfirmQueue,
+        onCancel,
+        onAgentsKilled: () => setMessages(prev => [...prev, createAgentsKilledMessage()]),
+        isMessageSelectorVisible: isMessageSelectorVisible || !!showBashesDialog,
+        screen,
+        abortSignal: abortController?.signal,
+        popCommandFromQueue: handleQueuedCommandOnCancel,
+        vimMode,
+        isLocalJSXCommand: toolJSX?.isLocalJSXCommand,
+        isSearchingHistory,
+        isHelpOpen,
+        inputMode,
+        inputValue,
+        streamMode
+    };
+    useEffect(() => {
+        const totalCost = getTotalCost();
+        if (totalCost >= 5 /* $5 */ && !showCostDialog && !haveShownCostDialog) {
+            logEvent('tengu_cost_threshold_reached', {});
+            // Mark as shown even if the dialog won't render (no console billing
+            // access). Otherwise this effect re-fires on every message change for
+            // the rest of the session — 200k+ spurious events observed.
+            setHaveShownCostDialog(true);
+            if (hasConsoleBillingAccess()) {
+                setShowCostDialog(true);
+            }
+        }
+    }, [messages, showCostDialog, haveShownCostDialog]);
+    const sandboxAskCallback = useCallback(async (hostPattern) => {
+        // If running as a swarm worker, forward the request to the leader via mailbox
+        if (isAgentSwarmsEnabled() && isSwarmWorker()) {
+            const requestId = generateSandboxRequestId();
+            // Send the request to the leader via mailbox
+            const sent = await sendSandboxPermissionRequestViaMailbox(hostPattern.host, requestId);
+            return new Promise(resolveShouldAllowHost => {
+                if (!sent) {
+                    // If we couldn't send via mailbox, fall back to local handling
+                    setSandboxPermissionRequestQueue(prev => [...prev, {
+                            hostPattern,
+                            resolvePromise: resolveShouldAllowHost
+                        }]);
+                    return;
+                }
+                // Register the callback for when the leader responds
+                registerSandboxPermissionCallback({
+                    requestId,
+                    host: hostPattern.host,
+                    resolve: resolveShouldAllowHost
+                });
+                // Update AppState to show pending indicator
+                setAppState(prev => ({
+                    ...prev,
+                    pendingSandboxRequest: {
+                        requestId,
+                        host: hostPattern.host
+                    }
+                }));
+            });
+        }
+        // Normal flow for non-workers: show local UI and optionally race
+        // against the REPL bridge (Remote Control) if connected.
+        return new Promise(resolveShouldAllowHost => {
+            let resolved = false;
+            function resolveOnce(allow) {
+                if (resolved)
+                    return;
+                resolved = true;
+                resolveShouldAllowHost(allow);
+            }
+            // Queue the local sandbox permission dialog
+            setSandboxPermissionRequestQueue(prev => [...prev, {
+                    hostPattern,
+                    resolvePromise: resolveOnce
+                }]);
+            // When the REPL bridge is connected, also forward the sandbox
+            // permission request as a can_use_tool control_request so the
+            // remote user (e.g. on claude.ai) can approve it too.
+            if (feature('BRIDGE_MODE')) {
+                const bridgeCallbacks = store.getState().replBridgePermissionCallbacks;
+                if (bridgeCallbacks) {
+                    const bridgeRequestId = randomUUID();
+                    bridgeCallbacks.sendRequest(bridgeRequestId, SANDBOX_NETWORK_ACCESS_TOOL_NAME, {
+                        host: hostPattern.host
+                    }, randomUUID(), `Allow network connection to ${hostPattern.host}?`);
+                    const unsubscribe = bridgeCallbacks.onResponse(bridgeRequestId, response => {
+                        unsubscribe();
+                        const allow = response.behavior === 'allow';
+                        // Resolve ALL pending requests for the same host, not just
+                        // this one — mirrors the local dialog handler pattern.
+                        setSandboxPermissionRequestQueue(queue => {
+                            queue.filter(item => item.hostPattern.host === hostPattern.host).forEach(item => item.resolvePromise(allow));
+                            return queue.filter(item => item.hostPattern.host !== hostPattern.host);
+                        });
+                        // Clean up all sibling bridge subscriptions for this host
+                        // (other concurrent same-host requests) before deleting.
+                        const siblingCleanups = sandboxBridgeCleanupRef.current.get(hostPattern.host);
+                        if (siblingCleanups) {
+                            for (const fn of siblingCleanups) {
+                                fn();
+                            }
+                            sandboxBridgeCleanupRef.current.delete(hostPattern.host);
+                        }
+                    });
+                    // Register cleanup so the local dialog handler can cancel
+                    // the remote prompt and unsubscribe when the local user
+                    // responds first.
+                    const cleanup = () => {
+                        unsubscribe();
+                        bridgeCallbacks.cancelRequest(bridgeRequestId);
+                    };
+                    const existing = sandboxBridgeCleanupRef.current.get(hostPattern.host) ?? [];
+                    existing.push(cleanup);
+                    sandboxBridgeCleanupRef.current.set(hostPattern.host, existing);
+                }
+            }
+        });
+    }, [setAppState, store]);
+    // #34044: if user explicitly set sandbox.enabled=true but deps are missing,
+    // isSandboxingEnabled() returns false silently. Surface the reason once at
+    // mount so users know their security config isn't being enforced. Full
+    // reason goes to debug log; notification points to /sandbox for details.
+    // addNotification is stable (useCallback) so the effect fires once.
+    useEffect(() => {
+        const reason = SandboxManager.getSandboxUnavailableReason();
+        if (!reason)
+            return;
+        if (SandboxManager.isSandboxRequired()) {
+            process.stderr.write(`\nError: sandbox required but unavailable: ${reason}\n` + `  sandbox.failIfUnavailable is set — refusing to start without a working sandbox.\n\n`);
+            gracefulShutdownSync(1, 'other');
+            return;
+        }
+        logForDebugging(`sandbox disabled: ${reason}`, {
+            level: 'warn'
+        });
+        addNotification({
+            key: 'sandbox-unavailable',
+            jsx: _jsxs(_Fragment, { children: [_jsx(Text, { color: "warning", children: "sandbox disabled" }), _jsx(Text, { dimColor: true, children: " \u00B7 /sandbox" })] }),
+            priority: 'medium'
+        });
+    }, [addNotification]);
+    if (SandboxManager.isSandboxingEnabled()) {
+        // If sandboxing is enabled (setting.sandbox is defined, initialise the manager)
+        SandboxManager.initialize(sandboxAskCallback).catch(err => {
+            // Initialization/validation failed - display error and exit
+            process.stderr.write(`\n❌ Sandbox Error: ${errorMessage(err)}\n`);
+            gracefulShutdownSync(1, 'other');
+        });
+    }
+    const setToolPermissionContext = useCallback((context, options) => {
+        setAppState(prev => ({
+            ...prev,
+            toolPermissionContext: {
+                ...context,
+                // Preserve the coordinator's mode only when explicitly requested.
+                // Workers' getAppState() returns a transformed context with mode
+                // 'acceptEdits' that must not leak into the coordinator's actual
+                // state via permission-rule updates — those call sites pass
+                // { preserveMode: true }. User-initiated mode changes (e.g.,
+                // selecting "allow all edits") must NOT be overridden.
+                mode: options?.preserveMode ? prev.toolPermissionContext.mode : context.mode
+            }
+        }));
+        // When permission context changes, recheck all queued items
+        // This handles the case where approving item1 with "don't ask again"
+        // should auto-approve other queued items that now match the updated rules
+        setImmediate(setToolUseConfirmQueue => {
+            // Use setToolUseConfirmQueue callback to get current queue state
+            // instead of capturing it in the closure, to avoid stale closure issues
+            setToolUseConfirmQueue(currentQueue => {
+                currentQueue.forEach(item => {
+                    void item.recheckPermission();
+                });
+                return currentQueue;
+            });
+        }, setToolUseConfirmQueue);
+    }, [setAppState, setToolUseConfirmQueue]);
+    // Register the leader's setToolPermissionContext for in-process teammates
+    useEffect(() => {
+        registerLeaderSetToolPermissionContext(setToolPermissionContext);
+        return () => unregisterLeaderSetToolPermissionContext();
+    }, [setToolPermissionContext]);
+    const canUseTool = useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext);
+    const requestPrompt = useCallback((title, toolInputSummary) => (request) => new Promise((resolve, reject) => {
+        setPromptQueue(prev => [...prev, {
+                request,
+                title,
+                toolInputSummary,
+                resolve,
+                reject
+            }]);
+    }), []);
+    const getToolUseContext = useCallback((messages, newMessages, abortController, mainLoopModel) => {
+        // Read mutable values fresh from the store rather than closure-capturing
+        // useAppState() snapshots. Same values today (closure is refreshed by the
+        // render between turns); decouples freshness from React's render cycle for
+        // a future headless conversation loop. Same pattern refreshTools() uses.
+        const s = store.getState();
+        // Compute tools fresh from store.getState() rather than the closure-
+        // captured `tools`. useManageMCPConnections populates appState.mcp
+        // async as servers connect — the store may have newer MCP state than
+        // the closure captured at render time. Also doubles as refreshTools()
+        // for mid-query tool list updates.
+        const computeTools = () => {
+            const state = store.getState();
+            const assembled = assembleToolPool(state.toolPermissionContext, state.mcp.tools);
+            const merged = mergeAndFilterTools(combinedInitialTools, assembled, state.toolPermissionContext.mode);
+            if (!mainThreadAgentDefinition)
+                return merged;
+            return resolveAgentTools(mainThreadAgentDefinition, merged, false, true).resolvedTools;
+        };
+        return {
+            abortController,
+            options: {
+                commands,
+                tools: computeTools(),
+                debug,
+                verbose: s.verbose,
+                mainLoopModel,
+                thinkingConfig: s.thinkingEnabled !== false ? thinkingConfig : {
+                    type: 'disabled'
+                },
+                // Merge fresh from store rather than closing over useMergedClients'
+                // memoized output. initialMcpClients is a prop (session-constant).
+                mcpClients: mergeClients(initialMcpClients, s.mcp.clients),
+                mcpResources: s.mcp.resources,
+                ideInstallationStatus: ideInstallationStatus,
+                isNonInteractiveSession: false,
+                dynamicMcpConfig,
+                theme,
+                agentDefinitions: allowedAgentTypes ? {
+                    ...s.agentDefinitions,
+                    allowedAgentTypes
+                } : s.agentDefinitions,
+                customSystemPrompt,
+                appendSystemPrompt,
+                refreshTools: computeTools
+            },
+            getAppState: () => store.getState(),
+            setAppState,
+            messages,
+            setMessages,
+            updateFileHistoryState(updater) {
+                // Perf: skip the setState when the updater returns the same reference
+                // (e.g. fileHistoryTrackEdit returns `state` when the file is already
+                // tracked). Otherwise every no-op call would notify all store listeners.
+                setAppState(prev => {
+                    const updated = updater(prev.fileHistory);
+                    if (updated === prev.fileHistory)
+                        return prev;
+                    return {
+                        ...prev,
+                        fileHistory: updated
+                    };
+                });
+            },
+            updateAttributionState(updater) {
+                setAppState(prev => {
+                    const updated = updater(prev.attribution);
+                    if (updated === prev.attribution)
+                        return prev;
+                    return {
+                        ...prev,
+                        attribution: updated
+                    };
+                });
+            },
+            openMessageSelector: () => {
+                if (!disabled) {
+                    setIsMessageSelectorVisible(true);
+                }
+            },
+            onChangeAPIKey: reverify,
+            readFileState: readFileState.current,
+            setToolJSX,
+            addNotification,
+            appendSystemMessage: msg => setMessages(prev => [...prev, msg]),
+            sendOSNotification: opts => {
+                void sendNotification(opts, terminal);
+            },
+            onChangeDynamicMcpConfig,
+            onInstallIDEExtension: setIDEToInstallExtension,
+            nestedMemoryAttachmentTriggers: new Set(),
+            loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,
+            dynamicSkillDirTriggers: new Set(),
+            discoveredSkillNames: discoveredSkillNamesRef.current,
+            setResponseLength,
+            pushApiMetricsEntry: "external" === 'ant' ? (ttftMs) => {
+                const now = Date.now();
+                const baseline = responseLengthRef.current;
+                apiMetricsRef.current.push({
+                    ttftMs,
+                    firstTokenTime: now,
+                    lastTokenTime: now,
+                    responseLengthBaseline: baseline,
+                    endResponseLength: baseline
+                });
+            } : undefined,
+            setStreamMode,
+            onCompactProgress: event => {
+                switch (event.type) {
+                    case 'hooks_start':
+                        setSpinnerColor('claudeBlue_FOR_SYSTEM_SPINNER');
+                        setSpinnerShimmerColor('claudeBlueShimmer_FOR_SYSTEM_SPINNER');
+                        setSpinnerMessage(event.hookType === 'pre_compact' ? 'Running PreCompact hooks\u2026' : event.hookType === 'post_compact' ? 'Running PostCompact hooks\u2026' : 'Running SessionStart hooks\u2026');
+                        break;
+                    case 'compact_start':
+                        setSpinnerMessage('Compacting conversation');
+                        break;
+                    case 'compact_end':
+                        setSpinnerMessage(null);
+                        setSpinnerColor(null);
+                        setSpinnerShimmerColor(null);
+                        break;
+                }
+            },
+            setInProgressToolUseIDs,
+            setHasInterruptibleToolInProgress: (v) => {
+                hasInterruptibleToolInProgressRef.current = v;
+            },
+            resume,
+            setConversationId,
+            requestPrompt: feature('HOOK_PROMPTS') ? requestPrompt : undefined,
+            contentReplacementState: contentReplacementStateRef.current
+        };
+    }, [commands, combinedInitialTools, mainThreadAgentDefinition, debug, initialMcpClients, ideInstallationStatus, dynamicMcpConfig, theme, allowedAgentTypes, store, setAppState, reverify, addNotification, setMessages, onChangeDynamicMcpConfig, resume, requestPrompt, disabled, customSystemPrompt, appendSystemPrompt, setConversationId]);
+    // Session backgrounding (Ctrl+B to background/foreground)
+    const handleBackgroundQuery = useCallback(() => {
+        // Stop the foreground query so the background one takes over
+        abortController?.abort('background');
+        // Aborting subagents may produce task-completed notifications.
+        // Clear task notifications so the queue processor doesn't immediately
+        // start a new foreground query; forward them to the background session.
+        const removedNotifications = removeByFilter(cmd => cmd.mode === 'task-notification');
+        void (async () => {
+            const toolUseContext = getToolUseContext(messagesRef.current, [], new AbortController(), mainLoopModel);
+            const [defaultSystemPrompt, userContext, systemContext] = await Promise.all([getSystemPrompt(toolUseContext.options.tools, mainLoopModel, Array.from(toolPermissionContext.additionalWorkingDirectories.keys()), toolUseContext.options.mcpClients), getUserContext(), getSystemContext()]);
+            const systemPrompt = buildEffectiveSystemPrompt({
+                mainThreadAgentDefinition,
+                toolUseContext,
+                customSystemPrompt,
+                defaultSystemPrompt,
+                appendSystemPrompt
+            });
+            toolUseContext.renderedSystemPrompt = systemPrompt;
+            const notificationAttachments = await getQueuedCommandAttachments(removedNotifications).catch(() => []);
+            const notificationMessages = notificationAttachments.map(createAttachmentMessage);
+            // Deduplicate: if the query loop already yielded a notification into
+            // messagesRef before we removed it from the queue, skip duplicates.
+            // We use prompt text for dedup because source_uuid is not set on
+            // task-notification QueuedCommands (enqueuePendingNotification callers
+            // don't pass uuid), so it would always be undefined.
+            const existingPrompts = new Set();
+            for (const m of messagesRef.current) {
+                if (m.type === 'attachment' && m.attachment.type === 'queued_command' && m.attachment.commandMode === 'task-notification' && typeof m.attachment.prompt === 'string') {
+                    existingPrompts.add(m.attachment.prompt);
+                }
+            }
+            const uniqueNotifications = notificationMessages.filter(m => m.attachment.type === 'queued_command' && (typeof m.attachment.prompt !== 'string' || !existingPrompts.has(m.attachment.prompt)));
+            startBackgroundSession({
+                messages: [...messagesRef.current, ...uniqueNotifications],
+                queryParams: {
+                    systemPrompt,
+                    userContext,
+                    systemContext,
+                    canUseTool,
+                    toolUseContext,
+                    querySource: getQuerySourceForREPL()
+                },
+                description: terminalTitle,
+                setAppState,
+                agentDefinition: mainThreadAgentDefinition
+            });
+        })();
+    }, [abortController, mainLoopModel, toolPermissionContext, mainThreadAgentDefinition, getToolUseContext, customSystemPrompt, appendSystemPrompt, canUseTool, setAppState]);
+    const { handleBackgroundSession } = useSessionBackgrounding({
+        setMessages,
+        setIsLoading: setIsExternalLoading,
+        resetLoadingState,
+        setAbortController,
+        onBackgroundQuery: handleBackgroundQuery
+    });
+    const onQueryEvent = useCallback((event) => {
+        handleMessageFromStream(event, newMessage => {
+            if (isCompactBoundaryMessage(newMessage)) {
+                // Fullscreen: keep pre-compact messages for scrollback. query.ts
+                // slices at the boundary for API calls, Messages.tsx skips the
+                // boundary filter in fullscreen, and useLogMessages treats this
+                // as an incremental append (first uuid unchanged). Cap at one
+                // compact-interval of scrollback — normalizeMessages/applyGrouping
+                // are O(n) per render, so drop everything before the previous
+                // boundary to keep n bounded across multi-day sessions.
+                if (isFullscreenEnvEnabled()) {
+                    setMessages(old => [...getMessagesAfterCompactBoundary(old, {
+                            includeSnipped: true
+                        }), newMessage]);
+                }
+                else {
+                    setMessages(() => [newMessage]);
+                }
+                // Bump conversationId so Messages.tsx row keys change and
+                // stale memoized rows remount with post-compact content.
+                setConversationId(randomUUID());
+                // Compaction succeeded — clear the context-blocked flag so ticks resume
+                if (feature('PROACTIVE') || feature('KAIROS')) {
+                    proactiveModule?.setContextBlocked(false);
+                }
+            }
+            else if (newMessage.type === 'progress' && isEphemeralToolProgress(newMessage.data.type)) {
+                // Replace the previous ephemeral progress tick for the same tool
+                // call instead of appending. Sleep/Bash emit a tick per second and
+                // only the last one is rendered; appending blows up the messages
+                // array (13k+ observed) and the transcript (120MB of sleep_progress
+                // lines). useLogMessages tracks length, so same-length replacement
+                // also skips the transcript write.
+                // agent_progress / hook_progress / skill_progress are NOT ephemeral
+                // — each carries distinct state the UI needs (e.g. subagent tool
+                // history). Replacing those leaves the AgentTool UI stuck at
+                // "Initializing…" because it renders the full progress trail.
+                setMessages(oldMessages => {
+                    const last = oldMessages.at(-1);
+                    if (last?.type === 'progress' && last.parentToolUseID === newMessage.parentToolUseID && last.data.type === newMessage.data.type) {
+                        const copy = oldMessages.slice();
+                        copy[copy.length - 1] = newMessage;
+                        return copy;
+                    }
+                    return [...oldMessages, newMessage];
+                });
+            }
+            else {
+                setMessages(oldMessages => [...oldMessages, newMessage]);
+            }
+            // Block ticks on API errors to prevent tick → error → tick
+            // runaway loops (e.g., auth failure, rate limit, blocking limit).
+            // Cleared on compact boundary (above) or successful response (below).
+            if (feature('PROACTIVE') || feature('KAIROS')) {
+                if (newMessage.type === 'assistant' && 'isApiErrorMessage' in newMessage && newMessage.isApiErrorMessage) {
+                    proactiveModule?.setContextBlocked(true);
+                }
+                else if (newMessage.type === 'assistant') {
+                    proactiveModule?.setContextBlocked(false);
+                }
+            }
+        }, newContent => {
+            // setResponseLength handles updating both responseLengthRef (for
+            // spinner animation) and apiMetricsRef (endResponseLength/lastTokenTime
+            // for OTPS). No separate metrics update needed here.
+            setResponseLength(length => length + newContent.length);
+        }, setStreamMode, setStreamingToolUses, tombstonedMessage => {
+            setMessages(oldMessages => oldMessages.filter(m => m !== tombstonedMessage));
+            void removeTranscriptMessage(tombstonedMessage.uuid);
+        }, setStreamingThinking, metrics => {
+            const now = Date.now();
+            const baseline = responseLengthRef.current;
+            apiMetricsRef.current.push({
+                ...metrics,
+                firstTokenTime: now,
+                lastTokenTime: now,
+                responseLengthBaseline: baseline,
+                endResponseLength: baseline
+            });
+        }, onStreamingText);
+    }, [setMessages, setResponseLength, setStreamMode, setStreamingToolUses, setStreamingThinking, onStreamingText]);
+    const onQueryImpl = useCallback(async (messagesIncludingNewMessages, newMessages, abortController, shouldQuery, additionalAllowedTools, mainLoopModelParam, effort) => {
+        // Prepare IDE integration for new prompt. Read mcpClients fresh from
+        // store — useManageMCPConnections may have populated it since the
+        // render that captured this closure (same pattern as computeTools).
+        if (shouldQuery) {
+            const freshClients = mergeClients(initialMcpClients, store.getState().mcp.clients);
+            void diagnosticTracker.handleQueryStart(freshClients);
+            const ideClient = getConnectedIdeClient(freshClients);
+            if (ideClient) {
+                void closeOpenDiffs(ideClient);
+            }
+        }
+        // Mark onboarding as complete when any user message is sent to Claude
+        void maybeMarkProjectOnboardingComplete();
+        // Extract a session title from the first real user message. One-shot
+        // via ref (was tengu_birch_mist experiment: first-message-only to save
+        // Haiku calls). The ref replaces the old `messages.length <= 1` check,
+        // which was broken by SessionStart hook messages (prepended via
+        // useDeferredHookMessages) and attachment messages (appended by
+        // processTextPrompt) — both pushed length past 1 on turn one, so the
+        // title silently fell through to the "Context Code" default.
+        if (!titleDisabled && !sessionTitle && !agentTitle && !haikuTitleAttemptedRef.current) {
+            const firstUserMessage = newMessages.find(m => m.type === 'user' && !m.isMeta);
+            const text = firstUserMessage?.type === 'user' ? getContentText(firstUserMessage.message.content) : null;
+            // Skip synthetic breadcrumbs — slash-command output, prompt-skill
+            // expansions (/commit → <command-message>), local-command headers
+            // (/help → <command-name>), and bash-mode (!cmd → <bash-input>).
+            // None of these are the user's topic; wait for real prose.
+            if (text && !text.startsWith(`<${LOCAL_COMMAND_STDOUT_TAG}>`) && !text.startsWith(`<${COMMAND_MESSAGE_TAG}>`) && !text.startsWith(`<${COMMAND_NAME_TAG}>`) && !text.startsWith(`<${BASH_INPUT_TAG}>`)) {
+                haikuTitleAttemptedRef.current = true;
+                void generateSessionTitle(text, new AbortController().signal).then(title => {
+                    if (title)
+                        setHaikuTitle(title);
+                    else
+                        haikuTitleAttemptedRef.current = false;
+                }, () => {
+                    haikuTitleAttemptedRef.current = false;
+                });
+            }
+        }
+        // Apply slash-command-scoped allowedTools (from skill frontmatter) to the
+        // store once per turn. This also covers the reset: the next non-skill turn
+        // passes [] and clears it. Must run before the !shouldQuery gate: forked
+        // commands (executeForkedSlashCommand) return shouldQuery=false, and
+        // createGetAppStateWithAllowedTools in forkedAgent.ts reads this field, so
+        // stale skill tools would otherwise leak into forked agent permissions.
+        // Previously this write was hidden inside getToolUseContext's getAppState
+        // (~85 calls/turn); hoisting it here makes getAppState a pure read and stops
+        // ephemeral contexts (permission dialog, BackgroundTasksDialog) from
+        // accidentally clearing it mid-turn.
+        store.setState(prev => {
+            const cur = prev.toolPermissionContext.alwaysAllowRules.command;
+            if (cur === additionalAllowedTools || cur?.length === additionalAllowedTools.length && cur.every((v, i) => v === additionalAllowedTools[i])) {
+                return prev;
+            }
+            return {
+                ...prev,
+                toolPermissionContext: {
+                    ...prev.toolPermissionContext,
+                    alwaysAllowRules: {
+                        ...prev.toolPermissionContext.alwaysAllowRules,
+                        command: additionalAllowedTools
+                    }
+                }
+            };
+        });
+        // The last message is an assistant message if the user input was a bash command,
+        // or if the user input was an invalid slash command.
+        if (!shouldQuery) {
+            // Manual /compact sets messages directly (shouldQuery=false) bypassing
+            // handleMessageFromStream. Clear context-blocked if a compact boundary
+            // is present so proactive ticks resume after compaction.
+            if (newMessages.some(isCompactBoundaryMessage)) {
+                // Bump conversationId so Messages.tsx row keys change and
+                // stale memoized rows remount with post-compact content.
+                setConversationId(randomUUID());
+                if (feature('PROACTIVE') || feature('KAIROS')) {
+                    proactiveModule?.setContextBlocked(false);
+                }
+            }
+            resetLoadingState();
+            setAbortController(null);
+            return;
+        }
+        const toolUseContext = getToolUseContext(messagesIncludingNewMessages, newMessages, abortController, mainLoopModelParam);
+        // getToolUseContext reads tools/mcpClients fresh from store.getState()
+        // (via computeTools/mergeClients). Use those rather than the closure-
+        // captured `tools`/`mcpClients` — useManageMCPConnections may have
+        // flushed new MCP state between the render that captured this closure
+        // and now. Turn 1 via processInitialMessage is the main beneficiary.
+        const { tools: freshTools, mcpClients: freshMcpClients } = toolUseContext.options;
+        // Scope the skill's effort override to this turn's context only —
+        // wrapping getAppState keeps the override out of the global store so
+        // background agents and UI subscribers (Spinner, LogoV2) never see it.
+        if (effort !== undefined) {
+            const previousGetAppState = toolUseContext.getAppState;
+            toolUseContext.getAppState = () => ({
+                ...previousGetAppState(),
+                effortValue: effort
+            });
+        }
+        queryCheckpoint('query_context_loading_start');
+        const [, , defaultSystemPrompt, baseUserContext, systemContext] = await Promise.all([
+            // IMPORTANT: do this after setMessages() above, to avoid UI jank
+            checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState),
+            // Gated on TRANSCRIPT_CLASSIFIER so GrowthBook kill switch runs wherever auto mode is built in
+            feature('TRANSCRIPT_CLASSIFIER') ? checkAndDisableAutoModeIfNeeded(toolPermissionContext, setAppState, store.getState().fastMode) : undefined, getSystemPrompt(freshTools, mainLoopModelParam, Array.from(toolPermissionContext.additionalWorkingDirectories.keys()), freshMcpClients), getUserContext(), getSystemContext()
+        ]);
+        const userContext = {
+            ...baseUserContext,
+            ...getCoordinatorUserContext(freshMcpClients, isScratchpadEnabled() ? getScratchpadDir() : undefined),
+            ...((feature('PROACTIVE') || feature('KAIROS')) && proactiveModule?.isProactiveActive() && !terminalFocusRef.current ? {
+                terminalFocus: 'The terminal is unfocused \u2014 the user is not actively watching.'
+            } : {})
+        };
+        queryCheckpoint('query_context_loading_end');
+        const systemPrompt = buildEffectiveSystemPrompt({
+            mainThreadAgentDefinition,
+            toolUseContext,
+            customSystemPrompt,
+            defaultSystemPrompt,
+            appendSystemPrompt
+        });
+        toolUseContext.renderedSystemPrompt = systemPrompt;
+        queryCheckpoint('query_query_start');
+        resetTurnHookDuration();
+        resetTurnToolDuration();
+        resetTurnClassifierDuration();
+        for await (const event of query({
+            messages: messagesIncludingNewMessages,
+            systemPrompt,
+            userContext,
+            systemContext,
+            canUseTool,
+            toolUseContext,
+            querySource: getQuerySourceForREPL()
+        })) {
+            onQueryEvent(event);
+        }
+        if (feature('BUDDY')) {
+            void fireCompanionObserver(messagesRef.current, reaction => setAppState(prev => prev.companionReaction === reaction ? prev : {
+                ...prev,
+                companionReaction: reaction
+            }));
+        }
+        queryCheckpoint('query_end');
+        // Capture ant-only API metrics before resetLoadingState clears the ref.
+        // For multi-request turns (tool use loops), compute P50 across all requests.
+        if ("external" === 'ant' && apiMetricsRef.current.length > 0) {
+            const entries = apiMetricsRef.current;
+            const ttfts = entries.map(e => e.ttftMs);
+            // Compute per-request OTPS using only active streaming time and
+            // streaming-only content. endResponseLength tracks content added by
+            // streaming deltas only, excluding subagent/compaction inflation.
+            const otpsValues = entries.map(e => {
+                const delta = Math.round((e.endResponseLength - e.responseLengthBaseline) / 4);
+                const samplingMs = e.lastTokenTime - e.firstTokenTime;
+                return samplingMs > 0 ? Math.round(delta / (samplingMs / 1000)) : 0;
+            });
+            const isMultiRequest = entries.length > 1;
+            const hookMs = getTurnHookDurationMs();
+            const hookCount = getTurnHookCount();
+            const toolMs = getTurnToolDurationMs();
+            const toolCount = getTurnToolCount();
+            const classifierMs = getTurnClassifierDurationMs();
+            const classifierCount = getTurnClassifierCount();
+            const turnMs = Date.now() - loadingStartTimeRef.current;
+            setMessages(prev => [...prev, createApiMetricsMessage({
+                    ttftMs: isMultiRequest ? median(ttfts) : ttfts[0],
+                    otps: isMultiRequest ? median(otpsValues) : otpsValues[0],
+                    isP50: isMultiRequest,
+                    hookDurationMs: hookMs > 0 ? hookMs : undefined,
+                    hookCount: hookCount > 0 ? hookCount : undefined,
+                    turnDurationMs: turnMs > 0 ? turnMs : undefined,
+                    toolDurationMs: toolMs > 0 ? toolMs : undefined,
+                    toolCount: toolCount > 0 ? toolCount : undefined,
+                    classifierDurationMs: classifierMs > 0 ? classifierMs : undefined,
+                    classifierCount: classifierCount > 0 ? classifierCount : undefined,
+                    configWriteCount: getGlobalConfigWriteCount()
+                })]);
+        }
+        resetLoadingState();
+        // Log query profiling report if enabled
+        logQueryProfileReport();
+        // Signal that a query turn has completed successfully
+        await onTurnComplete?.(messagesRef.current);
+    }, [initialMcpClients, resetLoadingState, getToolUseContext, toolPermissionContext, setAppState, customSystemPrompt, onTurnComplete, appendSystemPrompt, canUseTool, mainThreadAgentDefinition, onQueryEvent, sessionTitle, titleDisabled]);
+    const onQuery = useCallback(async (newMessages, abortController, shouldQuery, additionalAllowedTools, mainLoopModelParam, onBeforeQueryCallback, input, effort) => {
+        // If this is a teammate, mark them as active when starting a turn
+        if (isAgentSwarmsEnabled()) {
+            const teamName = getTeamName();
+            const agentName = getAgentName();
+            if (teamName && agentName) {
+                // Fire and forget - turn starts immediately, write happens in background
+                void setMemberActive(teamName, agentName, true);
+            }
+        }
+        // Concurrent guard via state machine. tryStart() atomically checks
+        // and transitions idle→running, returning the generation number.
+        // Returns null if already running — no separate check-then-set.
+        const thisGeneration = queryGuard.tryStart();
+        if (thisGeneration === null) {
+            logEvent('tengu_concurrent_onquery_detected', {});
+            // Extract and enqueue user message text, skipping meta messages
+            // (e.g. expanded skill content, tick prompts) that should not be
+            // replayed as user-visible text.
+            newMessages.filter((m) => m.type === 'user' && !m.isMeta).map(_ => getContentText(_.message.content)).filter(_ => _ !== null).forEach((msg, i) => {
+                enqueue({
+                    value: msg,
+                    mode: 'prompt'
+                });
+                if (i === 0) {
+                    logEvent('tengu_concurrent_onquery_enqueued', {});
+                }
+            });
+            return;
+        }
+        try {
+            // isLoading is derived from queryGuard — tryStart() above already
+            // transitioned dispatching→running, so no setter call needed here.
+            resetTimingRefs();
+            setMessages(oldMessages => [...oldMessages, ...newMessages]);
+            responseLengthRef.current = 0;
+            if (feature('TOKEN_BUDGET')) {
+                const parsedBudget = input ? parseTokenBudget(input) : null;
+                snapshotOutputTokensForTurn(parsedBudget ?? getCurrentTurnTokenBudget());
+            }
+            apiMetricsRef.current = [];
+            setStreamingToolUses([]);
+            setStreamingText(null);
+            // messagesRef is updated synchronously by the setMessages wrapper
+            // above, so it already includes newMessages from the append at the
+            // top of this try block.  No reconstruction needed, no waiting for
+            // React's scheduler (previously cost 20-56ms per prompt; the 56ms
+            // case was a GC pause caught during the await).
+            const latestMessages = messagesRef.current;
+            if (input) {
+                await mrOnBeforeQuery(input, latestMessages, newMessages.length);
+            }
+            // Pass full conversation history to callback
+            if (onBeforeQueryCallback && input) {
+                const shouldProceed = await onBeforeQueryCallback(input, latestMessages);
+                if (!shouldProceed) {
+                    return;
+                }
+            }
+            await onQueryImpl(latestMessages, newMessages, abortController, shouldQuery, additionalAllowedTools, mainLoopModelParam, effort);
+        }
+        finally {
+            // queryGuard.end() atomically checks generation and transitions
+            // running→idle. Returns false if a newer query owns the guard
+            // (cancel+resubmit race where the stale finally fires as a microtask).
+            if (queryGuard.end(thisGeneration)) {
+                setLastQueryCompletionTime(Date.now());
+                skipIdleCheckRef.current = false;
+                // Always reset loading state in finally - this ensures cleanup even
+                // if onQueryImpl throws. onTurnComplete is called separately in
+                // onQueryImpl only on successful completion.
+                resetLoadingState();
+                await mrOnTurnComplete(messagesRef.current, abortController.signal.aborted);
+                // Notify bridge clients that the turn is complete so mobile apps
+                // can stop the spark animation and show post-turn UI.
+                sendBridgeResultRef.current();
+                // Auto-hide tungsten panel content at turn end (ant-only), but keep
+                // tungstenActiveSession set so the pill stays in the footer and the user
+                // can reopen the panel. Background tmux tasks (e.g. /hunter) run for
+                // minutes — wiping the session made the pill disappear entirely, forcing
+                // the user to re-invoke Tmux just to peek. Skip on abort so the panel
+                // stays open for inspection (matches the turn-duration guard below).
+                if ("external" === 'ant' && !abortController.signal.aborted) {
+                    setAppState(prev => {
+                        if (prev.tungstenActiveSession === undefined)
+                            return prev;
+                        if (prev.tungstenPanelAutoHidden === true)
+                            return prev;
+                        return {
+                            ...prev,
+                            tungstenPanelAutoHidden: true
+                        };
+                    });
+                }
+                // Capture budget info before clearing (ant-only)
+                let budgetInfo;
+                if (feature('TOKEN_BUDGET')) {
+                    if (getCurrentTurnTokenBudget() !== null && getCurrentTurnTokenBudget() > 0 && !abortController.signal.aborted) {
+                        budgetInfo = {
+                            tokens: getTurnOutputTokens(),
+                            limit: getCurrentTurnTokenBudget(),
+                            nudges: getBudgetContinuationCount()
+                        };
+                    }
+                    snapshotOutputTokensForTurn(null);
+                }
+                // Add turn duration message for turns longer than 30s or with a budget
+                // Skip if user aborted or if in loop mode (too noisy between ticks)
+                // Defer if swarm teammates are still running (show when they finish)
+                const turnDurationMs = Date.now() - loadingStartTimeRef.current - totalPausedMsRef.current;
+                if ((turnDurationMs > 30000 || budgetInfo !== undefined) && !abortController.signal.aborted && !proactiveActive) {
+                    const hasRunningSwarmAgents = getAllInProcessTeammateTasks(store.getState().tasks).some(t => t.status === 'running');
+                    if (hasRunningSwarmAgents) {
+                        // Only record start time on the first deferred turn
+                        if (swarmStartTimeRef.current === null) {
+                            swarmStartTimeRef.current = loadingStartTimeRef.current;
+                        }
+                        // Always update budget — later turns may carry the actual budget
+                        if (budgetInfo) {
+                            swarmBudgetInfoRef.current = budgetInfo;
+                        }
+                    }
+                    else {
+                        setMessages(prev => [...prev, createTurnDurationMessage(turnDurationMs, budgetInfo, count(prev, isLoggableMessage))]);
+                    }
+                }
+                // Clear the controller so CancelRequestHandler's canCancelRunningTask
+                // reads false at the idle prompt. Without this, the stale non-aborted
+                // controller makes ctrl+c fire onCancel() (aborting nothing) instead of
+                // propagating to the double-press exit flow.
+                setAbortController(null);
+            }
+            // Auto-restore: if the user interrupted before any meaningful response
+            // arrived, rewind the conversation and restore their prompt — same as
+            // opening the message selector and picking the last message.
+            // This runs OUTSIDE the queryGuard.end() check because onCancel calls
+            // forceEnd(), which bumps the generation so end() returns false above.
+            // Guards: reason === 'user-cancel' (onCancel/Esc; programmatic aborts
+            // use 'background'/'interrupt' and must not rewind — note abort() with
+            // no args sets reason to a DOMException, not undefined), !isActive (no
+            // newer query started — cancel+resubmit race), empty input (don't
+            // clobber text typed during loading), no queued commands (user queued
+            // B while A was loading → they've moved on, don't restore A; also
+            // avoids removeLastFromHistory removing B's entry instead of A's),
+            // not viewing a teammate (messagesRef is the main conversation — the
+            // old Up-arrow quick-restore had this guard, preserve it).
+            if (abortController.signal.reason === 'user-cancel' && !queryGuard.isActive && inputValueRef.current === '' && getCommandQueueLength() === 0 && !store.getState().viewingAgentTaskId) {
+                const msgs = messagesRef.current;
+                const lastUserMsg = msgs.findLast(selectableUserMessagesFilter);
+                if (lastUserMsg) {
+                    const idx = msgs.lastIndexOf(lastUserMsg);
+                    if (messagesAfterAreOnlySynthetic(msgs, idx)) {
+                        // The submit is being undone — undo its history entry too,
+                        // otherwise Up-arrow shows the restored text twice.
+                        removeLastFromHistory();
+                        restoreMessageSyncRef.current(lastUserMsg);
+                    }
+                }
+            }
+        }
+    }, [onQueryImpl, setAppState, resetLoadingState, queryGuard, mrOnBeforeQuery, mrOnTurnComplete]);
+    // Handle initial message (from CLI args or plan mode exit with context clear)
+    // This effect runs when isLoading becomes false and there's a pending message
+    const initialMessageRef = useRef(false);
+    useEffect(() => {
+        const pending = initialMessage;
+        if (!pending || isLoading || initialMessageRef.current)
+            return;
+        // Mark as processing to prevent re-entry
+        initialMessageRef.current = true;
+        async function processInitialMessage(initialMsg) {
+            // Clear context if requested (plan mode exit)
+            if (initialMsg.clearContext) {
+                // Preserve the plan slug before clearing context, so the new session
+                // can access the same plan file after regenerateSessionId()
+                const oldPlanSlug = initialMsg.message.planContent ? getPlanSlug() : undefined;
+                const { clearConversation } = await import('../commands/clear/conversation.js');
+                await clearConversation({
+                    setMessages,
+                    readFileState: readFileState.current,
+                    discoveredSkillNames: discoveredSkillNamesRef.current,
+                    loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,
+                    getAppState: () => store.getState(),
+                    setAppState,
+                    setConversationId
+                });
+                haikuTitleAttemptedRef.current = false;
+                setHaikuTitle(undefined);
+                bashTools.current.clear();
+                bashToolsProcessedIdx.current = 0;
+                // Restore the plan slug for the new session so getPlan() finds the file
+                if (oldPlanSlug) {
+                    setPlanSlug(getSessionId(), oldPlanSlug);
+                }
+            }
+            // Atomically: clear initial message, set permission mode and rules, and store plan for verification
+            const shouldStorePlanForVerification = initialMsg.message.planContent && "external" === 'ant' && isEnvTruthy(undefined);
+            setAppState(prev => {
+                // Build and apply permission updates (mode + allowedPrompts rules)
+                let updatedToolPermissionContext = initialMsg.mode ? applyPermissionUpdates(prev.toolPermissionContext, buildPermissionUpdates(initialMsg.mode, initialMsg.allowedPrompts)) : prev.toolPermissionContext;
+                // For auto, override the mode (buildPermissionUpdates maps
+                // it to 'default' via toExternalPermissionMode) and strip dangerous rules
+                if (feature('TRANSCRIPT_CLASSIFIER') && initialMsg.mode === 'auto') {
+                    updatedToolPermissionContext = stripDangerousPermissionsForAutoMode({
+                        ...updatedToolPermissionContext,
+                        mode: 'auto',
+                        prePlanMode: undefined
+                    });
+                }
+                return {
+                    ...prev,
+                    initialMessage: null,
+                    toolPermissionContext: updatedToolPermissionContext,
+                    ...(shouldStorePlanForVerification && {
+                        pendingPlanVerification: {
+                            plan: initialMsg.message.planContent,
+                            verificationStarted: false,
+                            verificationCompleted: false
+                        }
+                    })
+                };
+            });
+            // Create file history snapshot for code rewind
+            if (fileHistoryEnabled()) {
+                void fileHistoryMakeSnapshot((updater) => {
+                    setAppState(prev => ({
+                        ...prev,
+                        fileHistory: updater(prev.fileHistory)
+                    }));
+                }, initialMsg.message.uuid);
+            }
+            // Ensure SessionStart hook context is available before the first API
+            // call. onSubmit calls this internally but the onQuery path below
+            // bypasses onSubmit — hoist here so both paths see hook messages.
+            await awaitPendingHooks();
+            // Route all initial prompts through onSubmit to ensure UserPromptSubmit hooks fire
+            // TODO: Simplify by always routing through onSubmit once it supports
+            // ContentBlockParam arrays (images) as input
+            const content = initialMsg.message.message.content;
+            // Route all string content through onSubmit to ensure hooks fire
+            // For complex content (images, etc.), fall back to direct onQuery
+            // Plan messages bypass onSubmit to preserve planContent metadata for rendering
+            if (typeof content === 'string' && !initialMsg.message.planContent) {
+                // Route through onSubmit for proper processing including UserPromptSubmit hooks
+                void onSubmit(content, {
+                    setCursorOffset: () => { },
+                    clearBuffer: () => { },
+                    resetHistory: () => { }
+                });
+            }
+            else {
+                // Plan messages or complex content (images, etc.) - send directly to model
+                // Plan messages use onQuery to preserve planContent metadata for rendering
+                // TODO: Once onSubmit supports ContentBlockParam arrays, remove this branch
+                const newAbortController = createAbortController();
+                setAbortController(newAbortController);
+                void onQuery([initialMsg.message], newAbortController, true, 
+                // shouldQuery
+                [], 
+                // additionalAllowedTools
+                mainLoopModel);
+            }
+            // Reset ref after a delay to allow new initial messages
+            setTimeout(ref => {
+                ref.current = false;
+            }, 100, initialMessageRef);
+        }
+        void processInitialMessage(pending);
+    }, [initialMessage, isLoading, setMessages, setAppState, onQuery, mainLoopModel, tools]);
+    const onSubmit = useCallback(async (input, helpers, speculationAccept, options) => {
+        // Re-pin scroll to bottom on submit so the user always sees the new
+        // exchange (matches OpenCode's auto-scroll behavior).
+        repinScroll();
+        // Resume loop mode if paused
+        if (feature('PROACTIVE') || feature('KAIROS')) {
+            proactiveModule?.resumeProactive();
+        }
+        // Handle immediate commands - these bypass the queue and execute right away
+        // even while Claude is processing. Commands opt-in via `immediate: true`.
+        // Commands triggered via keybindings are always treated as immediate.
+        if (!speculationAccept && input.trim().startsWith('/')) {
+            // Expand [Pasted text #N] refs so immediate commands (e.g. /btw) receive
+            // the pasted content, not the placeholder. The non-immediate path gets
+            // this expansion later in handlePromptSubmit.
+            const trimmedInput = expandPastedTextRefs(input, pastedContents).trim();
+            const spaceIndex = trimmedInput.indexOf(' ');
+            const commandName = spaceIndex === -1 ? trimmedInput.slice(1) : trimmedInput.slice(1, spaceIndex);
+            const commandArgs = spaceIndex === -1 ? '' : trimmedInput.slice(spaceIndex + 1).trim();
+            // Find matching command - treat as immediate if:
+            // 1. Command has `immediate: true`, OR
+            // 2. Command was triggered via keybinding (fromKeybinding option)
+            const matchingCommand = commands.find(cmd => isCommandEnabled(cmd) && (cmd.name === commandName || cmd.aliases?.includes(commandName) || getCommandName(cmd) === commandName));
+            if (matchingCommand?.name === 'clear' && idleHintShownRef.current) {
+                logEvent('tengu_idle_return_action', {
+                    action: 'hint_converted',
+                    variant: idleHintShownRef.current,
+                    idleMinutes: Math.round((Date.now() - lastQueryCompletionTimeRef.current) / 60_000),
+                    messageCount: messagesRef.current.length,
+                    totalInputTokens: getTotalInputTokens()
+                });
+                idleHintShownRef.current = false;
+            }
+            const shouldTreatAsImmediate = queryGuard.isActive && (matchingCommand?.immediate || options?.fromKeybinding);
+            if (matchingCommand && shouldTreatAsImmediate && matchingCommand.type === 'local-jsx') {
+                // Only clear input if the submitted text matches what's in the prompt.
+                // When a command keybinding fires, input is "/<command>" but the actual
+                // input value is the user's existing text - don't clear it in that case.
+                if (input.trim() === inputValueRef.current.trim()) {
+                    setInputValue('');
+                    helpers.setCursorOffset(0);
+                    helpers.clearBuffer();
+                    setPastedContents({});
+                }
+                const pastedTextRefs = parseReferences(input).filter(r => pastedContents[r.id]?.type === 'text');
+                const pastedTextCount = pastedTextRefs.length;
+                const pastedTextBytes = pastedTextRefs.reduce((sum, r) => sum + (pastedContents[r.id]?.content.length ?? 0), 0);
+                logEvent('tengu_paste_text', {
+                    pastedTextCount,
+                    pastedTextBytes
+                });
+                logEvent('tengu_immediate_command_executed', {
+                    commandName: matchingCommand.name,
+                    fromKeybinding: options?.fromKeybinding ?? false
+                });
+                // Execute the command directly
+                const executeImmediateCommand = async () => {
+                    let doneWasCalled = false;
+                    const onDone = (result, doneOptions) => {
+                        doneWasCalled = true;
+                        setToolJSX({
+                            jsx: null,
+                            shouldHidePromptInput: false,
+                            clearLocalJSX: true
+                        });
+                        const newMessages = [];
+                        if (result && doneOptions?.display !== 'skip') {
+                            addNotification({
+                                key: `immediate-${matchingCommand.name}`,
+                                text: result,
+                                priority: 'immediate'
+                            });
+                            // In fullscreen the command just showed as a centered modal
+                            // pane — the notification above is enough feedback. Adding
+                            // "❯ /config" + "⎿ dismissed" to the transcript is clutter
+                            // (those messages are type:system subtype:local_command —
+                            // user-visible but NOT sent to the model, so skipping them
+                            // doesn't change model context). Outside fullscreen the
+                            // transcript entry stays so scrollback shows what ran.
+                            if (!isFullscreenEnvEnabled()) {
+                                newMessages.push(createCommandInputMessage(formatCommandInputTags(getCommandName(matchingCommand), commandArgs)), createCommandInputMessage(`<${LOCAL_COMMAND_STDOUT_TAG}>${escapeXml(result)}</${LOCAL_COMMAND_STDOUT_TAG}>`));
+                            }
+                        }
+                        // Inject meta messages (model-visible, user-hidden) into the transcript
+                        if (doneOptions?.metaMessages?.length) {
+                            newMessages.push(...doneOptions.metaMessages.map(content => createUserMessage({
+                                content,
+                                isMeta: true
+                            })));
+                        }
+                        if (newMessages.length) {
+                            setMessages(prev => [...prev, ...newMessages]);
+                        }
+                        // Restore stashed prompt after local-jsx command completes.
+                        // The normal stash restoration path (below) is skipped because
+                        // local-jsx commands return early from onSubmit.
+                        if (stashedPrompt !== undefined) {
+                            setInputValue(stashedPrompt.text);
+                            helpers.setCursorOffset(stashedPrompt.cursorOffset);
+                            setPastedContents(stashedPrompt.pastedContents);
+                            setStashedPrompt(undefined);
+                        }
+                    };
+                    // Build context for the command (reuses existing getToolUseContext).
+                    // Read messages via ref to keep onSubmit stable across message
+                    // updates — matches the pattern at L2384/L2400/L2662 and avoids
+                    // pinning stale REPL render scopes in downstream closures.
+                    const context = getToolUseContext(messagesRef.current, [], createAbortController(), mainLoopModel);
+                    const mod = await matchingCommand.load();
+                    const jsx = await mod.call(onDone, context, commandArgs);
+                    // Skip if onDone already fired — prevents stuck isLocalJSXCommand
+                    // (see processSlashCommand.tsx local-jsx case for full mechanism).
+                    if (jsx && !doneWasCalled) {
+                        // shouldHidePromptInput: false keeps Notifications mounted
+                        // so the onDone result isn't lost
+                        setToolJSX({
+                            jsx,
+                            shouldHidePromptInput: false,
+                            isLocalJSXCommand: true
+                        });
+                    }
+                };
+                void executeImmediateCommand();
+                return; // Always return early - don't add to history or queue
+            }
+        }
+        // Remote mode: skip empty input early before any state mutations
+        if (activeRemote.isRemoteMode && !input.trim()) {
+            return;
+        }
+        // Idle-return: prompt returning users to start fresh when the
+        // conversation is large and the cache is cold. tengu_willow_mode
+        // controls treatment: "dialog" (blocking), "hint" (notification), "off".
+        {
+            const willowMode = getFeatureValue_CACHED_MAY_BE_STALE('tengu_willow_mode', 'off');
+            const idleThresholdMin = Number(process.env.CLAUDE_CODE_IDLE_THRESHOLD_MINUTES ?? 75);
+            const tokenThreshold = Number(process.env.CLAUDE_CODE_IDLE_TOKEN_THRESHOLD ?? 100_000);
+            if (willowMode !== 'off' && !getGlobalConfig().idleReturnDismissed && !skipIdleCheckRef.current && !speculationAccept && !input.trim().startsWith('/') && lastQueryCompletionTimeRef.current > 0 && getTotalInputTokens() >= tokenThreshold) {
+                const idleMs = Date.now() - lastQueryCompletionTimeRef.current;
+                const idleMinutes = idleMs / 60_000;
+                if (idleMinutes >= idleThresholdMin && willowMode === 'dialog') {
+                    setIdleReturnPending({
+                        input,
+                        idleMinutes
+                    });
+                    setInputValue('');
+                    helpers.setCursorOffset(0);
+                    helpers.clearBuffer();
+                    return;
+                }
+            }
+        }
+        // Add to history for direct user submissions.
+        // Queued command processing (executeQueuedInput) doesn't call onSubmit,
+        // so notifications and already-queued user input won't be added to history here.
+        // Skip history for keybinding-triggered commands (user didn't type the command).
+        if (!options?.fromKeybinding) {
+            addToHistory({
+                display: speculationAccept ? input : prependModeCharacterToInput(input, inputMode),
+                pastedContents: speculationAccept ? {} : pastedContents
+            });
+            // Add the just-submitted command to the front of the ghost-text
+            // cache so it's suggested immediately (not after the 60s TTL).
+            if (inputMode === 'bash') {
+                prependToShellHistoryCache(input.trim());
+            }
+        }
+        // Restore stash if present, but NOT for slash commands or when loading.
+        // - Slash commands (especially interactive ones like /model, /context) hide
+        //   the prompt and show a picker UI. Restoring the stash during a command would
+        //   place the text in a hidden input, and the user would lose it by typing the
+        //   next command. Instead, preserve the stash so it survives across command runs.
+        // - When loading, the submitted input will be queued and handlePromptSubmit
+        //   will clear the input field (onInputChange('')), which would clobber the
+        //   restored stash. Defer restoration to after handlePromptSubmit (below).
+        //   Remote mode is exempt: it sends via WebSocket and returns early without
+        //   calling handlePromptSubmit, so there's no clobbering risk — restore eagerly.
+        // In both deferred cases, the stash is restored after await handlePromptSubmit.
+        const isSlashCommand = !speculationAccept && input.trim().startsWith('/');
+        // Submit runs "now" (not queued) when not already loading, or when
+        // accepting speculation, or in remote mode (which sends via WS and
+        // returns early without calling handlePromptSubmit).
+        const submitsNow = !isLoading || speculationAccept || activeRemote.isRemoteMode;
+        if (stashedPrompt !== undefined && !isSlashCommand && submitsNow) {
+            setInputValue(stashedPrompt.text);
+            helpers.setCursorOffset(stashedPrompt.cursorOffset);
+            setPastedContents(stashedPrompt.pastedContents);
+            setStashedPrompt(undefined);
+        }
+        else if (submitsNow) {
+            if (!options?.fromKeybinding) {
+                // Clear input when not loading or accepting speculation.
+                // Preserve input for keybinding-triggered commands.
+                setInputValue('');
+                helpers.setCursorOffset(0);
+            }
+            setPastedContents({});
+        }
+        if (submitsNow) {
+            setInputMode('prompt');
+            setIDESelection(undefined);
+            setSubmitCount(_ => _ + 1);
+            helpers.clearBuffer();
+            tipPickedThisTurnRef.current = false;
+            // Show the placeholder in the same React batch as setInputValue('').
+            // Skip for slash/bash (they have their own echo), speculation and remote
+            // mode (both setMessages directly with no gap to bridge).
+            if (!isSlashCommand && inputMode === 'prompt' && !speculationAccept && !activeRemote.isRemoteMode) {
+                setUserInputOnProcessing(input);
+                // showSpinner includes userInputOnProcessing, so the spinner appears
+                // on this render. Reset timing refs now (before queryGuard.reserve()
+                // would) so elapsed time doesn't read as Date.now() - 0. The
+                // isQueryActive transition above does the same reset — idempotent.
+                resetTimingRefs();
+            }
+            // Increment prompt count for attribution tracking and save snapshot
+            // The snapshot persists promptCount so it survives compaction
+            if (feature('COMMIT_ATTRIBUTION')) {
+                setAppState(prev => ({
+                    ...prev,
+                    attribution: incrementPromptCount(prev.attribution, snapshot => {
+                        void recordAttributionSnapshot(snapshot).catch(error => {
+                            logForDebugging(`Attribution: Failed to save snapshot: ${error}`);
+                        });
+                    })
+                }));
+            }
+        }
+        // Handle speculation acceptance
+        if (speculationAccept) {
+            const { queryRequired } = await handleSpeculationAccept(speculationAccept.state, speculationAccept.speculationSessionTimeSavedMs, speculationAccept.setAppState, input, {
+                setMessages,
+                readFileState,
+                cwd: getOriginalCwd()
+            });
+            if (queryRequired) {
+                const newAbortController = createAbortController();
+                setAbortController(newAbortController);
+                void onQuery([], newAbortController, true, [], mainLoopModel);
+            }
+            return;
+        }
+        // Remote mode: send input via stream-json instead of local query.
+        // Permission requests from the remote are bridged into toolUseConfirmQueue
+        // and rendered using the standard PermissionRequest component.
+        //
+        // local-jsx slash commands (e.g. /agents, /config) render UI in THIS
+        // process — they have no remote equivalent. Let those fall through to
+        // handlePromptSubmit so they execute locally. Prompt commands and
+        // plain text go to the remote.
+        if (activeRemote.isRemoteMode && !(isSlashCommand && commands.find(c => {
+            const name = input.trim().slice(1).split(/\s/)[0];
+            return isCommandEnabled(c) && (c.name === name || c.aliases?.includes(name) || getCommandName(c) === name);
+        })?.type === 'local-jsx')) {
+            // Build content blocks when there are pasted attachments (images)
+            const pastedValues = Object.values(pastedContents);
+            const imageContents = pastedValues.filter(c => c.type === 'image');
+            const imagePasteIds = imageContents.length > 0 ? imageContents.map(c => c.id) : undefined;
+            let messageContent = input.trim();
+            let remoteContent = input.trim();
+            if (pastedValues.length > 0) {
+                const contentBlocks = [];
+                const remoteBlocks = [];
+                const trimmedInput = input.trim();
+                if (trimmedInput) {
+                    contentBlocks.push({
+                        type: 'text',
+                        text: trimmedInput
+                    });
+                    remoteBlocks.push({
+                        type: 'text',
+                        text: trimmedInput
+                    });
+                }
+                for (const pasted of pastedValues) {
+                    if (pasted.type === 'image') {
+                        const source = {
+                            type: 'base64',
+                            media_type: (pasted.mediaType ?? 'image/png'),
+                            data: pasted.content
+                        };
+                        contentBlocks.push({
+                            type: 'image',
+                            source
+                        });
+                        remoteBlocks.push({
+                            type: 'image',
+                            source
+                        });
+                    }
+                    else {
+                        contentBlocks.push({
+                            type: 'text',
+                            text: pasted.content
+                        });
+                        remoteBlocks.push({
+                            type: 'text',
+                            text: pasted.content
+                        });
+                    }
+                }
+                messageContent = contentBlocks;
+                remoteContent = remoteBlocks;
+            }
+            // Create and add user message to UI
+            // Note: empty input already handled by early return above
+            const userMessage = createUserMessage({
+                content: messageContent,
+                imagePasteIds
+            });
+            setMessages(prev => [...prev, userMessage]);
+            // Send to remote session
+            await activeRemote.sendMessage(remoteContent, {
+                uuid: userMessage.uuid
+            });
+            return;
+        }
+        // Ensure SessionStart hook context is available before the first API call.
+        await awaitPendingHooks();
+        await handlePromptSubmit({
+            input,
+            helpers,
+            queryGuard,
+            isExternalLoading,
+            mode: inputMode,
+            commands,
+            onInputChange: setInputValue,
+            setPastedContents,
+            setToolJSX,
+            getToolUseContext,
+            messages: messagesRef.current,
+            mainLoopModel,
+            pastedContents,
+            ideSelection,
+            setUserInputOnProcessing,
+            setAbortController,
+            abortController,
+            onQuery,
+            setAppState,
+            querySource: getQuerySourceForREPL(),
+            onBeforeQuery,
+            canUseTool,
+            addNotification,
+            setMessages,
+            // Read via ref so streamMode can be dropped from onSubmit deps —
+            // handlePromptSubmit only uses it for debug log + telemetry event.
+            streamMode: streamModeRef.current,
+            hasInterruptibleToolInProgress: hasInterruptibleToolInProgressRef.current
+        });
+        // Restore stash that was deferred above. Two cases:
+        // - Slash command: handlePromptSubmit awaited the full command execution
+        //   (including interactive pickers). Restoring now places the stash back in
+        //   the visible input.
+        // - Loading (queued): handlePromptSubmit enqueued + cleared input, then
+        //   returned quickly. Restoring now places the stash back after the clear.
+        if ((isSlashCommand || isLoading) && stashedPrompt !== undefined) {
+            setInputValue(stashedPrompt.text);
+            helpers.setCursorOffset(stashedPrompt.cursorOffset);
+            setPastedContents(stashedPrompt.pastedContents);
+            setStashedPrompt(undefined);
+        }
+    }, [queryGuard,
+        // isLoading is read at the !isLoading checks above for input-clearing
+        // and submitCount gating. It's derived from isQueryActive || isExternalLoading,
+        // so including it here ensures the closure captures the fresh value.
+        isLoading, isExternalLoading, inputMode, commands, setInputValue, setInputMode, setPastedContents, setSubmitCount, setIDESelection, setToolJSX, getToolUseContext,
+        // messages is read via messagesRef.current inside the callback to
+        // keep onSubmit stable across message updates (see L2384/L2400/L2662).
+        // Without this, each setMessages call (~30× per turn) recreates
+        // onSubmit, pinning the REPL render scope (1776B) + that render's
+        // messages array in downstream closures (PromptInput, handleAutoRunIssue).
+        // Heap analysis showed ~9 REPL scopes and ~15 messages array versions
+        // accumulating after #20174/#20175, all traced to this dep.
+        mainLoopModel, pastedContents, ideSelection, setUserInputOnProcessing, setAbortController, addNotification, onQuery, stashedPrompt, setStashedPrompt, setAppState, onBeforeQuery, canUseTool, remoteSession, setMessages, awaitPendingHooks, repinScroll]);
+    // Callback for when user submits input while viewing a teammate's transcript
+    const onAgentSubmit = useCallback(async (input, task, helpers) => {
+        if (isLocalAgentTask(task)) {
+            appendMessageToLocalAgent(task.id, createUserMessage({
+                content: input
+            }), setAppState);
+            if (task.status === 'running') {
+                queuePendingMessage(task.id, input, setAppState);
+            }
+            else {
+                void resumeAgentBackground({
+                    agentId: task.id,
+                    prompt: input,
+                    toolUseContext: getToolUseContext(messagesRef.current, [], new AbortController(), mainLoopModel),
+                    canUseTool
+                }).catch(err => {
+                    logForDebugging(`resumeAgentBackground failed: ${errorMessage(err)}`);
+                    addNotification({
+                        key: `resume-agent-failed-${task.id}`,
+                        jsx: _jsxs(Text, { color: "error", children: ["Failed to resume agent: ", errorMessage(err)] }),
+                        priority: 'low'
+                    });
+                });
+            }
+        }
+        else {
+            injectUserMessageToTeammate(task.id, input, setAppState);
+        }
+        setInputValue('');
+        helpers.setCursorOffset(0);
+        helpers.clearBuffer();
+    }, [setAppState, setInputValue, getToolUseContext, canUseTool, mainLoopModel, addNotification]);
+    // Handlers for auto-run /issue or /good-claude (defined after onSubmit)
+    const handleAutoRunIssue = useCallback(() => {
+        const command = autoRunIssueReason ? getAutoRunCommand(autoRunIssueReason) : '/issue';
+        setAutoRunIssueReason(null); // Clear the state
+        onSubmit(command, {
+            setCursorOffset: () => { },
+            clearBuffer: () => { },
+            resetHistory: () => { }
+        }).catch(err => {
+            logForDebugging(`Auto-run ${command} failed: ${errorMessage(err)}`);
+        });
+    }, [onSubmit, autoRunIssueReason]);
+    const handleCancelAutoRunIssue = useCallback(() => {
+        setAutoRunIssueReason(null);
+    }, []);
+    // Handler for when user presses 1 on survey thanks screen to share details
+    const handleSurveyRequestFeedback = useCallback(() => {
+        const command = "external" === 'ant' ? '/issue' : '/feedback';
+        onSubmit(command, {
+            setCursorOffset: () => { },
+            clearBuffer: () => { },
+            resetHistory: () => { }
+        }).catch(err => {
+            logForDebugging(`Survey feedback request failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }, [onSubmit]);
+    // onSubmit is unstable (deps include `messages` which changes every turn).
+    // `handleOpenRateLimitOptions` is prop-drilled to every MessageRow, and each
+    // MessageRow fiber pins the closure (and transitively the entire REPL render
+    // scope, ~1.8KB) at mount time. Using a ref keeps this callback stable so
+    // old REPL scopes can be GC'd — saves ~35MB over a 1000-turn session.
+    const onSubmitRef = useRef(onSubmit);
+    onSubmitRef.current = onSubmit;
+    const handleOpenRateLimitOptions = useCallback(() => {
+        void onSubmitRef.current('/rate-limit-options', {
+            setCursorOffset: () => { },
+            clearBuffer: () => { },
+            resetHistory: () => { }
+        });
+    }, []);
+    const handleExit = useCallback(async () => {
+        setIsExiting(true);
+        // In bg sessions, always detach instead of kill — even when a worktree is
+        // active. Without this guard, the worktree branch below short-circuits into
+        // ExitFlow (which calls gracefulShutdown) before exit.tsx is ever loaded.
+        if (feature('BG_SESSIONS') && isBgSession()) {
+            spawnSync('tmux', ['detach-client'], {
+                stdio: 'ignore'
+            });
+            setIsExiting(false);
+            return;
+        }
+        const showWorktree = getCurrentWorktreeSession() !== null;
+        if (showWorktree) {
+            setExitFlow(_jsx(ExitFlow, { showWorktree: true, onDone: () => { }, onCancel: () => {
+                    setExitFlow(null);
+                    setIsExiting(false);
+                } }));
+            return;
+        }
+        const exitMod = await exit.load();
+        const exitFlowResult = await exitMod.call(() => { });
+        setExitFlow(exitFlowResult);
+        // If call() returned without killing the process (bg session detach),
+        // clear isExiting so the UI is usable on reattach. No-op on the normal
+        // path — gracefulShutdown's process.exit() means we never get here.
+        if (exitFlowResult === null) {
+            setIsExiting(false);
+        }
+    }, []);
+    const handleShowMessageSelector = useCallback(() => {
+        setIsMessageSelectorVisible(prev => !prev);
+    }, []);
+    // Rewind conversation state to just before `message`: slice messages,
+    // reset conversation ID, microcompact state, permission mode, prompt suggestion.
+    // Does NOT touch the prompt input. Index is computed from messagesRef (always
+    // fresh via the setMessages wrapper) so callers don't need to worry about
+    // stale closures.
+    const rewindConversationTo = useCallback((message) => {
+        const prev = messagesRef.current;
+        const messageIndex = prev.lastIndexOf(message);
+        if (messageIndex === -1)
+            return;
+        logEvent('tengu_conversation_rewind', {
+            preRewindMessageCount: prev.length,
+            postRewindMessageCount: messageIndex,
+            messagesRemoved: prev.length - messageIndex,
+            rewindToMessageIndex: messageIndex
+        });
+        setMessages(prev.slice(0, messageIndex));
+        // Careful, this has to happen after setMessages
+        setConversationId(randomUUID());
+        // Reset cached microcompact state so stale pinned cache edits
+        // don't reference tool_use_ids from truncated messages
+        resetMicrocompactState();
+        if (feature('CONTEXT_COLLAPSE')) {
+            // Rewind truncates the REPL array. Commits whose archived span
+            // was past the rewind point can't be projected anymore
+            // (projectView silently skips them) but the staged queue and ID
+            // maps reference stale uuids. Simplest safe reset: drop
+            // everything. The ctx-agent will re-stage on the next
+            // threshold crossing.
+            /* eslint-disable @typescript-eslint/no-require-imports */
+            ;
+            require('../services/contextCollapse/index.js').resetContextCollapse();
+            /* eslint-enable @typescript-eslint/no-require-imports */
+        }
+        // Restore state from the message we're rewinding to
+        setAppState(prev => ({
+            ...prev,
+            // Restore permission mode from the message
+            toolPermissionContext: message.permissionMode && prev.toolPermissionContext.mode !== message.permissionMode ? {
+                ...prev.toolPermissionContext,
+                mode: message.permissionMode
+            } : prev.toolPermissionContext,
+            // Clear stale prompt suggestion from previous conversation state
+            promptSuggestion: {
+                text: null,
+                promptId: null,
+                shownAt: 0,
+                acceptedAt: 0,
+                generationRequestId: null
+            }
+        }));
+    }, [setMessages, setAppState]);
+    // Synchronous rewind + input population. Used directly by auto-restore on
+    // interrupt (so React batches with the abort's setMessages → single render,
+    // no flicker). MessageSelector wraps this in setImmediate via handleRestoreMessage.
+    const restoreMessageSync = useCallback((message) => {
+        rewindConversationTo(message);
+        const r = textForResubmit(message);
+        if (r) {
+            setInputValue(r.text);
+            setInputMode(r.mode);
+        }
+        // Restore pasted images
+        if (Array.isArray(message.message.content) && message.message.content.some(block => block.type === 'image')) {
+            const imageBlocks = message.message.content.filter(block => block.type === 'image');
+            if (imageBlocks.length > 0) {
+                const newPastedContents = {};
+                imageBlocks.forEach((block, index) => {
+                    if (block.source.type === 'base64') {
+                        const id = message.imagePasteIds?.[index] ?? index + 1;
+                        newPastedContents[id] = {
+                            id,
+                            type: 'image',
+                            content: block.source.data,
+                            mediaType: block.source.media_type
+                        };
+                    }
+                });
+                setPastedContents(newPastedContents);
+            }
+        }
+    }, [rewindConversationTo, setInputValue]);
+    restoreMessageSyncRef.current = restoreMessageSync;
+    // MessageSelector path: defer via setImmediate so the "Interrupted" message
+    // renders to static output before rewind — otherwise it remains vestigial
+    // at the top of the screen.
+    const handleRestoreMessage = useCallback(async (message) => {
+        setImmediate((restore, message) => restore(message), restoreMessageSync, message);
+    }, [restoreMessageSync]);
+    // Not memoized — hook stores caps via ref, reads latest closure at dispatch.
+    // 24-char prefix: deriveUUID preserves first 24, renderable uuid prefix-matches raw source.
+    const findRawIndex = (uuid) => {
+        const prefix = uuid.slice(0, 24);
+        return messages.findIndex(m => m.uuid.slice(0, 24) === prefix);
+    };
+    const messageActionCaps = {
+        copy: text => 
+        // setClipboard RETURNS OSC 52 — caller must stdout.write (tmux side-effects load-buffer, but that's tmux-only).
+        void setClipboard(text).then(raw => {
+            if (raw)
+                process.stdout.write(raw);
+            addNotification({
+                // Same key as text-selection copy — repeated copies replace toast, don't queue.
+                key: 'selection-copied',
+                text: 'copied',
+                color: 'success',
+                priority: 'immediate',
+                timeoutMs: 2000
+            });
+        }),
+        edit: async (msg) => {
+            // Same skip-confirm check as /rewind: lossless → direct, else confirm dialog.
+            const rawIdx = findRawIndex(msg.uuid);
+            const raw = rawIdx >= 0 ? messages[rawIdx] : undefined;
+            if (!raw || !selectableUserMessagesFilter(raw))
+                return;
+            const noFileChanges = !(await fileHistoryHasAnyChanges(fileHistory, raw.uuid));
+            const onlySynthetic = messagesAfterAreOnlySynthetic(messages, rawIdx);
+            if (noFileChanges && onlySynthetic) {
+                // rewindConversationTo's setMessages races stream appends — cancel first (idempotent).
+                onCancel();
+                // handleRestoreMessage also restores pasted images.
+                void handleRestoreMessage(raw);
+            }
+            else {
+                // Dialog path: onPreRestore (= onCancel) fires when user CONFIRMS, not on nevermind.
+                setMessageSelectorPreselect(raw);
+                setIsMessageSelectorVisible(true);
+            }
+        }
+    };
+    const { enter: enterMessageActions, handlers: messageActionHandlers } = useMessageActions(cursor, setCursor, cursorNavRef, messageActionCaps);
+    async function onInit() {
+        // Always verify API key on startup, so we can show the user an error in the
+        // bottom right corner of the screen if the API key is invalid.
+        void reverify();
+        // Populate readFileState with CLAUDE.md files at startup
+        const memoryFiles = await getMemoryFiles();
+        if (memoryFiles.length > 0) {
+            const fileList = memoryFiles.map(f => `  [${f.type}] ${f.path} (${f.content.length} chars)${f.parent ? ` (included by ${f.parent})` : ''}`).join('\n');
+            logForDebugging(`Loaded ${memoryFiles.length} CLAUDE.md/rules files:\n${fileList}`);
+        }
+        else {
+            logForDebugging('No CLAUDE.md/rules files found');
+        }
+        for (const file of memoryFiles) {
+            // When the injected content doesn't match disk (stripped HTML comments,
+            // stripped frontmatter, MEMORY.md truncation), cache the RAW disk bytes
+            // with isPartialView so Edit/Write require a real Read first while
+            // getChangedFiles + nested_memory dedup still work.
+            readFileState.current.set(file.path, {
+                content: file.contentDiffersFromDisk ? file.rawContent ?? file.content : file.content,
+                timestamp: Date.now(),
+                offset: undefined,
+                limit: undefined,
+                isPartialView: file.contentDiffersFromDisk
+            });
+        }
+        // Initial message handling is done via the initialMessage effect
+    }
+    // Register cost summary tracker
+    useCostSummary(useFpsMetrics());
+    // Record transcripts locally, for debugging and conversation recovery
+    // Don't record conversation if we only have initial messages; optimizes
+    // the case where user resumes a conversation then quites before doing
+    // anything else
+    useLogMessages(messages, messages.length === initialMessages?.length);
+    // REPL Bridge: replicate user/assistant messages to the bridge session
+    // for remote access via claude.ai. No-op in external builds or when not enabled.
+    const { sendBridgeResult } = useReplBridge(messages, setMessages, abortControllerRef, commands, mainLoopModel);
+    sendBridgeResultRef.current = sendBridgeResult;
+    // Telegram mirror: espeja prompts + respuestas + resúmenes de tool_use al
+    // chat primario cuando el bridge está activo, e inyecta mensajes entrantes
+    // desde Telegram al REPL como si fueran prompts del usuario.
+    useTelegramMirror(messages);
+    // WhatsApp mirror: mismo patrón que Telegram, al número primario configurado.
+    useWhatsAppMirror(messages);
+    useAfterFirstRender();
+    // Track prompt queue usage for analytics. Fire once per transition from
+    // empty to non-empty, not on every length change -- otherwise a render loop
+    // (concurrent onQuery thrashing, etc.) spams saveGlobalConfig, which hits
+    // ELOCKED under concurrent sessions and falls back to unlocked writes.
+    // That write storm is the primary trigger for ~/.context.json corruption
+    // (GH #3117).
+    const hasCountedQueueUseRef = useRef(false);
+    useEffect(() => {
+        if (queuedCommands.length < 1) {
+            hasCountedQueueUseRef.current = false;
+            return;
+        }
+        if (hasCountedQueueUseRef.current)
+            return;
+        hasCountedQueueUseRef.current = true;
+        saveGlobalConfig(current => ({
+            ...current,
+            promptQueueUseCount: (current.promptQueueUseCount ?? 0) + 1
+        }));
+    }, [queuedCommands.length]);
+    // Process queued commands when query completes and queue has items
+    const executeQueuedInput = useCallback(async (queuedCommands) => {
+        await handlePromptSubmit({
+            helpers: {
+                setCursorOffset: () => { },
+                clearBuffer: () => { },
+                resetHistory: () => { }
+            },
+            queryGuard,
+            commands,
+            onInputChange: () => { },
+            setPastedContents: () => { },
+            setToolJSX,
+            getToolUseContext,
+            messages,
+            mainLoopModel,
+            ideSelection,
+            setUserInputOnProcessing,
+            setAbortController,
+            onQuery,
+            setAppState,
+            querySource: getQuerySourceForREPL(),
+            onBeforeQuery,
+            canUseTool,
+            addNotification,
+            setMessages,
+            queuedCommands
+        });
+    }, [queryGuard, commands, setToolJSX, getToolUseContext, messages, mainLoopModel, ideSelection, setUserInputOnProcessing, canUseTool, setAbortController, onQuery, addNotification, setAppState, onBeforeQuery]);
+    useQueueProcessor({
+        executeQueuedInput,
+        hasActiveLocalJsxUI: isShowingLocalJSXCommand,
+        queryGuard
+    });
+    // We'll use the global lastInteractionTime from state.ts
+    // Update last interaction time when input changes.
+    // Must be immediate because useEffect runs after the Ink render cycle flush.
+    useEffect(() => {
+        activityManager.recordUserActivity();
+        updateLastInteractionTime(true);
+    }, [inputValue, submitCount]);
+    useEffect(() => {
+        if (submitCount === 1) {
+            startBackgroundHousekeeping();
+        }
+    }, [submitCount]);
+    // Show notification when Claude is done responding and user is idle
+    useEffect(() => {
+        // Don't set up notification if Claude is busy
+        if (isLoading)
+            return;
+        // Only enable notifications after the first new interaction in this session
+        if (submitCount === 0)
+            return;
+        // No query has completed yet
+        if (lastQueryCompletionTime === 0)
+            return;
+        // Set timeout to check idle state
+        const timer = setTimeout((lastQueryCompletionTime, isLoading, toolJSX, focusedInputDialogRef, terminal) => {
+            // Check if user has interacted since the response ended
+            const lastUserInteraction = getLastInteractionTime();
+            if (lastUserInteraction > lastQueryCompletionTime) {
+                // User has interacted since Claude finished - they're not idle, don't notify
+                return;
+            }
+            // User hasn't interacted since response ended, check other conditions
+            const idleTimeSinceResponse = Date.now() - lastQueryCompletionTime;
+            if (!isLoading && !toolJSX &&
+                // Use ref to get current dialog state, avoiding stale closure
+                focusedInputDialogRef.current === undefined && idleTimeSinceResponse >= getGlobalConfig().messageIdleNotifThresholdMs) {
+                void sendNotification({
+                    message: 'Claude is waiting for your input',
+                    notificationType: 'idle_prompt'
+                }, terminal);
+            }
+        }, getGlobalConfig().messageIdleNotifThresholdMs, lastQueryCompletionTime, isLoading, toolJSX, focusedInputDialogRef, terminal);
+        return () => clearTimeout(timer);
+    }, [isLoading, toolJSX, submitCount, lastQueryCompletionTime, terminal]);
+    // Idle-return hint: show notification when idle threshold is exceeded.
+    // Timer fires after the configured idle period; notification persists until
+    // dismissed or the user submits.
+    useEffect(() => {
+        if (lastQueryCompletionTime === 0)
+            return;
+        if (isLoading)
+            return;
+        const willowMode = getFeatureValue_CACHED_MAY_BE_STALE('tengu_willow_mode', 'off');
+        if (willowMode !== 'hint' && willowMode !== 'hint_v2')
+            return;
+        if (getGlobalConfig().idleReturnDismissed)
+            return;
+        const tokenThreshold = Number(process.env.CLAUDE_CODE_IDLE_TOKEN_THRESHOLD ?? 100_000);
+        if (getTotalInputTokens() < tokenThreshold)
+            return;
+        const idleThresholdMs = Number(process.env.CLAUDE_CODE_IDLE_THRESHOLD_MINUTES ?? 75) * 60_000;
+        const elapsed = Date.now() - lastQueryCompletionTime;
+        const remaining = idleThresholdMs - elapsed;
+        const timer = setTimeout((lqct, addNotif, msgsRef, mode, hintRef) => {
+            if (msgsRef.current.length === 0)
+                return;
+            const totalTokens = getTotalInputTokens();
+            const formattedTokens = formatTokens(totalTokens);
+            const idleMinutes = (Date.now() - lqct) / 60_000;
+            addNotif({
+                key: 'idle-return-hint',
+                jsx: mode === 'hint_v2' ? _jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "new task? " }), _jsx(Text, { color: "suggestion", children: "/clear" }), _jsx(Text, { dimColor: true, children: " to save " }), _jsxs(Text, { color: "suggestion", children: [formattedTokens, " tokens"] })] }) : _jsxs(Text, { color: "warning", children: ["new task? /clear to save ", formattedTokens, " tokens"] }),
+                priority: 'medium',
+                // Persist until submit — the hint fires at T+75min idle, user may
+                // not return for hours. removeNotification in useEffect cleanup
+                // handles dismissal. 0x7FFFFFFF = setTimeout max (~24.8 days).
+                timeoutMs: 0x7fffffff
+            });
+            hintRef.current = mode;
+            logEvent('tengu_idle_return_action', {
+                action: 'hint_shown',
+                variant: mode,
+                idleMinutes: Math.round(idleMinutes),
+                messageCount: msgsRef.current.length,
+                totalInputTokens: totalTokens
+            });
+        }, Math.max(0, remaining), lastQueryCompletionTime, addNotification, messagesRef, willowMode, idleHintShownRef);
+        return () => {
+            clearTimeout(timer);
+            removeNotification('idle-return-hint');
+            idleHintShownRef.current = false;
+        };
+    }, [lastQueryCompletionTime, isLoading, addNotification, removeNotification]);
+    // Submits incoming prompts from teammate messages or tasks mode as new turns
+    // Returns true if submission succeeded, false if a query is already running
+    const handleIncomingPrompt = useCallback((content, options) => {
+        if (queryGuard.isActive)
+            return false;
+        // Defer to user-queued commands — user input always takes priority
+        // over system messages (teammate messages, task list items, etc.)
+        // Read from the module-level store at call time (not the render-time
+        // snapshot) to avoid a stale closure — this callback's deps don't
+        // include the queue.
+        if (getCommandQueue().some(cmd => cmd.mode === 'prompt' || cmd.mode === 'bash')) {
+            return false;
+        }
+        const newAbortController = createAbortController();
+        setAbortController(newAbortController);
+        // Create a user message with the formatted content (includes XML wrapper)
+        const userMessage = createUserMessage({
+            content,
+            isMeta: options?.isMeta ? true : undefined
+        });
+        void onQuery([userMessage], newAbortController, true, [], mainLoopModel);
+        return true;
+    }, [onQuery, mainLoopModel, store]);
+    // Voice input integration (VOICE_MODE builds only)
+    const voice = feature('VOICE_MODE') ?
+        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+        useVoiceIntegration({
+            setInputValueRaw,
+            inputValueRef,
+            insertTextRef
+        }) : {
+        stripTrailing: () => 0,
+        handleKeyEvent: () => { },
+        resetAnchor: () => { },
+        interimRange: null
+    };
+    useInboxPoller({
+        enabled: isAgentSwarmsEnabled(),
+        isLoading,
+        focusedInputDialog,
+        onSubmitMessage: handleIncomingPrompt
+    });
+    useMailboxBridge({
+        isLoading,
+        onSubmitMessage: handleIncomingPrompt
+    });
+    // Scheduled tasks from .claude/scheduled_tasks.json (CronCreate/Delete/List)
+    if (feature('AGENT_TRIGGERS')) {
+        // Assistant mode bypasses the isLoading gate (the proactive tick →
+        // Sleep → tick loop would otherwise starve the scheduler).
+        // kairosEnabled is set once in initialState (main.tsx) and never mutated — no
+        // subscription needed. The tengu_kairos_cron runtime gate is checked inside
+        // useScheduledTasks's effect (not here) since wrapping a hook call in a dynamic
+        // condition would break rules-of-hooks.
+        const assistantMode = store.getState().kairosEnabled;
+        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+        useScheduledTasks({
+            isLoading,
+            assistantMode,
+            setMessages
+        });
+    }
+    // Note: Permission polling is now handled by useInboxPoller
+    // - Workers receive permission responses via mailbox messages
+    // - Leaders receive permission requests via mailbox messages
+    if ("external" === 'ant') {
+        // Tasks mode: watch for tasks and auto-process them
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds
+        useTaskListWatcher({
+            taskListId,
+            isLoading,
+            onSubmitTask: handleIncomingPrompt
+        });
+        // Loop mode: auto-tick when enabled (via /job command)
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds
+        useProactive?.({
+            // Suppress ticks while an initial message is pending — the initial
+            // message will be processed asynchronously and a premature tick would
+            // race with it, causing concurrent-query enqueue of expanded skill text.
+            isLoading: isLoading || initialMessage !== null,
+            queuedCommandsLength: queuedCommands.length,
+            hasActiveLocalJsxUI: isShowingLocalJSXCommand,
+            isInPlanMode: toolPermissionContext.mode === 'plan',
+            onSubmitTick: (prompt) => handleIncomingPrompt(prompt, {
+                isMeta: true
+            }),
+            onQueueTick: (prompt) => enqueue({
+                mode: 'prompt',
+                value: prompt,
+                isMeta: true
+            })
+        });
+    }
+    // Abort the current operation when a 'now' priority message arrives
+    // (e.g. from a chat UI client via UDS).
+    useEffect(() => {
+        if (queuedCommands.some(cmd => cmd.priority === 'now')) {
+            abortControllerRef.current?.abort('interrupt');
+        }
+    }, [queuedCommands]);
+    // Initial load
+    useEffect(() => {
+        void onInit();
+        // Cleanup on unmount
+        return () => {
+            void diagnosticTracker.shutdown();
+        };
+        // TODO: fix this
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Listen for suspend/resume events
+    const { internal_eventEmitter } = useStdin();
+    const [remountKey, setRemountKey] = useState(0);
+    useEffect(() => {
+        const handleSuspend = () => {
+            // Print suspension instructions
+            process.stdout.write(`\nContext Code has been suspended. Run \`fg\` to bring Context Code back.\nNote: ctrl + z now suspends Context Code, ctrl + _ undoes input.\n`);
+        };
+        const handleResume = () => {
+            // Force complete component tree replacement instead of terminal clear
+            // Ink now handles line count reset internally on SIGCONT
+            setRemountKey(prev => prev + 1);
+        };
+        internal_eventEmitter?.on('suspend', handleSuspend);
+        internal_eventEmitter?.on('resume', handleResume);
+        return () => {
+            internal_eventEmitter?.off('suspend', handleSuspend);
+            internal_eventEmitter?.off('resume', handleResume);
+        };
+    }, [internal_eventEmitter]);
+    // Derive stop hook spinner suffix from messages state
+    const stopHookSpinnerSuffix = useMemo(() => {
+        if (!isLoading)
+            return null;
+        // Find stop hook progress messages
+        const progressMsgs = messages.filter((m) => m.type === 'progress' && m.data.type === 'hook_progress' && (m.data.hookEvent === 'Stop' || m.data.hookEvent === 'SubagentStop'));
+        if (progressMsgs.length === 0)
+            return null;
+        // Get the most recent stop hook execution
+        const currentToolUseID = progressMsgs.at(-1)?.toolUseID;
+        if (!currentToolUseID)
+            return null;
+        // Check if there's already a summary message for this execution (hooks completed)
+        const hasSummaryForCurrentExecution = messages.some(m => m.type === 'system' && m.subtype === 'stop_hook_summary' && m.toolUseID === currentToolUseID);
+        if (hasSummaryForCurrentExecution)
+            return null;
+        const currentHooks = progressMsgs.filter(p => p.toolUseID === currentToolUseID);
+        const total = currentHooks.length;
+        // Count completed hooks
+        const completedCount = count(messages, m => {
+            if (m.type !== 'attachment')
+                return false;
+            const attachment = m.attachment;
+            return 'hookEvent' in attachment && (attachment.hookEvent === 'Stop' || attachment.hookEvent === 'SubagentStop') && 'toolUseID' in attachment && attachment.toolUseID === currentToolUseID;
+        });
+        // Check if any hook has a custom status message
+        const customMessage = currentHooks.find(p => p.data.statusMessage)?.data.statusMessage;
+        if (customMessage) {
+            // Use custom message with progress counter if multiple hooks
+            return total === 1 ? `${customMessage}…` : `${customMessage}… ${completedCount}/${total}`;
+        }
+        // Fall back to default behavior
+        const hookType = currentHooks[0]?.data.hookEvent === 'SubagentStop' ? 'subagent stop' : 'stop';
+        if ("external" === 'ant') {
+            const cmd = currentHooks[completedCount]?.data.command;
+            const label = cmd ? ` '${truncateToWidth(cmd, 40)}'` : '';
+            return total === 1 ? `running ${hookType} hook${label}` : `running ${hookType} hook${label}\u2026 ${completedCount}/${total}`;
+        }
+        return total === 1 ? `running ${hookType} hook` : `running stop hooks… ${completedCount}/${total}`;
+    }, [messages, isLoading]);
+    // Callback to capture frozen state when entering transcript mode
+    const handleEnterTranscript = useCallback(() => {
+        setFrozenTranscriptState({
+            messagesLength: messages.length,
+            streamingToolUsesLength: streamingToolUses.length
+        });
+    }, [messages.length, streamingToolUses.length]);
+    // Callback to clear frozen state when exiting transcript mode
+    const handleExitTranscript = useCallback(() => {
+        setFrozenTranscriptState(null);
+    }, []);
+    // Props for GlobalKeybindingHandlers component (rendered inside KeybindingSetup)
+    const virtualScrollActive = isFullscreenEnvEnabled() && !disableVirtualScroll;
+    // Transcript search state. Hooks must be unconditional so they live here
+    // (not inside the `if (screen === 'transcript')` branch below); isActive
+    // gates the useInput. Query persists across bar open/close so n/N keep
+    // working after Enter dismisses the bar (less semantics).
+    const jumpRef = useRef(null);
+    const [searchOpen, setSearchOpen] = useState(false);
+    const [searchQuery, setSearchQuery] = useState('');
+    const [searchCount, setSearchCount] = useState(0);
+    const [searchCurrent, setSearchCurrent] = useState(0);
+    const onSearchMatchesChange = useCallback((count, current) => {
+        setSearchCount(count);
+        setSearchCurrent(current);
+    }, []);
+    useInput((input, key, event) => {
+        if (key.ctrl || key.meta)
+            return;
+        // No Esc handling here — less has no navigating mode. Search state
+        // (highlights, n/N) is just state. Esc/q/ctrl+c → transcript:exit
+        // (ungated). Highlights clear on exit via the screen-change effect.
+        if (input === '/') {
+            // Capture scrollTop NOW — typing is a preview, 0-matches snaps
+            // back here. Synchronous ref write, fires before the bar's
+            // mount-effect calls setSearchQuery.
+            jumpRef.current?.setAnchor();
+            setSearchOpen(true);
+            event.stopImmediatePropagation();
+            return;
+        }
+        // Held-key batching: tokenizer coalesces to 'nnn'. Same uniform-batch
+        // pattern as modalPagerAction in ScrollKeybindingHandler.tsx. Each
+        // repeat is a step (n isn't idempotent like g).
+        const c = input[0];
+        if ((c === 'n' || c === 'N') && input === c.repeat(input.length) && searchCount > 0) {
+            const fn = c === 'n' ? jumpRef.current?.nextMatch : jumpRef.current?.prevMatch;
+            if (fn)
+                for (let i = 0; i < input.length; i++)
+                    fn();
+            event.stopImmediatePropagation();
+        }
+    }, 
+    // Search needs virtual scroll (jumpRef drives VirtualMessageList). [
+    // kills it, so !dumpMode — after [ there's nothing to jump in.
+    {
+        isActive: screen === 'transcript' && virtualScrollActive && !searchOpen && !dumpMode
+    });
+    const { setQuery: setHighlight, scanElement, setPositions } = useSearchHighlight();
+    // Resize → abort search. Positions are (msg, query, WIDTH)-keyed —
+    // cached positions are stale after a width change (new layout, new
+    // wrapping). Clearing searchQuery triggers VML's setSearchQuery('')
+    // which clears positionsCache + setPositions(null). Bar closes.
+    // User hits / again → fresh everything.
+    const transcriptCols = useTerminalSize().columns;
+    const prevColsRef = React.useRef(transcriptCols);
+    React.useEffect(() => {
+        if (prevColsRef.current !== transcriptCols) {
+            prevColsRef.current = transcriptCols;
+            if (searchQuery || searchOpen) {
+                setSearchOpen(false);
+                setSearchQuery('');
+                setSearchCount(0);
+                setSearchCurrent(0);
+                jumpRef.current?.disarmSearch();
+                setHighlight('');
+            }
+        }
+    }, [transcriptCols, searchQuery, searchOpen, setHighlight]);
+    // Transcript escape hatches. Bare letters in modal context (no prompt
+    // competing for input) — same class as g/G/j/k in ScrollKeybindingHandler.
+    useInput((input, key, event) => {
+        if (key.ctrl || key.meta)
+            return;
+        if (input === 'q') {
+            // less: q quits the pager. ctrl+o toggles; q is the lineage exit.
+            handleExitTranscript();
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (input === '[' && !dumpMode) {
+            // Force dump-to-scrollback. Also expand + uncap — no point dumping
+            // a subset. Terminal/tmux cmd-F can now find anything. Guard here
+            // (not in isActive) so v still works post-[ — dump-mode footer at
+            // ~4898 wires editorStatus, confirming v is meant to stay live.
+            setDumpMode(true);
+            setShowAllInTranscript(true);
+            event.stopImmediatePropagation();
+        }
+        else if (input === 'v') {
+            // less-style: v opens the file in $VISUAL/$EDITOR. Render the full
+            // transcript (same path /export uses), write to tmp, hand off.
+            // openFileInExternalEditor handles alt-screen suspend/resume for
+            // terminal editors; GUI editors spawn detached.
+            event.stopImmediatePropagation();
+            // Drop double-taps: the render is async and a second press before it
+            // completes would run a second parallel render (double memory, two
+            // tempfiles, two editor spawns). editorGenRef only guards
+            // transcript-exit staleness, not same-session concurrency.
+            if (editorRenderingRef.current)
+                return;
+            editorRenderingRef.current = true;
+            // Capture generation + make a staleness-aware setter. Each write
+            // checks gen (transcript exit bumps it → late writes from the
+            // async render go silent).
+            const gen = editorGenRef.current;
+            const setStatus = (s) => {
+                if (gen !== editorGenRef.current)
+                    return;
+                clearTimeout(editorTimerRef.current);
+                setEditorStatus(s);
+            };
+            setStatus(`rendering ${deferredMessages.length} messages…`);
+            void (async () => {
+                try {
+                    // Width = terminal minus vim's line-number gutter (4 digits +
+                    // space + slack). Floor at 80. PassThrough has no .columns so
+                    // without this Ink defaults to 80. Trailing-space strip: right-
+                    // aligned timestamps still leave a flexbox spacer run at EOL.
+                    // eslint-disable-next-line custom-rules/prefer-use-terminal-size -- one-shot at keypress time, not a reactive render dep
+                    const w = Math.max(80, (process.stdout.columns ?? 80) - 6);
+                    const raw = await renderMessagesToPlainText(deferredMessages, tools, w);
+                    const text = raw.replace(/[ \t]+$/gm, '');
+                    const path = join(tmpdir(), `cc-transcript-${Date.now()}.txt`);
+                    await writeFile(path, text);
+                    const opened = openFileInExternalEditor(path);
+                    setStatus(opened ? `opening ${path}` : `wrote ${path} · no $VISUAL/$EDITOR set`);
+                }
+                catch (e) {
+                    setStatus(`render failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                editorRenderingRef.current = false;
+                if (gen !== editorGenRef.current)
+                    return;
+                editorTimerRef.current = setTimeout(s => s(''), 4000, setEditorStatus);
+            })();
+        }
+    }, 
+    // !searchOpen: typing 'v' or '[' in the search bar is search input, not
+    // a command. No !dumpMode here — v should work after [ (the [ handler
+    // guards itself inline).
+    {
+        isActive: screen === 'transcript' && virtualScrollActive && !searchOpen
+    });
+    // Fresh `less` per transcript entry. Prevents stale highlights matching
+    // unrelated normal-mode text (overlay is alt-screen-global) and avoids
+    // surprise n/N on re-entry. Same exit resets [ dump mode — each ctrl+o
+    // entry is a fresh instance.
+    const inTranscript = screen === 'transcript' && virtualScrollActive;
+    useEffect(() => {
+        if (!inTranscript) {
+            setSearchQuery('');
+            setSearchCount(0);
+            setSearchCurrent(0);
+            setSearchOpen(false);
+            editorGenRef.current++;
+            clearTimeout(editorTimerRef.current);
+            setDumpMode(false);
+            setEditorStatus('');
+        }
+    }, [inTranscript]);
+    useEffect(() => {
+        setHighlight(inTranscript ? searchQuery : '');
+        // Clear the position-based CURRENT (yellow) overlay too. setHighlight
+        // only clears the scan-based inverse. Without this, the yellow box
+        // persists at its last screen coords after ctrl-c exits transcript.
+        if (!inTranscript)
+            setPositions(null);
+    }, [inTranscript, searchQuery, setHighlight, setPositions]);
+    const globalKeybindingProps = {
+        screen,
+        setScreen,
+        showAllInTranscript,
+        setShowAllInTranscript,
+        messageCount: messages.length,
+        onEnterTranscript: handleEnterTranscript,
+        onExitTranscript: handleExitTranscript,
+        virtualScrollActive,
+        // Bar-open is a mode (owns keystrokes — j/k type, Esc cancels).
+        // Navigating (query set, bar closed) is NOT — Esc exits transcript,
+        // same as less q with highlights still visible. useSearchInput
+        // doesn't stopPropagation, so without this gate transcript:exit
+        // would fire on the same Esc that cancels the bar (child registers
+        // first, fires first, bubbles).
+        searchBarOpen: searchOpen
+    };
+    // Use frozen lengths to slice arrays, avoiding memory overhead of cloning
+    const transcriptMessages = frozenTranscriptState ? deferredMessages.slice(0, frozenTranscriptState.messagesLength) : deferredMessages;
+    const transcriptStreamingToolUses = frozenTranscriptState ? streamingToolUses.slice(0, frozenTranscriptState.streamingToolUsesLength) : streamingToolUses;
+    // Handle shift+down for teammate navigation and background task management.
+    // Guard onOpenBackgroundTasks when a local-jsx dialog (e.g. /mcp) is open —
+    // otherwise Shift+Down stacks BackgroundTasksDialog on top and deadlocks input.
+    useBackgroundTaskNavigation({
+        onOpenBackgroundTasks: isShowingLocalJSXCommand ? undefined : () => setShowBashesDialog(true)
+    });
+    // Auto-exit viewing mode when teammate completes or errors
+    useTeammateViewAutoExit();
+    if (screen === 'transcript') {
+        // Virtual scroll replaces the 30-message cap: everything is scrollable
+        // and memory is bounded by the viewport. Without it, wrapping transcript
+        // in a ScrollBox would mount all messages (~250 MB on long sessions —
+        // the exact problem), so the kill switch and non-fullscreen paths must
+        // fall through to the legacy render: no alt screen, dump to terminal
+        // scrollback, 30-cap + Ctrl+E. Reusing scrollRef is safe — normal-mode
+        // and transcript-mode are mutually exclusive (this early return), so
+        // only one ScrollBox is ever mounted at a time.
+        const transcriptScrollRef = isFullscreenEnvEnabled() && !disableVirtualScroll && !dumpMode ? scrollRef : undefined;
+        const transcriptMessagesElement = _jsx(Messages, { messages: transcriptMessages, tools: tools, commands: commands, verbose: true, toolJSX: null, toolUseConfirmQueue: [], inProgressToolUseIDs: inProgressToolUseIDs, isMessageSelectorVisible: false, conversationId: conversationId, screen: screen, agentDefinitions: agentDefinitions, streamingToolUses: transcriptStreamingToolUses, showAllInTranscript: showAllInTranscript, onOpenRateLimitOptions: handleOpenRateLimitOptions, isLoading: isLoading, hidePastThinking: true, streamingThinking: streamingThinking, scrollRef: transcriptScrollRef, jumpRef: jumpRef, onSearchMatchesChange: onSearchMatchesChange, scanElement: scanElement, setPositions: setPositions, disableRenderCap: dumpMode });
+        const transcriptToolJSX = toolJSX && _jsx(Box, { flexDirection: "column", width: "100%", children: toolJSX.jsx });
+        const transcriptReturn = _jsxs(KeybindingSetup, { children: [_jsx(AnimatedTerminalTitle, { isAnimating: titleIsAnimating, title: terminalTitle, disabled: titleDisabled, noPrefix: showStatusInTerminalTab }), _jsx(GlobalKeybindingHandlers, { ...globalKeybindingProps }), feature('VOICE_MODE') ? _jsx(VoiceKeybindingHandler, { voiceHandleKeyEvent: voice.handleKeyEvent, stripTrailing: voice.stripTrailing, resetAnchor: voice.resetAnchor, isActive: !toolJSX?.isLocalJSXCommand }) : null, _jsx(CommandKeybindingHandlers, { onSubmit: onSubmit, isActive: !toolJSX?.isLocalJSXCommand }), transcriptScrollRef ?
+                    _jsx(ScrollKeybindingHandler, { scrollRef: scrollRef, 
+                        // Yield wheel/ctrl+u/d to UltraplanChoiceDialog's own scroll
+                        // handler while the modal is showing.
+                        isActive: focusedInputDialog !== 'ultraplan-choice', 
+                        // g/G/j/k/ctrl+u/ctrl+d would eat keystrokes the search bar
+                        // wants. Off while searching.
+                        isModal: !searchOpen, 
+                        // Manual scroll exits the search context — clear the yellow
+                        // current-match marker. Positions are (msg, rowOffset)-keyed;
+                        // j/k changes scrollTop so rowOffset is stale → wrong row
+                        // gets yellow. Next n/N re-establishes via step()→jump().
+                        onScroll: () => jumpRef.current?.disarmSearch() }) : null, _jsx(CancelRequestHandler, { ...cancelRequestProps }), transcriptScrollRef ? _jsx(FullscreenLayout, { scrollRef: scrollRef, scrollable: _jsxs(_Fragment, { children: [transcriptMessagesElement, transcriptToolJSX, _jsx(SandboxViolationExpandedView, {})] }), bottom: searchOpen ? _jsx(TranscriptSearchBar, { jumpRef: jumpRef, 
+                        // Seed was tried (c01578c8) — broke /hello muscle
+                        // memory (cursor lands after 'foo', /hello → foohello).
+                        // Cancel-restore handles the 'don't lose prior search'
+                        // concern differently (onCancel re-applies searchQuery).
+                        initialQuery: "", count: searchCount, current: searchCurrent, onClose: q => {
+                            // Enter — commit. 0-match guard: junk query shouldn't
+                            // persist (badge hidden, n/N dead anyway).
+                            setSearchQuery(searchCount > 0 ? q : '');
+                            setSearchOpen(false);
+                            // onCancel path: bar unmounts before its useEffect([query])
+                            // can fire with ''. Without this, searchCount stays stale
+                            // (n guard at :4956 passes) and VML's matches[] too
+                            // (nextMatch walks the old array). Phantom nav, no
+                            // highlight. onExit (Enter, q non-empty) still commits.
+                            if (!q) {
+                                setSearchCount(0);
+                                setSearchCurrent(0);
+                                jumpRef.current?.setSearchQuery('');
+                            }
+                        }, onCancel: () => {
+                            // Esc/ctrl+c/ctrl+g — undo. Bar's effect last fired
+                            // with whatever was typed. searchQuery (REPL state)
+                            // is unchanged since / (onClose = commit, didn't run).
+                            // Two VML calls: '' restores anchor (0-match else-
+                            // branch), then searchQuery re-scans from anchor's
+                            // nearest. Both synchronous — one React batch.
+                            // setHighlight explicit: REPL's sync-effect dep is
+                            // searchQuery (unchanged), wouldn't re-fire.
+                            setSearchOpen(false);
+                            jumpRef.current?.setSearchQuery('');
+                            jumpRef.current?.setSearchQuery(searchQuery);
+                            setHighlight(searchQuery);
+                        }, setHighlight: setHighlight }) : _jsx(TranscriptModeFooter, { showAllInTranscript: showAllInTranscript, virtualScroll: true, status: editorStatus || undefined, searchBadge: searchQuery && searchCount > 0 ? {
+                            current: searchCurrent,
+                            count: searchCount
+                        } : undefined }) }) : _jsxs(_Fragment, { children: [transcriptMessagesElement, transcriptToolJSX, _jsx(SandboxViolationExpandedView, {}), _jsx(TranscriptModeFooter, { showAllInTranscript: showAllInTranscript, virtualScroll: false, suppressShowAll: dumpMode, status: editorStatus || undefined })] })] });
+        // The virtual-scroll branch (FullscreenLayout above) needs
+        // <AlternateScreen>'s <Box height={rows}> constraint — without it,
+        // ScrollBox's flexGrow has no ceiling, viewport = content height,
+        // scrollTop pins at 0, and Ink's screen buffer sizes to the full
+        // spacer (200×5k+ rows on long sessions). Same root type + props as
+        // normal mode's wrap below so React reconciles and the alt buffer
+        // stays entered across toggle. The 30-cap dump branch stays
+        // unwrapped — it wants native terminal scrollback.
+        if (transcriptScrollRef) {
+            return _jsx(AlternateScreen, { mouseTracking: isMouseTrackingEnabled(), children: transcriptReturn });
+        }
+        return transcriptReturn;
+    }
+    // Get viewed agent task (inlined from selectors for explicit data flow).
+    // viewedAgentTask: teammate OR local_agent — drives the boolean checks
+    // below. viewedTeammateTask: teammate-only narrowed, for teammate-specific
+    // field access (inProgressToolUseIDs).
+    const viewedTask = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined;
+    const viewedTeammateTask = viewedTask && isInProcessTeammateTask(viewedTask) ? viewedTask : undefined;
+    const viewedAgentTask = viewedTeammateTask ?? (viewedTask && isLocalAgentTask(viewedTask) ? viewedTask : undefined);
+    // Bypass useDeferredValue when streaming text is showing so Messages renders
+    // the final message in the same frame streaming text clears. Also bypass when
+    // not loading — deferredMessages only matters during streaming (keeps input
+    // responsive); after the turn ends, showing messages immediately prevents a
+    // jitter gap where the spinner is gone but the answer hasn't appeared yet.
+    // Only reducedMotion users keep the deferred path during loading.
+    const usesSyncMessages = showStreamingText || !isLoading;
+    // When viewing an agent, never fall through to leader — empty until
+    // bootstrap/stream fills. Closes the see-leader-type-agent footgun.
+    const displayedMessages = viewedAgentTask ? viewedAgentTask.messages ?? [] : usesSyncMessages ? messages : deferredMessages;
+    // Show the placeholder until the real user message appears in
+    // displayedMessages. userInputOnProcessing stays set for the whole turn
+    // (cleared in resetLoadingState); this length check hides it once
+    // displayedMessages grows past the baseline captured at submit time.
+    // Covers both gaps: before setMessages is called (processUserInput), and
+    // while deferredMessages lags behind messages. Suppressed when viewing an
+    // agent — displayedMessages is a different array there, and onAgentSubmit
+    // doesn't use the placeholder anyway.
+    const placeholderText = userInputOnProcessing && !viewedAgentTask && displayedMessages.length <= userInputBaselineRef.current ? userInputOnProcessing : undefined;
+    const toolPermissionOverlay = focusedInputDialog === 'tool-permission' ? _jsx(PermissionRequest, { onDone: () => setToolUseConfirmQueue(([_, ...tail]) => tail), onReject: handleQueuedCommandOnCancel, toolUseConfirm: toolUseConfirmQueue[0], toolUseContext: getToolUseContext(messages, messages, abortController ?? createAbortController(), mainLoopModel), verbose: verbose, workerBadge: toolUseConfirmQueue[0]?.workerBadge, setStickyFooter: isFullscreenEnvEnabled() ? setPermissionStickyFooter : undefined }, toolUseConfirmQueue[0]?.toolUseID) : null;
+    // Narrow terminals: companion collapses to a one-liner that REPL stacks
+    // on its own row (above input in fullscreen, below in scrollback) instead
+    // of row-beside. Wide terminals keep the row layout with sprite on the right.
+    const companionNarrow = transcriptCols < MIN_COLS_FOR_FULL_SPRITE;
+    // Hide the sprite when PromptInput early-returns BackgroundTasksDialog.
+    // The sprite sits as a row sibling of PromptInput, so the dialog's Pane
+    // divider draws at useTerminalSize() width but only gets terminalWidth -
+    // spriteWidth — divider stops short and dialog text wraps early. Don't
+    // check footerSelection: pill FOCUS (arrow-down to tasks pill) must keep
+    // the sprite visible so arrow-right can navigate to it.
+    const companionVisible = !toolJSX?.shouldHidePromptInput && !focusedInputDialog && !showBashesDialog;
+    // In fullscreen, ALL local-jsx slash commands float in the modal slot —
+    // FullscreenLayout wraps them in an absolute-positioned bottom-anchored
+    // pane (▔ divider, ModalContext). Pane/Dialog inside detect the context
+    // and skip their own top-level frame. Non-fullscreen keeps the inline
+    // render paths below. Commands that used to route through bottom
+    // (immediate: /model, /mcp, /btw, ...) and scrollable (non-immediate:
+    // /config, /theme, /diff, ...) both go here now.
+    const toolJsxCentered = isFullscreenEnvEnabled() && toolJSX?.isLocalJSXCommand === true;
+    const centeredModal = toolJsxCentered ? toolJSX.jsx : null;
+    // <AlternateScreen> at the root: everything below is inside its
+    // <Box height={rows}>. Handlers/contexts are zero-height so ScrollBox's
+    // flexGrow in FullscreenLayout resolves against this Box. The transcript
+    // early return above wraps its virtual-scroll branch the same way; only
+    // the 30-cap dump branch stays unwrapped for native terminal scrollback.
+    const mainReturn = _jsxs(KeybindingSetup, { children: [_jsx(AnimatedTerminalTitle, { isAnimating: titleIsAnimating, title: terminalTitle, disabled: titleDisabled, noPrefix: showStatusInTerminalTab }), _jsx(GlobalKeybindingHandlers, { ...globalKeybindingProps }), feature('VOICE_MODE') ? _jsx(VoiceKeybindingHandler, { voiceHandleKeyEvent: voice.handleKeyEvent, stripTrailing: voice.stripTrailing, resetAnchor: voice.resetAnchor, isActive: !toolJSX?.isLocalJSXCommand }) : null, _jsx(CommandKeybindingHandlers, { onSubmit: onSubmit, isActive: !toolJSX?.isLocalJSXCommand }), _jsx(ScrollKeybindingHandler, { scrollRef: scrollRef, isActive: isFullscreenEnvEnabled() && (centeredModal != null || !focusedInputDialog || focusedInputDialog === 'tool-permission'), onScroll: centeredModal || toolPermissionOverlay || viewedAgentTask ? undefined : composedOnScroll }), feature('MESSAGE_ACTIONS') && isFullscreenEnvEnabled() && !disableMessageActions ? _jsx(MessageActionsKeybindings, { handlers: messageActionHandlers, isActive: cursor !== null }) : null, _jsx(CancelRequestHandler, { ...cancelRequestProps }), _jsx(MCPConnectionManager, { dynamicMcpConfig: dynamicMcpConfig, isStrictMcpConfig: strictMcpConfig, children: _jsx(FullscreenLayout, { scrollRef: scrollRef, overlay: toolPermissionOverlay, bottomFloat: feature('BUDDY') && companionVisible && !companionNarrow ? _jsx(CompanionFloatingBubble, {}) : undefined, modal: centeredModal, modalScrollRef: modalScrollRef, dividerYRef: dividerYRef, hidePill: !!viewedAgentTask, hideSticky: !!viewedTeammateTask, newMessageCount: unseenDivider?.count ?? 0, onPillClick: () => {
+                        setCursor(null);
+                        jumpToNew(scrollRef.current);
+                    }, scrollable: _jsxs(_Fragment, { children: [_jsx(TeammateViewHeader, {}), _jsx(Messages, { messages: displayedMessages, tools: tools, commands: commands, verbose: verbose, toolJSX: toolJSX, toolUseConfirmQueue: toolUseConfirmQueue, inProgressToolUseIDs: viewedTeammateTask ? viewedTeammateTask.inProgressToolUseIDs ?? new Set() : inProgressToolUseIDs, isMessageSelectorVisible: isMessageSelectorVisible, conversationId: conversationId, screen: screen, streamingToolUses: streamingToolUses, showAllInTranscript: showAllInTranscript, agentDefinitions: agentDefinitions, onOpenRateLimitOptions: handleOpenRateLimitOptions, isLoading: isLoading, streamingText: isLoading && !viewedAgentTask ? visibleStreamingText : null, isBriefOnly: viewedAgentTask ? false : isBriefOnly, unseenDivider: viewedAgentTask ? undefined : unseenDivider, scrollRef: isFullscreenEnvEnabled() ? scrollRef : undefined, trackStickyPrompt: isFullscreenEnvEnabled() ? true : undefined, cursor: cursor, setCursor: setCursor, cursorNavRef: cursorNavRef }), _jsx(AwsAuthStatusBox, {}), !disabled && placeholderText && !centeredModal && _jsx(UserTextMessage, { param: {
+                                    text: placeholderText,
+                                    type: 'text'
+                                }, addMargin: true, verbose: verbose }), toolJSX && !(toolJSX.isLocalJSXCommand && toolJSX.isImmediate) && !toolJsxCentered && _jsx(Box, { flexDirection: "column", width: "100%", children: toolJSX.jsx }), "external" === 'ant' && _jsx(TungstenLiveMonitor, {}), feature('WEB_BROWSER_TOOL') ? WebBrowserPanelModule && _jsx(WebBrowserPanelModule.WebBrowserPanel, {}) : null, _jsx(Box, { flexGrow: 1 }), showSpinner && _jsx(SpinnerWithVerb, { mode: streamMode, spinnerTip: spinnerTip, responseLengthRef: responseLengthRef, apiMetricsRef: apiMetricsRef, overrideMessage: spinnerMessage, spinnerSuffix: stopHookSpinnerSuffix, verbose: verbose, loadingStartTimeRef: loadingStartTimeRef, totalPausedMsRef: totalPausedMsRef, pauseStartTimeRef: pauseStartTimeRef, overrideColor: spinnerColor, overrideShimmerColor: spinnerShimmerColor, hasActiveTools: inProgressToolUseIDs.size > 0, leaderIsIdle: !isLoading }), !showSpinner && !isLoading && !userInputOnProcessing && !hasRunningTeammates && isBriefOnly && !viewedAgentTask && _jsx(BriefIdleStatus, {}), isFullscreenEnvEnabled() && _jsx(PromptInputQueuedCommands, {})] }), bottom: _jsxs(Box, { flexDirection: feature('BUDDY') && companionNarrow ? 'column' : 'row', width: "100%", alignItems: feature('BUDDY') && companionNarrow ? undefined : 'flex-end', children: [feature('BUDDY') && companionNarrow && isFullscreenEnvEnabled() && companionVisible ? _jsx(CompanionSprite, {}) : null, _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [permissionStickyFooter, toolJSX?.isLocalJSXCommand && toolJSX.isImmediate && !toolJsxCentered && _jsx(Box, { flexDirection: "column", width: "100%", children: toolJSX.jsx }), !showSpinner && !toolJSX?.isLocalJSXCommand && showExpandedTodos && tasksV2 && tasksV2.length > 0 && _jsx(Box, { width: "100%", flexDirection: "column", children: _jsx(TaskListV2, { tasks: tasksV2, isStandalone: true }) }), focusedInputDialog === 'sandbox-permission' && _jsx(SandboxPermissionRequest, { hostPattern: sandboxPermissionRequestQueue[0].hostPattern, onUserResponse: (response) => {
+                                            const { allow, persistToSettings } = response;
+                                            const currentRequest = sandboxPermissionRequestQueue[0];
+                                            if (!currentRequest)
+                                                return;
+                                            const approvedHost = currentRequest.hostPattern.host;
+                                            if (persistToSettings) {
+                                                const update = {
+                                                    type: 'addRules',
+                                                    rules: [{
+                                                            toolName: WEB_FETCH_TOOL_NAME,
+                                                            ruleContent: `domain:${approvedHost}`
+                                                        }],
+                                                    behavior: (allow ? 'allow' : 'deny'),
+                                                    destination: 'localSettings'
+                                                };
+                                                setAppState(prev => ({
+                                                    ...prev,
+                                                    toolPermissionContext: applyPermissionUpdate(prev.toolPermissionContext, update)
+                                                }));
+                                                persistPermissionUpdate(update);
+                                                // Immediately update sandbox in-memory config to prevent race conditions
+                                                // where pending requests slip through before settings change is detected
+                                                SandboxManager.refreshConfig();
+                                            }
+                                            // Resolve ALL pending requests for the same host (not just the first one)
+                                            // This handles the case where multiple parallel requests came in for the same domain
+                                            setSandboxPermissionRequestQueue(queue => {
+                                                queue.filter(item => item.hostPattern.host === approvedHost).forEach(item => item.resolvePromise(allow));
+                                                return queue.filter(item => item.hostPattern.host !== approvedHost);
+                                            });
+                                            // Clean up bridge subscriptions and cancel remote prompts
+                                            // for this host since the local user already responded.
+                                            const cleanups = sandboxBridgeCleanupRef.current.get(approvedHost);
+                                            if (cleanups) {
+                                                for (const fn of cleanups) {
+                                                    fn();
+                                                }
+                                                sandboxBridgeCleanupRef.current.delete(approvedHost);
+                                            }
+                                        } }, sandboxPermissionRequestQueue[0].hostPattern.host), focusedInputDialog === 'prompt' && _jsx(PromptDialog, { title: promptQueue[0].title, toolInputSummary: promptQueue[0].toolInputSummary, request: promptQueue[0].request, onRespond: selectedKey => {
+                                            const item = promptQueue[0];
+                                            if (!item)
+                                                return;
+                                            item.resolve({
+                                                prompt_response: item.request.prompt,
+                                                selected: selectedKey
+                                            });
+                                            setPromptQueue(([, ...tail]) => tail);
+                                        }, onAbort: () => {
+                                            const item = promptQueue[0];
+                                            if (!item)
+                                                return;
+                                            item.reject(new Error('Prompt cancelled by user'));
+                                            setPromptQueue(([, ...tail]) => tail);
+                                        } }, promptQueue[0].request.prompt), pendingWorkerRequest && _jsx(WorkerPendingPermission, { toolName: pendingWorkerRequest.toolName, description: pendingWorkerRequest.description }), pendingSandboxRequest && _jsx(WorkerPendingPermission, { toolName: "Network Access", description: `Waiting for leader to approve network access to ${pendingSandboxRequest.host}` }), focusedInputDialog === 'worker-sandbox-permission' && _jsx(SandboxPermissionRequest, { hostPattern: {
+                                            host: workerSandboxPermissions.queue[0].host,
+                                            port: undefined
+                                        }, onUserResponse: (response) => {
+                                            const { allow, persistToSettings } = response;
+                                            const currentRequest = workerSandboxPermissions.queue[0];
+                                            if (!currentRequest)
+                                                return;
+                                            const approvedHost = currentRequest.host;
+                                            // Send response via mailbox to the worker
+                                            void sendSandboxPermissionResponseViaMailbox(currentRequest.workerName, currentRequest.requestId, approvedHost, allow, teamContext?.teamName);
+                                            if (persistToSettings && allow) {
+                                                const update = {
+                                                    type: 'addRules',
+                                                    rules: [{
+                                                            toolName: WEB_FETCH_TOOL_NAME,
+                                                            ruleContent: `domain:${approvedHost}`
+                                                        }],
+                                                    behavior: 'allow',
+                                                    destination: 'localSettings'
+                                                };
+                                                setAppState(prev => ({
+                                                    ...prev,
+                                                    toolPermissionContext: applyPermissionUpdate(prev.toolPermissionContext, update)
+                                                }));
+                                                persistPermissionUpdate(update);
+                                                SandboxManager.refreshConfig();
+                                            }
+                                            // Remove from queue
+                                            setAppState(prev => ({
+                                                ...prev,
+                                                workerSandboxPermissions: {
+                                                    ...prev.workerSandboxPermissions,
+                                                    queue: prev.workerSandboxPermissions.queue.slice(1)
+                                                }
+                                            }));
+                                        } }, workerSandboxPermissions.queue[0].requestId), focusedInputDialog === 'elicitation' && _jsx(ElicitationDialog, { event: elicitation.queue[0], onResponse: (action, content) => {
+                                            const currentRequest = elicitation.queue[0];
+                                            if (!currentRequest)
+                                                return;
+                                            // Call respond callback to resolve Promise
+                                            currentRequest.respond({
+                                                action,
+                                                content
+                                            });
+                                            // For URL accept, keep in queue for phase 2
+                                            const isUrlAccept = currentRequest.params.mode === 'url' && action === 'accept';
+                                            if (!isUrlAccept) {
+                                                setAppState(prev => ({
+                                                    ...prev,
+                                                    elicitation: {
+                                                        queue: prev.elicitation.queue.slice(1)
+                                                    }
+                                                }));
+                                            }
+                                        }, onWaitingDismiss: action => {
+                                            const currentRequest = elicitation.queue[0];
+                                            // Remove from queue
+                                            setAppState(prev => ({
+                                                ...prev,
+                                                elicitation: {
+                                                    queue: prev.elicitation.queue.slice(1)
+                                                }
+                                            }));
+                                            currentRequest?.onWaitingDismiss?.(action);
+                                        } }, elicitation.queue[0].serverName + ':' + String(elicitation.queue[0].requestId)), focusedInputDialog === 'cost' && _jsx(CostThresholdDialog, { onDone: () => {
+                                            setShowCostDialog(false);
+                                            setHaveShownCostDialog(true);
+                                            saveGlobalConfig(current => ({
+                                                ...current,
+                                                hasAcknowledgedCostThreshold: true
+                                            }));
+                                            logEvent('tengu_cost_threshold_acknowledged', {});
+                                        } }), focusedInputDialog === 'idle-return' && idleReturnPending && _jsx(IdleReturnDialog, { idleMinutes: idleReturnPending.idleMinutes, totalInputTokens: getTotalInputTokens(), onDone: async (action) => {
+                                            const pending = idleReturnPending;
+                                            setIdleReturnPending(null);
+                                            logEvent('tengu_idle_return_action', {
+                                                action: action,
+                                                idleMinutes: Math.round(pending.idleMinutes),
+                                                messageCount: messagesRef.current.length,
+                                                totalInputTokens: getTotalInputTokens()
+                                            });
+                                            if (action === 'dismiss') {
+                                                setInputValue(pending.input);
+                                                return;
+                                            }
+                                            if (action === 'never') {
+                                                saveGlobalConfig(current => {
+                                                    if (current.idleReturnDismissed)
+                                                        return current;
+                                                    return {
+                                                        ...current,
+                                                        idleReturnDismissed: true
+                                                    };
+                                                });
+                                            }
+                                            if (action === 'clear') {
+                                                const { clearConversation } = await import('../commands/clear/conversation.js');
+                                                await clearConversation({
+                                                    setMessages,
+                                                    readFileState: readFileState.current,
+                                                    discoveredSkillNames: discoveredSkillNamesRef.current,
+                                                    loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,
+                                                    getAppState: () => store.getState(),
+                                                    setAppState,
+                                                    setConversationId
+                                                });
+                                                haikuTitleAttemptedRef.current = false;
+                                                setHaikuTitle(undefined);
+                                                bashTools.current.clear();
+                                                bashToolsProcessedIdx.current = 0;
+                                            }
+                                            skipIdleCheckRef.current = true;
+                                            void onSubmitRef.current(pending.input, {
+                                                setCursorOffset: () => { },
+                                                clearBuffer: () => { },
+                                                resetHistory: () => { }
+                                            });
+                                        } }), focusedInputDialog === 'ide-onboarding' && _jsx(IdeOnboardingDialog, { onDone: () => setShowIdeOnboarding(false), installationStatus: ideInstallationStatus }), "external" === 'ant' && focusedInputDialog === 'model-switch' && AntModelSwitchCallout && _jsx(AntModelSwitchCallout, { onDone: (selection, modelAlias) => {
+                                            setShowModelSwitchCallout(false);
+                                            if (selection === 'switch' && modelAlias) {
+                                                setAppState(prev => ({
+                                                    ...prev,
+                                                    mainLoopModel: modelAlias,
+                                                    mainLoopModelForSession: null
+                                                }));
+                                            }
+                                        } }), "external" === 'ant' && focusedInputDialog === 'undercover-callout' && UndercoverAutoCallout && _jsx(UndercoverAutoCallout, { onDone: () => setShowUndercoverCallout(false) }), focusedInputDialog === 'effort-callout' && _jsx(EffortCallout, { model: mainLoopModel, onDone: selection => {
+                                            setShowEffortCallout(false);
+                                            if (selection !== 'dismiss') {
+                                                setAppState(prev => ({
+                                                    ...prev,
+                                                    effortValue: selection
+                                                }));
+                                            }
+                                        } }), focusedInputDialog === 'remote-callout' && _jsx(RemoteCallout, { onDone: selection => {
+                                            setAppState(prev => {
+                                                if (!prev.showRemoteCallout)
+                                                    return prev;
+                                                return {
+                                                    ...prev,
+                                                    showRemoteCallout: false,
+                                                    ...(selection === 'enable' && {
+                                                        replBridgeEnabled: true,
+                                                        replBridgeExplicit: true,
+                                                        replBridgeOutboundOnly: false
+                                                    })
+                                                };
+                                            });
+                                        } }), exitFlow, focusedInputDialog === 'plugin-hint' && hintRecommendation && _jsx(PluginHintMenu, { pluginName: hintRecommendation.pluginName, pluginDescription: hintRecommendation.pluginDescription, marketplaceName: hintRecommendation.marketplaceName, sourceCommand: hintRecommendation.sourceCommand, onResponse: handleHintResponse }), focusedInputDialog === 'lsp-recommendation' && lspRecommendation && _jsx(LspRecommendationMenu, { pluginName: lspRecommendation.pluginName, pluginDescription: lspRecommendation.pluginDescription, fileExtension: lspRecommendation.fileExtension, onResponse: handleLspResponse }), focusedInputDialog === 'desktop-upsell' && _jsx(DesktopUpsellStartup, { onDone: () => setShowDesktopUpsellStartup(false) }), feature('ULTRAPLAN') ? focusedInputDialog === 'ultraplan-choice' && ultraplanPendingChoice && _jsx(UltraplanChoiceDialog, { plan: ultraplanPendingChoice.plan, sessionId: ultraplanPendingChoice.sessionId, taskId: ultraplanPendingChoice.taskId, setMessages: setMessages, readFileState: readFileState.current, getAppState: () => store.getState(), setConversationId: setConversationId }) : null, feature('ULTRAPLAN') ? focusedInputDialog === 'ultraplan-launch' && ultraplanLaunchPending && _jsx(UltraplanLaunchDialog, { onChoice: (choice, opts) => {
+                                            const blurb = ultraplanLaunchPending.blurb;
+                                            setAppState(prev => prev.ultraplanLaunchPending ? {
+                                                ...prev,
+                                                ultraplanLaunchPending: undefined
+                                            } : prev);
+                                            if (choice === 'cancel')
+                                                return;
+                                            // Command's onDone used display:'skip', so add the
+                                            // echo here — gives immediate feedback before the
+                                            // ~5s teleportToRemote resolves.
+                                            setMessages(prev => [...prev, createCommandInputMessage(formatCommandInputTags('ultraplan', blurb))]);
+                                            const appendStdout = (msg) => setMessages(prev => [...prev, createCommandInputMessage(`<${LOCAL_COMMAND_STDOUT_TAG}>${escapeXml(msg)}</${LOCAL_COMMAND_STDOUT_TAG}>`)]);
+                                            // Defer the second message if a query is mid-turn
+                                            // so it lands after the assistant reply, not
+                                            // between the user's prompt and the reply.
+                                            const appendWhenIdle = (msg) => {
+                                                if (!queryGuard.isActive) {
+                                                    appendStdout(msg);
+                                                    return;
+                                                }
+                                                const unsub = queryGuard.subscribe(() => {
+                                                    if (queryGuard.isActive)
+                                                        return;
+                                                    unsub();
+                                                    // Skip if the user stopped ultraplan while we
+                                                    // were waiting — avoids a stale "Monitoring
+                                                    // <url>" message for a session that's gone.
+                                                    if (!store.getState().ultraplanSessionUrl)
+                                                        return;
+                                                    appendStdout(msg);
+                                                });
+                                            };
+                                            void launchUltraplan({
+                                                blurb,
+                                                getAppState: () => store.getState(),
+                                                setAppState,
+                                                signal: createAbortController().signal,
+                                                disconnectedBridge: opts?.disconnectedBridge,
+                                                onSessionReady: appendWhenIdle
+                                            }).then(appendStdout).catch(logError);
+                                        } }) : null, mrRender(), !toolJSX?.shouldHidePromptInput && !focusedInputDialog && !isExiting && !disabled && !cursor && _jsxs(_Fragment, { children: [autoRunIssueReason && _jsx(AutoRunIssueNotification, { onRun: handleAutoRunIssue, onCancel: handleCancelAutoRunIssue, reason: getAutoRunIssueReasonText(autoRunIssueReason) }), postCompactSurvey.state !== 'closed' ? _jsx(FeedbackSurvey, { state: postCompactSurvey.state, lastResponse: postCompactSurvey.lastResponse, handleSelect: postCompactSurvey.handleSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: handleSurveyRequestFeedback }) : memorySurvey.state !== 'closed' ? _jsx(FeedbackSurvey, { state: memorySurvey.state, lastResponse: memorySurvey.lastResponse, handleSelect: memorySurvey.handleSelect, handleTranscriptSelect: memorySurvey.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: handleSurveyRequestFeedback, message: "How well did Claude use its memory? (optional)" }) : _jsx(FeedbackSurvey, { state: feedbackSurvey.state, lastResponse: feedbackSurvey.lastResponse, handleSelect: feedbackSurvey.handleSelect, handleTranscriptSelect: feedbackSurvey.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: didAutoRunIssueRef.current ? undefined : handleSurveyRequestFeedback }), frustrationDetection.state !== 'closed' && _jsx(FeedbackSurvey, { state: frustrationDetection.state, lastResponse: null, handleSelect: () => { }, handleTranscriptSelect: frustrationDetection.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue }), "external" === 'ant' && skillImprovementSurvey.suggestion && _jsx(SkillImprovementSurvey, { isOpen: skillImprovementSurvey.isOpen, skillName: skillImprovementSurvey.suggestion.skillName, updates: skillImprovementSurvey.suggestion.updates, handleSelect: skillImprovementSurvey.handleSelect, inputValue: inputValue, setInputValue: setInputValue }), showIssueFlagBanner && _jsx(IssueFlagBanner, {}), _jsx(PromptInput, { debug: debug, ideSelection: ideSelection, hasSuppressedDialogs: !!hasSuppressedDialogs, isLocalJSXCommandActive: isShowingLocalJSXCommand, getToolUseContext: getToolUseContext, toolPermissionContext: toolPermissionContext, setToolPermissionContext: setToolPermissionContext, apiKeyStatus: apiKeyStatus, commands: commands, agents: agentDefinitions.activeAgents, isLoading: isLoading, onExit: handleExit, verbose: verbose, messages: messages, onAutoUpdaterResult: setAutoUpdaterResult, autoUpdaterResult: autoUpdaterResult, input: inputValue, onInputChange: setInputValue, mode: inputMode, onModeChange: setInputMode, stashedPrompt: stashedPrompt, setStashedPrompt: setStashedPrompt, submitCount: submitCount, onShowMessageSelector: handleShowMessageSelector, onMessageActionsEnter: 
+                                                // Works during isLoading — edit cancels first; uuid selection survives appends.
+                                                feature('MESSAGE_ACTIONS') && isFullscreenEnvEnabled() && !disableMessageActions ? enterMessageActions : undefined, mcpClients: mcpClients, pastedContents: pastedContents, setPastedContents: setPastedContents, vimMode: vimMode, setVimMode: setVimMode, showBashesDialog: showBashesDialog, setShowBashesDialog: setShowBashesDialog, onSubmit: onSubmit, onAgentSubmit: onAgentSubmit, isSearchingHistory: isSearchingHistory, setIsSearchingHistory: setIsSearchingHistory, helpOpen: isHelpOpen, setHelpOpen: setIsHelpOpen, insertTextRef: feature('VOICE_MODE') ? insertTextRef : undefined, voiceInterimRange: voice.interimRange }), _jsx(SessionBackgroundHint, { onBackgroundSession: handleBackgroundSession, isLoading: isLoading })] }), cursor &&
+                                        _jsx(MessageActionsBar, { cursor: cursor }), focusedInputDialog === 'message-selector' && _jsx(MessageSelector, { messages: messages, preselectedMessage: messageSelectorPreselect, onPreRestore: onCancel, onRestoreCode: async (message) => {
+                                            await fileHistoryRewind((updater) => {
+                                                setAppState(prev => ({
+                                                    ...prev,
+                                                    fileHistory: updater(prev.fileHistory)
+                                                }));
+                                            }, message.uuid);
+                                        }, onSummarize: async (message, feedback, direction = 'from') => {
+                                            // Project snipped messages so the compact model
+                                            // doesn't summarize content that was intentionally removed.
+                                            const compactMessages = getMessagesAfterCompactBoundary(messages);
+                                            const messageIndex = compactMessages.indexOf(message);
+                                            if (messageIndex === -1) {
+                                                // Selected a snipped or pre-compact message that the
+                                                // selector still shows (REPL keeps full history for
+                                                // scrollback). Surface why nothing happened instead
+                                                // of silently no-oping.
+                                                setMessages(prev => [...prev, createSystemMessage('That message is no longer in the active context (snipped or pre-compact). Choose a more recent message.', 'warning')]);
+                                                return;
+                                            }
+                                            const newAbortController = createAbortController();
+                                            const context = getToolUseContext(compactMessages, [], newAbortController, mainLoopModel);
+                                            const appState = context.getAppState();
+                                            const defaultSysPrompt = await getSystemPrompt(context.options.tools, context.options.mainLoopModel, Array.from(appState.toolPermissionContext.additionalWorkingDirectories.keys()), context.options.mcpClients);
+                                            const systemPrompt = buildEffectiveSystemPrompt({
+                                                mainThreadAgentDefinition: undefined,
+                                                toolUseContext: context,
+                                                customSystemPrompt: context.options.customSystemPrompt,
+                                                defaultSystemPrompt: defaultSysPrompt,
+                                                appendSystemPrompt: context.options.appendSystemPrompt
+                                            });
+                                            const [userContext, systemContext] = await Promise.all([getUserContext(), getSystemContext()]);
+                                            const result = await partialCompactConversation(compactMessages, messageIndex, context, {
+                                                systemPrompt,
+                                                userContext,
+                                                systemContext,
+                                                toolUseContext: context,
+                                                forkContextMessages: compactMessages
+                                            }, feedback, direction);
+                                            const kept = result.messagesToKeep ?? [];
+                                            const ordered = direction === 'up_to' ? [...result.summaryMessages, ...kept] : [...kept, ...result.summaryMessages];
+                                            const postCompact = [result.boundaryMarker, ...ordered, ...result.attachments, ...result.hookResults];
+                                            // Fullscreen 'from' keeps scrollback; 'up_to' must not
+                                            // (old[0] unchanged + grown array means incremental
+                                            // useLogMessages path, so boundary never persisted).
+                                            // Find by uuid since old is raw REPL history and snipped
+                                            // entries can shift the projected messageIndex.
+                                            if (isFullscreenEnvEnabled() && direction === 'from') {
+                                                setMessages(old => {
+                                                    const rawIdx = old.findIndex(m => m.uuid === message.uuid);
+                                                    return [...old.slice(0, rawIdx === -1 ? 0 : rawIdx), ...postCompact];
+                                                });
+                                            }
+                                            else {
+                                                setMessages(postCompact);
+                                            }
+                                            // Partial compact bypasses handleMessageFromStream — clear
+                                            // the context-blocked flag so proactive ticks resume.
+                                            if (feature('PROACTIVE') || feature('KAIROS')) {
+                                                proactiveModule?.setContextBlocked(false);
+                                            }
+                                            setConversationId(randomUUID());
+                                            runPostCompactCleanup(context.options.querySource);
+                                            if (direction === 'from') {
+                                                const r = textForResubmit(message);
+                                                if (r) {
+                                                    setInputValue(r.text);
+                                                    setInputMode(r.mode);
+                                                }
+                                            }
+                                            // Show notification with ctrl+o hint
+                                            const historyShortcut = getShortcutDisplay('app:toggleTranscript', 'Global', 'ctrl+o');
+                                            addNotification({
+                                                key: 'summarize-ctrl-o-hint',
+                                                text: `Conversation summarized (${historyShortcut} for history)`,
+                                                priority: 'medium',
+                                                timeoutMs: 8000
+                                            });
+                                        }, onRestoreMessage: handleRestoreMessage, onClose: () => {
+                                            setIsMessageSelectorVisible(false);
+                                            setMessageSelectorPreselect(undefined);
+                                        } }), "external" === 'ant' && _jsx(DevBar, {})] }), feature('BUDDY') && !(companionNarrow && isFullscreenEnvEnabled()) && companionVisible ? _jsx(CompanionSprite, {}) : null] }) }) }, remountKey)] });
+    if (isFullscreenEnvEnabled()) {
+        return _jsx(AlternateScreen, { mouseTracking: isMouseTrackingEnabled(), children: mainReturn });
+    }
+    return mainReturn;
+}