1  import { c as _c } from "react/compiler-runtime";
   2  // biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
   3  import { feature } from 'bun:bundle';
   4  import { spawnSync } from 'child_process';
   5  import { snapshotOutputTokensForTurn, getCurrentTurnTokenBudget, getTurnOutputTokens, getBudgetContinuationCount, getTotalInputTokens } from '../bootstrap/state.js';
   6  import { parseTokenBudget } from '../utils/tokenBudget.js';
   7  import { count } from '../utils/array.js';
   8  import { dirname, join } from 'path';
   9  import { tmpdir } from 'os';
  10  import figures from 'figures';
  11  // 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
  12  import { useInput } from '../ink.js';
  13  import { useSearchInput } from '../hooks/useSearchInput.js';
  14  import { useTerminalSize } from '../hooks/useTerminalSize.js';
  15  import { useSearchHighlight } from '../ink/hooks/use-search-highlight.js';
  16  import type { JumpHandle } from '../components/VirtualMessageList.js';
  17  import { renderMessagesToPlainText } from '../utils/exportRenderer.js';
  18  import { openFileInExternalEditor } from '../utils/editor.js';
  19  import { writeFile } from 'fs/promises';
  20  import { Box, Text, useStdin, useTheme, useTerminalFocus, useTerminalTitle, useTabStatus } from '../ink.js';
  21  import type { TabStatusKind } from '../ink/hooks/use-tab-status.js';
  22  import { CostThresholdDialog } from '../components/CostThresholdDialog.js';
  23  import { IdleReturnDialog } from '../components/IdleReturnDialog.js';
  24  import * as React from 'react';
  25  import { useEffect, useMemo, useRef, useState, useCallback, useDeferredValue, useLayoutEffect, type RefObject } from 'react';
  26  import { useNotifications } from '../context/notifications.js';
  27  import { sendNotification } from '../services/notifier.js';
  28  import { startPreventSleep, stopPreventSleep } from '../services/preventSleep.js';
  29  import { useTerminalNotification } from '../ink/useTerminalNotification.js';
  30  import { hasCursorUpViewportYankBug } from '../ink/terminal.js';
  31  import { createFileStateCacheWithSizeLimit, mergeFileStateCaches, READ_FILE_STATE_CACHE_SIZE } from '../utils/fileStateCache.js';
  32  import { updateLastInteractionTime, getLastInteractionTime, getOriginalCwd, getProjectRoot, getSessionId, switchSession, setCostStateForRestore, getTurnHookDurationMs, getTurnHookCount, resetTurnHookDuration, getTurnToolDurationMs, getTurnToolCount, resetTurnToolDuration, getTurnClassifierDurationMs, getTurnClassifierCount, resetTurnClassifierDuration } from '../bootstrap/state.js';
  33  import { asSessionId, asAgentId } from '../types/ids.js';
  34  import { logForDebugging } from '../utils/debug.js';
  35  import { QueryGuard } from '../utils/QueryGuard.js';
  36  import { isEnvTruthy } from '../utils/envUtils.js';
  37  import { formatTokens, truncateToWidth } from '../utils/format.js';
  38  import { consumeEarlyInput } from '../utils/earlyInput.js';
  39  import { setMemberActive } from '../utils/swarm/teamHelpers.js';
  40  import { isSwarmWorker, generateSandboxRequestId, sendSandboxPermissionRequestViaMailbox, sendSandboxPermissionResponseViaMailbox } from '../utils/swarm/permissionSync.js';
  41  import { registerSandboxPermissionCallback } from '../hooks/useSwarmPermissionPoller.js';
  42  import { getTeamName, getAgentName } from '../utils/teammate.js';
  43  import { WorkerPendingPermission } from '../components/permissions/WorkerPendingPermission.js';
  44  import { injectUserMessageToTeammate, getAllInProcessTeammateTasks } from '../tasks/InProcessTeammateTask/InProcessTeammateTask.js';
  45  import { isLocalAgentTask, queuePendingMessage, appendMessageToLocalAgent, type LocalAgentTaskState } from '../tasks/LocalAgentTask/LocalAgentTask.js';
  46  import { registerLeaderToolUseConfirmQueue, unregisterLeaderToolUseConfirmQueue, registerLeaderSetToolPermissionContext, unregisterLeaderSetToolPermissionContext } from '../utils/swarm/leaderPermissionBridge.js';
  47  import { endInteractionSpan } from '../utils/telemetry/sessionTracing.js';
  48  import { useLogMessages } from '../hooks/useLogMessages.js';
  49  import { useReplBridge } from '../hooks/useReplBridge.js';
  50  import { type Command, type CommandResultDisplay, type ResumeEntrypoint, getCommandName, isCommandEnabled } from '../commands.js';
  51  import type { PromptInputMode, QueuedCommand, VimMode } from '../types/textInputTypes.js';
  52  import { MessageSelector, selectableUserMessagesFilter, messagesAfterAreOnlySynthetic } from '../components/MessageSelector.js';
  53  import { useIdeLogging } from '../hooks/useIdeLogging.js';
  54  import { PermissionRequest, type ToolUseConfirm } from '../components/permissions/PermissionRequest.js';
  55  import { ElicitationDialog } from '../components/mcp/ElicitationDialog.js';
  56  import { PromptDialog } from '../components/hooks/PromptDialog.js';
  57  import type { PromptRequest, PromptResponse } from '../types/hooks.js';
  58  import PromptInput from '../components/PromptInput/PromptInput.js';
  59  import { PromptInputQueuedCommands } from '../components/PromptInput/PromptInputQueuedCommands.js';
  60  import { useRemoteSession } from '../hooks/useRemoteSession.js';
  61  import { useDirectConnect } from '../hooks/useDirectConnect.js';
  62  import type { DirectConnectConfig } from '../server/directConnectManager.js';
  63  import { useSSHSession } from '../hooks/useSSHSession.js';
  64  import { useAssistantHistory } from '../hooks/useAssistantHistory.js';
  65  import type { SSHSession } from '../ssh/createSSHSession.js';
  66  import { SkillImprovementSurvey } from '../components/SkillImprovementSurvey.js';
  67  import { useSkillImprovementSurvey } from '../hooks/useSkillImprovementSurvey.js';
  68  import { useMoreRight } from '../moreright/useMoreRight.js';
  69  import { SpinnerWithVerb, BriefIdleStatus, type SpinnerMode } from '../components/Spinner.js';
  70  import { getSystemPrompt } from '../constants/prompts.js';
  71  import { buildEffectiveSystemPrompt } from '../utils/systemPrompt.js';
  72  import { getSystemContext, getUserContext } from '../context.js';
  73  import { getMemoryFiles } from '../utils/claudemd.js';
  74  import { startBackgroundHousekeeping } from '../utils/backgroundHousekeeping.js';
  75  import { getTotalCost, saveCurrentSessionCosts, resetCostState, getStoredSessionCosts } from '../cost-tracker.js';
  76  import { useCostSummary } from '../costHook.js';
  77  import { useFpsMetrics } from '../context/fpsMetrics.js';
  78  import { useAfterFirstRender } from '../hooks/useAfterFirstRender.js';
  79  import { useDeferredHookMessages } from '../hooks/useDeferredHookMessages.js';
  80  import { addToHistory, removeLastFromHistory, expandPastedTextRefs, parseReferences } from '../history.js';
  81  import { prependModeCharacterToInput } from '../components/PromptInput/inputModes.js';
  82  import { prependToShellHistoryCache } from '../utils/suggestions/shellHistoryCompletion.js';
  83  import { useApiKeyVerification } from '../hooks/useApiKeyVerification.js';
  84  import { GlobalKeybindingHandlers } from '../hooks/useGlobalKeybindings.js';
  85  import { CommandKeybindingHandlers } from '../hooks/useCommandKeybindings.js';
  86  import { KeybindingSetup } from '../keybindings/KeybindingProviderSetup.js';
  87  import { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js';
  88  import { getShortcutDisplay } from '../keybindings/shortcutFormat.js';
  89  import { CancelRequestHandler } from '../hooks/useCancelRequest.js';
  90  import { useBackgroundTaskNavigation } from '../hooks/useBackgroundTaskNavigation.js';
  91  import { useSwarmInitialization } from '../hooks/useSwarmInitialization.js';
  92  import { useTeammateViewAutoExit } from '../hooks/useTeammateViewAutoExit.js';
  93  import { errorMessage } from '../utils/errors.js';
  94  import { isHumanTurn } from '../utils/messagePredicates.js';
  95  import { logError } from '../utils/log.js';
  96  // Dead code elimination: conditional imports
  97  /* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
  98  const useVoiceIntegration: typeof import('../hooks/useVoiceIntegration.js').useVoiceIntegration = feature('VOICE_MODE') ? require('../hooks/useVoiceIntegration.js').useVoiceIntegration : () => ({
  99    stripTrailing: () => 0,
 100    handleKeyEvent: () => {},
 101    resetAnchor: () => {}
 102  });
 103  const VoiceKeybindingHandler: typeof import('../hooks/useVoiceIntegration.js').VoiceKeybindingHandler = feature('VOICE_MODE') ? require('../hooks/useVoiceIntegration.js').VoiceKeybindingHandler : () => null;
 104  // Frustration detection is ant-only (dogfooding). Conditional require so external
 105  // builds eliminate the module entirely (including its two O(n) useMemos that run
 106  // on every messages change, plus the GrowthBook fetch).
 107  const useFrustrationDetection: typeof import('../components/FeedbackSurvey/useFrustrationDetection.js').useFrustrationDetection = "external" === 'ant' ? require('../components/FeedbackSurvey/useFrustrationDetection.js').useFrustrationDetection : () => ({
 108    state: 'closed',
 109    handleTranscriptSelect: () => {}
 110  });
 111  // Ant-only org warning. Conditional require so the org UUID list is
 112  // eliminated from external builds (one UUID is on excluded-strings).
 113  const useAntOrgWarningNotification: typeof import('../hooks/notifs/useAntOrgWarningNotification.js').useAntOrgWarningNotification = "external" === 'ant' ? require('../hooks/notifs/useAntOrgWarningNotification.js').useAntOrgWarningNotification : () => {};
 114  // Dead code elimination: conditional import for coordinator mode
 115  const getCoordinatorUserContext: (mcpClients: ReadonlyArray<{
 116    name: string;
 117  }>, scratchpadDir?: string) => {
 118    [k: string]: string;
 119  } = feature('COORDINATOR_MODE') ? require('../coordinator/coordinatorMode.js').getCoordinatorUserContext : () => ({});
 120  /* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
 121  import useCanUseTool from '../hooks/useCanUseTool.js';
 122  import type { ToolPermissionContext, Tool } from '../Tool.js';
 123  import { applyPermissionUpdate, applyPermissionUpdates, persistPermissionUpdate } from '../utils/permissions/PermissionUpdate.js';
 124  import { buildPermissionUpdates } from '../components/permissions/ExitPlanModePermissionRequest/ExitPlanModePermissionRequest.js';
 125  import { stripDangerousPermissionsForAutoMode } from '../utils/permissions/permissionSetup.js';
 126  import { getScratchpadDir, isScratchpadEnabled } from '../utils/permissions/filesystem.js';
 127  import { WEB_FETCH_TOOL_NAME } from '../tools/WebFetchTool/prompt.js';
 128  import { SLEEP_TOOL_NAME } from '../tools/SleepTool/prompt.js';
 129  import { clearSpeculativeChecks } from '../tools/BashTool/bashPermissions.js';
 130  import type { AutoUpdaterResult } from '../utils/autoUpdater.js';
 131  import { getGlobalConfig, saveGlobalConfig, getGlobalConfigWriteCount } from '../utils/config.js';
 132  import { hasConsoleBillingAccess } from '../utils/billing.js';
 133  import { logEvent, type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS } from 'src/services/analytics/index.js';
 134  import { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js';
 135  import { textForResubmit, handleMessageFromStream, type StreamingToolUse, type StreamingThinking, isCompactBoundaryMessage, getMessagesAfterCompactBoundary, getContentText, createUserMessage, createAssistantMessage, createTurnDurationMessage, createAgentsKilledMessage, createApiMetricsMessage, createSystemMessage, createCommandInputMessage, formatCommandInputTags } from '../utils/messages.js';
 136  import { generateSessionTitle } from '../utils/sessionTitle.js';
 137  import { BASH_INPUT_TAG, COMMAND_MESSAGE_TAG, COMMAND_NAME_TAG, LOCAL_COMMAND_STDOUT_TAG } from '../constants/xml.js';
 138  import { escapeXml } from '../utils/xml.js';
 139  import type { ThinkingConfig } from '../utils/thinking.js';
 140  import { gracefulShutdownSync } from '../utils/gracefulShutdown.js';
 141  import { handlePromptSubmit, type PromptInputHelpers } from '../utils/handlePromptSubmit.js';
 142  import { useQueueProcessor } from '../hooks/useQueueProcessor.js';
 143  import { useMailboxBridge } from '../hooks/useMailboxBridge.js';
 144  import { queryCheckpoint, logQueryProfileReport } from '../utils/queryProfiler.js';
 145  import type { Message as MessageType, UserMessage, ProgressMessage, HookResultMessage, PartialCompactDirection } from '../types/message.js';
 146  import { query } from '../query.js';
 147  import { mergeClients, useMergedClients } from '../hooks/useMergedClients.js';
 148  import { getQuerySourceForREPL } from '../utils/promptCategory.js';
 149  import { useMergedTools } from '../hooks/useMergedTools.js';
 150  import { mergeAndFilterTools } from '../utils/toolPool.js';
 151  import { useMergedCommands } from '../hooks/useMergedCommands.js';
 152  import { useSkillsChange } from '../hooks/useSkillsChange.js';
 153  import { useManagePlugins } from '../hooks/useManagePlugins.js';
 154  import { Messages } from '../components/Messages.js';
 155  import { TaskListV2 } from '../components/TaskListV2.js';
 156  import { TeammateViewHeader } from '../components/TeammateViewHeader.js';
 157  import { useTasksV2WithCollapseEffect } from '../hooks/useTasksV2.js';
 158  import { maybeMarkProjectOnboardingComplete } from '../projectOnboardingState.js';
 159  import type { MCPServerConnection } from '../services/mcp/types.js';
 160  import type { ScopedMcpServerConfig } from '../services/mcp/types.js';
 161  import { randomUUID, type UUID } from 'crypto';
 162  import { processSessionStartHooks } from '../utils/sessionStart.js';
 163  import { executeSessionEndHooks, getSessionEndHookTimeoutMs } from '../utils/hooks.js';
 164  import { type IDESelection, useIdeSelection } from '../hooks/useIdeSelection.js';
 165  import { getTools, assembleToolPool } from '../tools.js';
 166  import type { AgentDefinition } from '../tools/AgentTool/loadAgentsDir.js';
 167  import { resolveAgentTools } from '../tools/AgentTool/agentToolUtils.js';
 168  import { resumeAgentBackground } from '../tools/AgentTool/resumeAgent.js';
 169  import { useMainLoopModel } from '../hooks/useMainLoopModel.js';
 170  import { useAppState, useSetAppState, useAppStateStore } from '../state/AppState.js';
 171  import type { ContentBlockParam, ImageBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs';
 172  import type { ProcessUserInputContext } from '../utils/processUserInput/processUserInput.js';
 173  import type { PastedContent } from '../utils/config.js';
 174  import { copyPlanForFork, copyPlanForResume, getPlanSlug, setPlanSlug } from '../utils/plans.js';
 175  import { clearSessionMetadata, resetSessionFilePointer, adoptResumedSessionFile, removeTranscriptMessage, restoreSessionMetadata, getCurrentSessionTitle, isEphemeralToolProgress, isLoggableMessage, saveWorktreeState, getAgentTranscript } from '../utils/sessionStorage.js';
 176  import { deserializeMessages } from '../utils/conversationRecovery.js';
 177  import { extractReadFilesFromMessages, extractBashToolsFromMessages } from '../utils/queryHelpers.js';
 178  import { resetMicrocompactState } from '../services/compact/microCompact.js';
 179  import { runPostCompactCleanup } from '../services/compact/postCompactCleanup.js';
 180  import { provisionContentReplacementState, reconstructContentReplacementState, type ContentReplacementRecord } from '../utils/toolResultStorage.js';
 181  import { partialCompactConversation } from '../services/compact/compact.js';
 182  import type { LogOption } from '../types/logs.js';
 183  import type { AgentColorName } from '../tools/AgentTool/agentColorManager.js';
 184  import { fileHistoryMakeSnapshot, type FileHistoryState, fileHistoryRewind, type FileHistorySnapshot, copyFileHistoryForResume, fileHistoryEnabled, fileHistoryHasAnyChanges } from '../utils/fileHistory.js';
 185  import { type AttributionState, incrementPromptCount } from '../utils/commitAttribution.js';
 186  import { recordAttributionSnapshot } from '../utils/sessionStorage.js';
 187  import { computeStandaloneAgentContext, restoreAgentFromSession, restoreSessionStateFromLog, restoreWorktreeForResume, exitRestoredWorktree } from '../utils/sessionRestore.js';
 188  import { isBgSession, updateSessionName, updateSessionActivity } from '../utils/concurrentSessions.js';
 189  import { isInProcessTeammateTask, type InProcessTeammateTaskState } from '../tasks/InProcessTeammateTask/types.js';
 190  import { restoreRemoteAgentTasks } from '../tasks/RemoteAgentTask/RemoteAgentTask.js';
 191  import { useInboxPoller } from '../hooks/useInboxPoller.js';
 192  // Dead code elimination: conditional import for loop mode
 193  /* eslint-disable @typescript-eslint/no-require-imports */
 194  const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/index.js') : null;
 195  const PROACTIVE_NO_OP_SUBSCRIBE = (_cb: () => void) => () => {};
 196  const PROACTIVE_FALSE = () => false;
 197  const SUGGEST_BG_PR_NOOP = (_p: string, _n: string): boolean => false;
 198  const useProactive = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/useProactive.js').useProactive : null;
 199  const useScheduledTasks = feature('AGENT_TRIGGERS') ? require('../hooks/useScheduledTasks.js').useScheduledTasks : null;
 200  /* eslint-enable @typescript-eslint/no-require-imports */
 201  import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js';
 202  import { useTaskListWatcher } from '../hooks/useTaskListWatcher.js';
 203  import type { SandboxAskCallback, NetworkHostPattern } from '../utils/sandbox/sandbox-adapter.js';
 204  import { type IDEExtensionInstallationStatus, closeOpenDiffs, getConnectedIdeClient, type IdeType } from '../utils/ide.js';
 205  import { useIDEIntegration } from '../hooks/useIDEIntegration.js';
 206  import exit from '../commands/exit/index.js';
 207  import { ExitFlow } from '../components/ExitFlow.js';
 208  import { getCurrentWorktreeSession } from '../utils/worktree.js';
 209  import { popAllEditable, enqueue, type SetAppState, getCommandQueue, getCommandQueueLength, removeByFilter } from '../utils/messageQueueManager.js';
 210  import { useCommandQueue } from '../hooks/useCommandQueue.js';
 211  import { SessionBackgroundHint } from '../components/SessionBackgroundHint.js';
 212  import { startBackgroundSession } from '../tasks/LocalMainSessionTask.js';
 213  import { useSessionBackgrounding } from '../hooks/useSessionBackgrounding.js';
 214  import { diagnosticTracker } from '../services/diagnosticTracking.js';
 215  import { handleSpeculationAccept, type ActiveSpeculationState } from '../services/PromptSuggestion/speculation.js';
 216  import { IdeOnboardingDialog } from '../components/IdeOnboardingDialog.js';
 217  import { EffortCallout, shouldShowEffortCallout } from '../components/EffortCallout.js';
 218  import type { EffortValue } from '../utils/effort.js';
 219  import { RemoteCallout } from '../components/RemoteCallout.js';
 220  /* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
 221  const AntModelSwitchCallout = "external" === 'ant' ? require('../components/AntModelSwitchCallout.js').AntModelSwitchCallout : null;
 222  const shouldShowAntModelSwitch = "external" === 'ant' ? require('../components/AntModelSwitchCallout.js').shouldShowModelSwitchCallout : (): boolean => false;
 223  const UndercoverAutoCallout = "external" === 'ant' ? require('../components/UndercoverAutoCallout.js').UndercoverAutoCallout : null;
 224  /* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
 225  import { activityManager } from '../utils/activityManager.js';
 226  import { createAbortController } from '../utils/abortController.js';
 227  import { MCPConnectionManager } from 'src/services/mcp/MCPConnectionManager.js';
 228  import { useFeedbackSurvey } from 'src/components/FeedbackSurvey/useFeedbackSurvey.js';
 229  import { useMemorySurvey } from 'src/components/FeedbackSurvey/useMemorySurvey.js';
 230  import { usePostCompactSurvey } from 'src/components/FeedbackSurvey/usePostCompactSurvey.js';
 231  import { FeedbackSurvey } from 'src/components/FeedbackSurvey/FeedbackSurvey.js';
 232  import { useInstallMessages } from 'src/hooks/notifs/useInstallMessages.js';
 233  import { useAwaySummary } from 'src/hooks/useAwaySummary.js';
 234  import { useChromeExtensionNotification } from 'src/hooks/useChromeExtensionNotification.js';
 235  import { useOfficialMarketplaceNotification } from 'src/hooks/useOfficialMarketplaceNotification.js';
 236  import { usePromptsFromClaudeInChrome } from 'src/hooks/usePromptsFromClaudeInChrome.js';
 237  import { getTipToShowOnSpinner, recordShownTip } from 'src/services/tips/tipScheduler.js';
 238  import type { Theme } from 'src/utils/theme.js';
 239  import { checkAndDisableBypassPermissionsIfNeeded, checkAndDisableAutoModeIfNeeded, useKickOffCheckAndDisableBypassPermissionsIfNeeded, useKickOffCheckAndDisableAutoModeIfNeeded } from 'src/utils/permissions/bypassPermissionsKillswitch.js';
 240  import { SandboxManager } from 'src/utils/sandbox/sandbox-adapter.js';
 241  import { SANDBOX_NETWORK_ACCESS_TOOL_NAME } from 'src/cli/structuredIO.js';
 242  import { useFileHistorySnapshotInit } from 'src/hooks/useFileHistorySnapshotInit.js';
 243  import { SandboxPermissionRequest } from 'src/components/permissions/SandboxPermissionRequest.js';
 244  import { SandboxViolationExpandedView } from 'src/components/SandboxViolationExpandedView.js';
 245  import { useSettingsErrors } from 'src/hooks/notifs/useSettingsErrors.js';
 246  import { useMcpConnectivityStatus } from 'src/hooks/notifs/useMcpConnectivityStatus.js';
 247  import { useAutoModeUnavailableNotification } from 'src/hooks/notifs/useAutoModeUnavailableNotification.js';
 248  import { AUTO_MODE_DESCRIPTION } from 'src/components/AutoModeOptInDialog.js';
 249  import { useLspInitializationNotification } from 'src/hooks/notifs/useLspInitializationNotification.js';
 250  import { useLspPluginRecommendation } from 'src/hooks/useLspPluginRecommendation.js';
 251  import { LspRecommendationMenu } from 'src/components/LspRecommendation/LspRecommendationMenu.js';
 252  import { useClaudeCodeHintRecommendation } from 'src/hooks/useClaudeCodeHintRecommendation.js';
 253  import { PluginHintMenu } from 'src/components/ClaudeCodeHint/PluginHintMenu.js';
 254  import { DesktopUpsellStartup, shouldShowDesktopUpsellStartup } from 'src/components/DesktopUpsell/DesktopUpsellStartup.js';
 255  import { usePluginInstallationStatus } from 'src/hooks/notifs/usePluginInstallationStatus.js';
 256  import { usePluginAutoupdateNotification } from 'src/hooks/notifs/usePluginAutoupdateNotification.js';
 257  import { performStartupChecks } from 'src/utils/plugins/performStartupChecks.js';
 258  import { UserTextMessage } from 'src/components/messages/UserTextMessage.js';
 259  import { AwsAuthStatusBox } from '../components/AwsAuthStatusBox.js';
 260  import { useRateLimitWarningNotification } from 'src/hooks/notifs/useRateLimitWarningNotification.js';
 261  import { useDeprecationWarningNotification } from 'src/hooks/notifs/useDeprecationWarningNotification.js';
 262  import { useNpmDeprecationNotification } from 'src/hooks/notifs/useNpmDeprecationNotification.js';
 263  import { useIDEStatusIndicator } from 'src/hooks/notifs/useIDEStatusIndicator.js';
 264  import { useModelMigrationNotifications } from 'src/hooks/notifs/useModelMigrationNotifications.js';
 265  import { useCanSwitchToExistingSubscription } from 'src/hooks/notifs/useCanSwitchToExistingSubscription.js';
 266  import { useTeammateLifecycleNotification } from 'src/hooks/notifs/useTeammateShutdownNotification.js';
 267  import { useFastModeNotification } from 'src/hooks/notifs/useFastModeNotification.js';
 268  import { AutoRunIssueNotification, shouldAutoRunIssue, getAutoRunIssueReasonText, getAutoRunCommand, type AutoRunIssueReason } from '../utils/autoRunIssue.js';
 269  import type { HookProgress } from '../types/hooks.js';
 270  import { TungstenLiveMonitor } from '../tools/TungstenTool/TungstenLiveMonitor.js';
 271  /* eslint-disable @typescript-eslint/no-require-imports */
 272  const WebBrowserPanelModule = feature('WEB_BROWSER_TOOL') ? require('../tools/WebBrowserTool/WebBrowserPanel.js') as typeof import('../tools/WebBrowserTool/WebBrowserPanel.js') : null;
 273  /* eslint-enable @typescript-eslint/no-require-imports */
 274  import { IssueFlagBanner } from '../components/PromptInput/IssueFlagBanner.js';
 275  import { useIssueFlagBanner } from '../hooks/useIssueFlagBanner.js';
 276  import { CompanionSprite, CompanionFloatingBubble, MIN_COLS_FOR_FULL_SPRITE } from '../buddy/CompanionSprite.js';
 277  import { DevBar } from '../components/DevBar.js';
 278  // Session manager removed - using AppState now
 279  import type { RemoteSessionConfig } from '../remote/RemoteSessionManager.js';
 280  import { REMOTE_SAFE_COMMANDS } from '../commands.js';
 281  import type { RemoteMessageContent } from '../utils/teleport/api.js';
 282  import { FullscreenLayout, useUnseenDivider, computeUnseenDivider } from '../components/FullscreenLayout.js';
 283  import { isFullscreenEnvEnabled, maybeGetTmuxMouseHint, isMouseTrackingEnabled } from '../utils/fullscreen.js';
 284  import { AlternateScreen } from '../ink/components/AlternateScreen.js';
 285  import { ScrollKeybindingHandler } from '../components/ScrollKeybindingHandler.js';
 286  import { useMessageActions, MessageActionsKeybindings, MessageActionsBar, type MessageActionsState, type MessageActionsNav, type MessageActionCaps } from '../components/messageActions.js';
 287  import { setClipboard } from '../ink/termio/osc.js';
 288  import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js';
 289  import { createAttachmentMessage, getQueuedCommandAttachments } from '../utils/attachments.js';
 290  
 291  // Stable empty array for hooks that accept MCPServerConnection[] — avoids
 292  // creating a new [] literal on every render in remote mode, which would
 293  // cause useEffect dependency changes and infinite re-render loops.
 294  const EMPTY_MCP_CLIENTS: MCPServerConnection[] = [];
 295  
 296  // Stable stub for useAssistantHistory's non-KAIROS branch — avoids a new
 297  // function identity each render, which would break composedOnScroll's memo.
 298  const HISTORY_STUB = {
 299    maybeLoadOlder: (_: ScrollBoxHandle) => {}
 300  };
 301  // Window after a user-initiated scroll during which type-into-empty does NOT
 302  // repin to bottom. Josh Rosen's workflow: Claude emits long output → scroll
 303  // up to read the start → start typing → before this fix, snapped to bottom.
 304  // https://anthropic.slack.com/archives/C07VBSHV7EV/p1773545449871739
 305  const RECENT_SCROLL_REPIN_WINDOW_MS = 3000;
 306  
 307  // Use LRU cache to prevent unbounded memory growth
 308  // 100 files should be sufficient for most coding sessions while preventing
 309  // memory issues when working across many files in large projects
 310  
 311  function median(values: number[]): number {
 312    const sorted = [...values].sort((a, b) => a - b);
 313    const mid = Math.floor(sorted.length / 2);
 314    return sorted.length % 2 === 0 ? Math.round((sorted[mid - 1]! + sorted[mid]!) / 2) : sorted[mid]!;
 315  }
 316  
 317  /**
 318   * Small component to display transcript mode footer with dynamic keybinding.
 319   * Must be rendered inside KeybindingSetup to access keybinding context.
 320   */
 321  function TranscriptModeFooter(t0) {
 322    const $ = _c(9);
 323    const {
 324      showAllInTranscript,
 325      virtualScroll,
 326      searchBadge,
 327      suppressShowAll: t1,
 328      status
 329    } = t0;
 330    const suppressShowAll = t1 === undefined ? false : t1;
 331    const toggleShortcut = useShortcutDisplay("app:toggleTranscript", "Global", "ctrl+o");
 332    const showAllShortcut = useShortcutDisplay("transcript:toggleShowAll", "Transcript", "ctrl+e");
 333    const t2 = searchBadge ? " \xB7 n/N to navigate" : virtualScroll ? ` · ${figures.arrowUp}${figures.arrowDown} scroll · home/end top/bottom` : suppressShowAll ? "" : ` · ${showAllShortcut} to ${showAllInTranscript ? "collapse" : "show all"}`;
 334    let t3;
 335    if ($[0] !== t2 || $[1] !== toggleShortcut) {
 336      t3 = <Text dimColor={true}>Showing detailed transcript · {toggleShortcut} to toggle{t2}</Text>;
 337      $[0] = t2;
 338      $[1] = toggleShortcut;
 339      $[2] = t3;
 340    } else {
 341      t3 = $[2];
 342    }
 343    let t4;
 344    if ($[3] !== searchBadge || $[4] !== status) {
 345      t4 = status ? <><Box flexGrow={1} /><Text>{status} </Text></> : searchBadge ? <><Box flexGrow={1} /><Text dimColor={true}>{searchBadge.current}/{searchBadge.count}{"  "}</Text></> : null;
 346      $[3] = searchBadge;
 347      $[4] = status;
 348      $[5] = t4;
 349    } else {
 350      t4 = $[5];
 351    }
 352    let t5;
 353    if ($[6] !== t3 || $[7] !== t4) {
 354      t5 = <Box noSelect={true} alignItems="center" alignSelf="center" borderTopDimColor={true} borderBottom={false} borderLeft={false} borderRight={false} borderStyle="single" marginTop={1} paddingLeft={2} width="100%">{t3}{t4}</Box>;
 355      $[6] = t3;
 356      $[7] = t4;
 357      $[8] = t5;
 358    } else {
 359      t5 = $[8];
 360    }
 361    return t5;
 362  }
 363  
 364  /** less-style / bar. 1-row, same border-top styling as TranscriptModeFooter
 365   *  so swapping them in the bottom slot doesn't shift ScrollBox height.
 366   *  useSearchInput handles readline editing; we report query changes and
 367   *  render the counter. Incremental — re-search + highlight per keystroke. */
 368  function TranscriptSearchBar({
 369    jumpRef,
 370    count,
 371    current,
 372    onClose,
 373    onCancel,
 374    setHighlight,
 375    initialQuery
 376  }: {
 377    jumpRef: RefObject<JumpHandle | null>;
 378    count: number;
 379    current: number;
 380    /** Enter — commit. Query persists for n/N. */
 381    onClose: (lastQuery: string) => void;
 382    /** Esc/ctrl+c/ctrl+g — undo to pre-/ state. */
 383    onCancel: () => void;
 384    setHighlight: (query: string) => void;
 385    // Seed with the previous query (less: / shows last pattern). Mount-fire
 386    // of the effect re-scans with the same query — idempotent (same matches,
 387    // nearest-ptr, same highlights). User can edit or clear.
 388    initialQuery: string;
 389  }): React.ReactNode {
 390    const {
 391      query,
 392      cursorOffset
 393    } = useSearchInput({
 394      isActive: true,
 395      initialQuery,
 396      onExit: () => onClose(query),
 397      onCancel
 398    });
 399    // Index warm-up runs before the query effect so it measures the real
 400    // cost — otherwise setSearchQuery fills the cache first and warm
 401    // reports ~0ms while the user felt the actual lag.
 402    // First / in a transcript session pays the extractSearchText cost.
 403    // Subsequent / return 0 immediately (indexWarmed ref in VML).
 404    // Transcript is frozen at ctrl+o so the cache stays valid.
 405    // Initial 'building' so warmDone is false on mount — the [query] effect
 406    // waits for the warm effect's first resolve instead of racing it. With
 407    // null initial, warmDone would be true on mount → [query] fires →
 408    // setSearchQuery fills cache → warm reports ~0ms while the user felt
 409    // the real lag.
 410    const [indexStatus, setIndexStatus] = React.useState<'building' | {
 411      ms: number;
 412    } | null>('building');
 413    React.useEffect(() => {
 414      let alive = true;
 415      const warm = jumpRef.current?.warmSearchIndex;
 416      if (!warm) {
 417        setIndexStatus(null); // VML not mounted yet — rare, skip indicator
 418        return;
 419      }
 420      setIndexStatus('building');
 421      warm().then(ms => {
 422        if (!alive) return;
 423        // <20ms = imperceptible. No point showing "indexed in 3ms".
 424        if (ms < 20) {
 425          setIndexStatus(null);
 426        } else {
 427          setIndexStatus({
 428            ms
 429          });
 430          setTimeout(() => alive && setIndexStatus(null), 2000);
 431        }
 432      });
 433      return () => {
 434        alive = false;
 435      };
 436      // eslint-disable-next-line react-hooks/exhaustive-deps
 437    }, []); // mount-only: bar opens once per /
 438    // Gate the query effect on warm completion. setHighlight stays instant
 439    // (screen-space overlay, no indexing). setSearchQuery (the scan) waits.
 440    const warmDone = indexStatus !== 'building';
 441    useEffect(() => {
 442      if (!warmDone) return;
 443      jumpRef.current?.setSearchQuery(query);
 444      setHighlight(query);
 445      // eslint-disable-next-line react-hooks/exhaustive-deps
 446    }, [query, warmDone]);
 447    const off = cursorOffset;
 448    const cursorChar = off < query.length ? query[off] : ' ';
 449    return <Box borderTopDimColor borderBottom={false} borderLeft={false} borderRight={false} borderStyle="single" marginTop={1} paddingLeft={2} width="100%"
 450    // applySearchHighlight scans the whole screen buffer. The query
 451    // text rendered here IS on screen — /foo matches its own 'foo' in
 452    // the bar. With no content matches that's the ONLY visible match →
 453    // gets CURRENT → underlined. noSelect makes searchHighlight.ts:76
 454    // skip these cells (same exclusion as gutters). You can't text-
 455    // select the bar either; it's transient chrome, fine.
 456    noSelect>
 457        <Text>/</Text>
 458        <Text>{query.slice(0, off)}</Text>
 459        <Text inverse>{cursorChar}</Text>
 460        {off < query.length && <Text>{query.slice(off + 1)}</Text>}
 461        <Box flexGrow={1} />
 462        {indexStatus === 'building' ? <Text dimColor>indexing… </Text> : indexStatus ? <Text dimColor>indexed in {indexStatus.ms}ms </Text> : count === 0 && query ? <Text color="error">no matches </Text> : count > 0 ?
 463      // Engine-counted (indexOf on extractSearchText). May drift from
 464      // render-count for ghost/phantom messages — badge is a rough
 465      // location hint. scanElement gives exact per-message positions
 466      // but counting ALL would cost ~1-3ms × matched-messages.
 467      <Text dimColor>
 468            {current}/{count}
 469            {'  '}
 470          </Text> : null}
 471      </Box>;
 472  }
 473  const TITLE_ANIMATION_FRAMES = ['⠂', '⠐'];
 474  const TITLE_STATIC_PREFIX = '✳';
 475  const TITLE_ANIMATION_INTERVAL_MS = 960;
 476  
 477  /**
 478   * Sets the terminal tab title, with an animated prefix glyph while a query
 479   * is running. Isolated from REPL so the 960ms animation tick re-renders only
 480   * this leaf component (which returns null — pure side-effect) instead of the
 481   * entire REPL tree. Before extraction, the tick was ~1 REPL render/sec for
 482   * the duration of every turn, dragging PromptInput and friends along.
 483   */
 484  function AnimatedTerminalTitle(t0) {
 485    const $ = _c(6);
 486    const {
 487      isAnimating,
 488      title,
 489      disabled,
 490      noPrefix
 491    } = t0;
 492    const terminalFocused = useTerminalFocus();
 493    const [frame, setFrame] = useState(0);
 494    let t1;
 495    let t2;
 496    if ($[0] !== disabled || $[1] !== isAnimating || $[2] !== noPrefix || $[3] !== terminalFocused) {
 497      t1 = () => {
 498        if (disabled || noPrefix || !isAnimating || !terminalFocused) {
 499          return;
 500        }
 501        const interval = setInterval(_temp2, TITLE_ANIMATION_INTERVAL_MS, setFrame);
 502        return () => clearInterval(interval);
 503      };
 504      t2 = [disabled, noPrefix, isAnimating, terminalFocused];
 505      $[0] = disabled;
 506      $[1] = isAnimating;
 507      $[2] = noPrefix;
 508      $[3] = terminalFocused;
 509      $[4] = t1;
 510      $[5] = t2;
 511    } else {
 512      t1 = $[4];
 513      t2 = $[5];
 514    }
 515    useEffect(t1, t2);
 516    const prefix = isAnimating ? TITLE_ANIMATION_FRAMES[frame] ?? TITLE_STATIC_PREFIX : TITLE_STATIC_PREFIX;
 517    useTerminalTitle(disabled ? null : noPrefix ? title : `${prefix} ${title}`);
 518    return null;
 519  }
 520  function _temp2(setFrame_0) {
 521    return setFrame_0(_temp);
 522  }
 523  function _temp(f) {
 524    return (f + 1) % TITLE_ANIMATION_FRAMES.length;
 525  }
 526  export type Props = {
 527    commands: Command[];
 528    debug: boolean;
 529    initialTools: Tool[];
 530    // Initial messages to populate the REPL with
 531    initialMessages?: MessageType[];
 532    // Deferred hook messages promise — REPL renders immediately and injects
 533    // hook messages when they resolve. Awaited before the first API call.
 534    pendingHookMessages?: Promise<HookResultMessage[]>;
 535    initialFileHistorySnapshots?: FileHistorySnapshot[];
 536    // Content-replacement records from a resumed session's transcript — used to
 537    // reconstruct contentReplacementState so the same results are re-replaced
 538    initialContentReplacements?: ContentReplacementRecord[];
 539    // Initial agent context for session resume (name/color set via /rename or /color)
 540    initialAgentName?: string;
 541    initialAgentColor?: AgentColorName;
 542    mcpClients?: MCPServerConnection[];
 543    dynamicMcpConfig?: Record<string, ScopedMcpServerConfig>;
 544    autoConnectIdeFlag?: boolean;
 545    strictMcpConfig?: boolean;
 546    systemPrompt?: string;
 547    appendSystemPrompt?: string;
 548    // Optional callback invoked before query execution
 549    // Called after user message is added to conversation but before API call
 550    // Return false to prevent query execution
 551    onBeforeQuery?: (input: string, newMessages: MessageType[]) => Promise<boolean>;
 552    // Optional callback when a turn completes (model finishes responding)
 553    onTurnComplete?: (messages: MessageType[]) => void | Promise<void>;
 554    // When true, disables REPL input (hides prompt and prevents message selector)
 555    disabled?: boolean;
 556    // Optional agent definition to use for the main thread
 557    mainThreadAgentDefinition?: AgentDefinition;
 558    // When true, disables all slash commands
 559    disableSlashCommands?: boolean;
 560    // Task list id: when set, enables tasks mode that watches a task list and auto-processes tasks.
 561    taskListId?: string;
 562    // Remote session config for --remote mode (uses CCR as execution engine)
 563    remoteSessionConfig?: RemoteSessionConfig;
 564    // Direct connect config for `claude connect` mode (connects to a claude server)
 565    directConnectConfig?: DirectConnectConfig;
 566    // SSH session for `claude ssh` mode (local REPL, remote tools over ssh)
 567    sshSession?: SSHSession;
 568    // Thinking configuration to use when thinking is enabled
 569    thinkingConfig: ThinkingConfig;
 570  };
 571  export type Screen = 'prompt' | 'transcript';
 572  export function REPL({
 573    commands: initialCommands,
 574    debug,
 575    initialTools,
 576    initialMessages,
 577    pendingHookMessages,
 578    initialFileHistorySnapshots,
 579    initialContentReplacements,
 580    initialAgentName,
 581    initialAgentColor,
 582    mcpClients: initialMcpClients,
 583    dynamicMcpConfig: initialDynamicMcpConfig,
 584    autoConnectIdeFlag,
 585    strictMcpConfig = false,
 586    systemPrompt: customSystemPrompt,
 587    appendSystemPrompt,
 588    onBeforeQuery,
 589    onTurnComplete,
 590    disabled = false,
 591    mainThreadAgentDefinition: initialMainThreadAgentDefinition,
 592    disableSlashCommands = false,
 593    taskListId,
 594    remoteSessionConfig,
 595    directConnectConfig,
 596    sshSession,
 597    thinkingConfig
 598  }: Props): React.ReactNode {
 599    const isRemoteSession = !!remoteSessionConfig;
 600  
 601    // Env-var gates hoisted to mount-time — isEnvTruthy does toLowerCase+trim+
 602    // includes, and these were on the render path (hot during PageUp spam).
 603    const titleDisabled = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE), []);
 604    const moreRightEnabled = useMemo(() => "external" === 'ant' && isEnvTruthy(process.env.CLAUDE_MORERIGHT), []);
 605    const disableVirtualScroll = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL), []);
 606    const disableMessageActions = feature('MESSAGE_ACTIONS') ?
 607    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
 608    useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_MESSAGE_ACTIONS), []) : false;
 609  
 610    // Log REPL mount/unmount lifecycle
 611    useEffect(() => {
 612      logForDebugging(`[REPL:mount] REPL mounted, disabled=${disabled}`);
 613      return () => logForDebugging(`[REPL:unmount] REPL unmounting`);
 614    }, [disabled]);
 615  
 616    // Agent definition is state so /resume can update it mid-session
 617    const [mainThreadAgentDefinition, setMainThreadAgentDefinition] = useState(initialMainThreadAgentDefinition);
 618    const toolPermissionContext = useAppState(s => s.toolPermissionContext);
 619    const verbose = useAppState(s => s.verbose);
 620    const mcp = useAppState(s => s.mcp);
 621    const plugins = useAppState(s => s.plugins);
 622    const agentDefinitions = useAppState(s => s.agentDefinitions);
 623    const fileHistory = useAppState(s => s.fileHistory);
 624    const initialMessage = useAppState(s => s.initialMessage);
 625    const queuedCommands = useCommandQueue();
 626    // feature() is a build-time constant — dead code elimination removes the hook
 627    // call entirely in external builds, so this is safe despite looking conditional.
 628    // These fields contain excluded strings that must not appear in external builds.
 629    const spinnerTip = useAppState(s => s.spinnerTip);
 630    const showExpandedTodos = useAppState(s => s.expandedView) === 'tasks';
 631    const pendingWorkerRequest = useAppState(s => s.pendingWorkerRequest);
 632    const pendingSandboxRequest = useAppState(s => s.pendingSandboxRequest);
 633    const teamContext = useAppState(s => s.teamContext);
 634    const tasks = useAppState(s => s.tasks);
 635    const workerSandboxPermissions = useAppState(s => s.workerSandboxPermissions);
 636    const elicitation = useAppState(s => s.elicitation);
 637    const ultraplanPendingChoice = useAppState(s => s.ultraplanPendingChoice);
 638    const ultraplanLaunchPending = useAppState(s => s.ultraplanLaunchPending);
 639    const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId);
 640    const setAppState = useSetAppState();
 641  
 642    // Bootstrap: retained local_agent that hasn't loaded disk yet → read
 643    // sidechain JSONL and UUID-merge with whatever stream has appended so far.
 644    // Stream appends immediately on retain (no defer); bootstrap fills the
 645    // prefix. Disk-write-before-yield means live is always a suffix of disk.
 646    const viewedLocalAgent = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined;
 647    const needsBootstrap = isLocalAgentTask(viewedLocalAgent) && viewedLocalAgent.retain && !viewedLocalAgent.diskLoaded;
 648    useEffect(() => {
 649      if (!viewingAgentTaskId || !needsBootstrap) return;
 650      const taskId = viewingAgentTaskId;
 651      void getAgentTranscript(asAgentId(taskId)).then(result => {
 652        setAppState(prev => {
 653          const t = prev.tasks[taskId];
 654          if (!isLocalAgentTask(t) || t.diskLoaded || !t.retain) return prev;
 655          const live = t.messages ?? [];
 656          const liveUuids = new Set(live.map(m => m.uuid));
 657          const diskOnly = result ? result.messages.filter(m => !liveUuids.has(m.uuid)) : [];
 658          return {
 659            ...prev,
 660            tasks: {
 661              ...prev.tasks,
 662              [taskId]: {
 663                ...t,
 664                messages: [...diskOnly, ...live],
 665                diskLoaded: true
 666              }
 667            }
 668          };
 669        });
 670      });
 671    }, [viewingAgentTaskId, needsBootstrap, setAppState]);
 672    const store = useAppStateStore();
 673    const terminal = useTerminalNotification();
 674    const mainLoopModel = useMainLoopModel();
 675  
 676    // Note: standaloneAgentContext is initialized in main.tsx (via initialState) or
 677    // ResumeConversation.tsx (via setAppState before rendering REPL) to avoid
 678    // useEffect-based state initialization on mount (per CLAUDE.md guidelines)
 679  
 680    // Local state for commands (hot-reloadable when skill files change)
 681    const [localCommands, setLocalCommands] = useState(initialCommands);
 682  
 683    // Watch for skill file changes and reload all commands
 684    useSkillsChange(isRemoteSession ? undefined : getProjectRoot(), setLocalCommands);
 685  
 686    // Track proactive mode for tools dependency - SleepTool filters by proactive state
 687    const proactiveActive = React.useSyncExternalStore(proactiveModule?.subscribeToProactiveChanges ?? PROACTIVE_NO_OP_SUBSCRIBE, proactiveModule?.isProactiveActive ?? PROACTIVE_FALSE);
 688  
 689    // BriefTool.isEnabled() reads getUserMsgOptIn() from bootstrap state, which
 690    // /brief flips mid-session alongside isBriefOnly. The memo below needs a
 691    // React-visible dep to re-run getTools() when that happens; isBriefOnly is
 692    // the AppState mirror that triggers the re-render. Without this, toggling
 693    // /brief mid-session leaves the stale tool list (no SendUserMessage) and
 694    // the model emits plain text the brief filter hides.
 695    const isBriefOnly = useAppState(s => s.isBriefOnly);
 696    const localTools = useMemo(() => getTools(toolPermissionContext), [toolPermissionContext, proactiveActive, isBriefOnly]);
 697    useKickOffCheckAndDisableBypassPermissionsIfNeeded();
 698    useKickOffCheckAndDisableAutoModeIfNeeded();
 699    const [dynamicMcpConfig, setDynamicMcpConfig] = useState<Record<string, ScopedMcpServerConfig> | undefined>(initialDynamicMcpConfig);
 700    const onChangeDynamicMcpConfig = useCallback((config: Record<string, ScopedMcpServerConfig>) => {
 701      setDynamicMcpConfig(config);
 702    }, [setDynamicMcpConfig]);
 703    const [screen, setScreen] = useState<Screen>('prompt');
 704    const [showAllInTranscript, setShowAllInTranscript] = useState(false);
 705    // [ forces the dump-to-scrollback path inside transcript mode. Separate
 706    // from CLAUDE_CODE_NO_FLICKER=0 (which is process-lifetime) — this is
 707    // ephemeral, reset on transcript exit. Diagnostic escape hatch so
 708    // terminal/tmux native cmd-F can search the full flat render.
 709    const [dumpMode, setDumpMode] = useState(false);
 710    // v-for-editor render progress. Inline in the footer — notifications
 711    // render inside PromptInput which isn't mounted in transcript.
 712    const [editorStatus, setEditorStatus] = useState('');
 713    // Incremented on transcript exit. Async v-render captures this at start;
 714    // each status write no-ops if stale (user left transcript mid-render —
 715    // the stable setState would otherwise stamp a ghost toast into the next
 716    // session). Also clears any pending 4s auto-clear.
 717    const editorGenRef = useRef(0);
 718    const editorTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
 719    const editorRenderingRef = useRef(false);
 720    const {
 721      addNotification,
 722      removeNotification
 723    } = useNotifications();
 724  
 725    // eslint-disable-next-line prefer-const
 726    let trySuggestBgPRIntercept = SUGGEST_BG_PR_NOOP;
 727    const mcpClients = useMergedClients(initialMcpClients, mcp.clients);
 728  
 729    // IDE integration
 730    const [ideSelection, setIDESelection] = useState<IDESelection | undefined>(undefined);
 731    const [ideToInstallExtension, setIDEToInstallExtension] = useState<IdeType | null>(null);
 732    const [ideInstallationStatus, setIDEInstallationStatus] = useState<IDEExtensionInstallationStatus | null>(null);
 733    const [showIdeOnboarding, setShowIdeOnboarding] = useState(false);
 734    // Dead code elimination: model switch callout state (ant-only)
 735    const [showModelSwitchCallout, setShowModelSwitchCallout] = useState(() => {
 736      if ("external" === 'ant') {
 737        return shouldShowAntModelSwitch();
 738      }
 739      return false;
 740    });
 741    const [showEffortCallout, setShowEffortCallout] = useState(() => shouldShowEffortCallout(mainLoopModel));
 742    const showRemoteCallout = useAppState(s => s.showRemoteCallout);
 743    const [showDesktopUpsellStartup, setShowDesktopUpsellStartup] = useState(() => shouldShowDesktopUpsellStartup());
 744    // notifications
 745    useModelMigrationNotifications();
 746    useCanSwitchToExistingSubscription();
 747    useIDEStatusIndicator({
 748      ideSelection,
 749      mcpClients,
 750      ideInstallationStatus
 751    });
 752    useMcpConnectivityStatus({
 753      mcpClients
 754    });
 755    useAutoModeUnavailableNotification();
 756    usePluginInstallationStatus();
 757    usePluginAutoupdateNotification();
 758    useSettingsErrors();
 759    useRateLimitWarningNotification(mainLoopModel);
 760    useFastModeNotification();
 761    useDeprecationWarningNotification(mainLoopModel);
 762    useNpmDeprecationNotification();
 763    useAntOrgWarningNotification();
 764    useInstallMessages();
 765    useChromeExtensionNotification();
 766    useOfficialMarketplaceNotification();
 767    useLspInitializationNotification();
 768    useTeammateLifecycleNotification();
 769    const {
 770      recommendation: lspRecommendation,
 771      handleResponse: handleLspResponse
 772    } = useLspPluginRecommendation();
 773    const {
 774      recommendation: hintRecommendation,
 775      handleResponse: handleHintResponse
 776    } = useClaudeCodeHintRecommendation();
 777  
 778    // Memoize the combined initial tools array to prevent reference changes
 779    const combinedInitialTools = useMemo(() => {
 780      return [...localTools, ...initialTools];
 781    }, [localTools, initialTools]);
 782  
 783    // Initialize plugin management
 784    useManagePlugins({
 785      enabled: !isRemoteSession
 786    });
 787    const tasksV2 = useTasksV2WithCollapseEffect();
 788  
 789    // Start background plugin installations
 790  
 791    // SECURITY: This code is guaranteed to run ONLY after the "trust this folder" dialog
 792    // has been confirmed by the user. The trust dialog is shown in cli.tsx (line ~387)
 793    // before the REPL component is rendered. The dialog blocks execution until the user
 794    // accepts, and only then is the REPL component mounted and this effect runs.
 795    // This ensures that plugin installations from repository and user settings only
 796    // happen after explicit user consent to trust the current working directory.
 797    useEffect(() => {
 798      if (isRemoteSession) return;
 799      void performStartupChecks(setAppState);
 800    }, [setAppState, isRemoteSession]);
 801  
 802    // Allow Claude in Chrome MCP to send prompts through MCP notifications
 803    // and sync permission mode changes to the Chrome extension
 804    usePromptsFromClaudeInChrome(isRemoteSession ? EMPTY_MCP_CLIENTS : mcpClients, toolPermissionContext.mode);
 805  
 806    // Initialize swarm features: teammate hooks and context
 807    // Handles both fresh spawns and resumed teammate sessions
 808    useSwarmInitialization(setAppState, initialMessages, {
 809      enabled: !isRemoteSession
 810    });
 811    const mergedTools = useMergedTools(combinedInitialTools, mcp.tools, toolPermissionContext);
 812  
 813    // Apply agent tool restrictions if mainThreadAgentDefinition is set
 814    const {
 815      tools,
 816      allowedAgentTypes
 817    } = useMemo(() => {
 818      if (!mainThreadAgentDefinition) {
 819        return {
 820          tools: mergedTools,
 821          allowedAgentTypes: undefined as string[] | undefined
 822        };
 823      }
 824      const resolved = resolveAgentTools(mainThreadAgentDefinition, mergedTools, false, true);
 825      return {
 826        tools: resolved.resolvedTools,
 827        allowedAgentTypes: resolved.allowedAgentTypes
 828      };
 829    }, [mainThreadAgentDefinition, mergedTools]);
 830  
 831    // Merge commands from local state, plugins, and MCP
 832    const commandsWithPlugins = useMergedCommands(localCommands, plugins.commands as Command[]);
 833    const mergedCommands = useMergedCommands(commandsWithPlugins, mcp.commands as Command[]);
 834    // Filter out all commands if disableSlashCommands is true
 835    const commands = useMemo(() => disableSlashCommands ? [] : mergedCommands, [disableSlashCommands, mergedCommands]);
 836    useIdeLogging(isRemoteSession ? EMPTY_MCP_CLIENTS : mcp.clients);
 837    useIdeSelection(isRemoteSession ? EMPTY_MCP_CLIENTS : mcp.clients, setIDESelection);
 838    const [streamMode, setStreamMode] = useState<SpinnerMode>('responding');
 839    // Ref mirror so onSubmit can read the latest value without adding
 840    // streamMode to its deps. streamMode flips between
 841    // requesting/responding/tool-use ~10x per turn during streaming; having it
 842    // in onSubmit's deps was recreating onSubmit on every flip, which
 843    // cascaded into PromptInput prop churn and downstream useCallback/useMemo
 844    // invalidation. The only consumers inside callbacks are debug logging and
 845    // telemetry (handlePromptSubmit.ts), so a stale-by-one-render value is
 846    // harmless — but ref mirrors sync on every render anyway so it's fresh.
 847    const streamModeRef = useRef(streamMode);
 848    streamModeRef.current = streamMode;
 849    const [streamingToolUses, setStreamingToolUses] = useState<StreamingToolUse[]>([]);
 850    const [streamingThinking, setStreamingThinking] = useState<StreamingThinking | null>(null);
 851  
 852    // Auto-hide streaming thinking after 30 seconds of being completed
 853    useEffect(() => {
 854      if (streamingThinking && !streamingThinking.isStreaming && streamingThinking.streamingEndedAt) {
 855        const elapsed = Date.now() - streamingThinking.streamingEndedAt;
 856        const remaining = 30000 - elapsed;
 857        if (remaining > 0) {
 858          const timer = setTimeout(setStreamingThinking, remaining, null);
 859          return () => clearTimeout(timer);
 860        } else {
 861          setStreamingThinking(null);
 862        }
 863      }
 864    }, [streamingThinking]);
 865    const [abortController, setAbortController] = useState<AbortController | null>(null);
 866    // Ref that always points to the current abort controller, used by the
 867    // REPL bridge to abort the active query when a remote interrupt arrives.
 868    const abortControllerRef = useRef<AbortController | null>(null);
 869    abortControllerRef.current = abortController;
 870  
 871    // Ref for the bridge result callback — set after useReplBridge initializes,
 872    // read in the onQuery finally block to notify mobile clients that a turn ended.
 873    const sendBridgeResultRef = useRef<() => void>(() => {});
 874  
 875    // Ref for the synchronous restore callback — set after restoreMessageSync is
 876    // defined, read in the onQuery finally block for auto-restore on interrupt.
 877    const restoreMessageSyncRef = useRef<(m: UserMessage) => void>(() => {});
 878  
 879    // Ref to the fullscreen layout's scroll box for keyboard scrolling.
 880    // Null when fullscreen mode is disabled (ref never attached).
 881    const scrollRef = useRef<ScrollBoxHandle>(null);
 882    // Separate ref for the modal slot's inner ScrollBox — passed through
 883    // FullscreenLayout → ModalContext so Tabs can attach it to its own
 884    // ScrollBox for tall content (e.g. /status's MCP-server list). NOT
 885    // keyboard-driven — ScrollKeybindingHandler stays on the outer ref so
 886    // PgUp/PgDn/wheel always scroll the transcript behind the modal.
 887    // Plumbing kept for future modal-scroll wiring.
 888    const modalScrollRef = useRef<ScrollBoxHandle>(null);
 889    // Timestamp of the last user-initiated scroll (wheel, PgUp/PgDn, ctrl+u,
 890    // End/Home, G, drag-to-scroll). Stamped in composedOnScroll — the single
 891    // chokepoint ScrollKeybindingHandler calls for every user scroll action.
 892    // Programmatic scrolls (repinScroll's scrollToBottom, sticky auto-follow)
 893    // do NOT go through composedOnScroll, so they don't stamp this. Ref not
 894    // state: no re-render on every wheel tick.
 895    const lastUserScrollTsRef = useRef(0);
 896  
 897    // Synchronous state machine for the query lifecycle. Replaces the
 898    // error-prone dual-state pattern where isLoading (React state, async
 899    // batched) and isQueryRunning (ref, sync) could desync. See QueryGuard.ts.
 900    const queryGuard = React.useRef(new QueryGuard()).current;
 901  
 902    // Subscribe to the guard — true during dispatching or running.
 903    // This is the single source of truth for "is a local query in flight".
 904    const isQueryActive = React.useSyncExternalStore(queryGuard.subscribe, queryGuard.getSnapshot);
 905  
 906    // Separate loading flag for operations outside the local query guard:
 907    // remote sessions (useRemoteSession / useDirectConnect) and foregrounded
 908    // background tasks (useSessionBackgrounding). These don't route through
 909    // onQuery / queryGuard, so they need their own spinner-visibility state.
 910    // Initialize true if remote mode with initial prompt (CCR processing it).
 911    const [isExternalLoading, setIsExternalLoadingRaw] = React.useState(remoteSessionConfig?.hasInitialPrompt ?? false);
 912  
 913    // Derived: any loading source active. Read-only — no setter. Local query
 914    // loading is driven by queryGuard (reserve/tryStart/end/cancelReservation),
 915    // external loading by setIsExternalLoading.
 916    const isLoading = isQueryActive || isExternalLoading;
 917  
 918    // Elapsed time is computed by SpinnerWithVerb from these refs on each
 919    // animation frame, avoiding a useInterval that re-renders the entire REPL.
 920    const [userInputOnProcessing, setUserInputOnProcessingRaw] = React.useState<string | undefined>(undefined);
 921    // messagesRef.current.length at the moment userInputOnProcessing was set.
 922    // The placeholder hides once displayedMessages grows past this — i.e. the
 923    // real user message has landed in the visible transcript.
 924    const userInputBaselineRef = React.useRef(0);
 925    // True while the submitted prompt is being processed but its user message
 926    // hasn't reached setMessages yet. setMessages uses this to keep the
 927    // baseline in sync when unrelated async messages (bridge status, hook
 928    // results, scheduled tasks) land during that window.
 929    const userMessagePendingRef = React.useRef(false);
 930  
 931    // Wall-clock time tracking refs for accurate elapsed time calculation
 932    const loadingStartTimeRef = React.useRef<number>(0);
 933    const totalPausedMsRef = React.useRef(0);
 934    const pauseStartTimeRef = React.useRef<number | null>(null);
 935    const resetTimingRefs = React.useCallback(() => {
 936      loadingStartTimeRef.current = Date.now();
 937      totalPausedMsRef.current = 0;
 938      pauseStartTimeRef.current = null;
 939    }, []);
 940  
 941    // Reset timing refs inline when isQueryActive transitions false→true.
 942    // queryGuard.reserve() (in executeUserInput) fires BEFORE processUserInput's
 943    // first await, but the ref reset in onQuery's try block runs AFTER. During
 944    // that gap, React renders the spinner with loadingStartTimeRef=0, computing
 945    // elapsedTimeMs = Date.now() - 0 ≈ 56 years. This inline reset runs on the
 946    // first render where isQueryActive is observed true — the same render that
 947    // first shows the spinner — so the ref is correct by the time the spinner
 948    // reads it. See INC-4549.
 949    const wasQueryActiveRef = React.useRef(false);
 950    if (isQueryActive && !wasQueryActiveRef.current) {
 951      resetTimingRefs();
 952    }
 953    wasQueryActiveRef.current = isQueryActive;
 954  
 955    // Wrapper for setIsExternalLoading that resets timing refs on transition
 956    // to true — SpinnerWithVerb reads these for elapsed time, so they must be
 957    // reset for remote sessions / foregrounded tasks too (not just local
 958    // queries, which reset them in onQuery). Without this, a remote-only
 959    // session would show ~56 years elapsed (Date.now() - 0).
 960    const setIsExternalLoading = React.useCallback((value: boolean) => {
 961      setIsExternalLoadingRaw(value);
 962      if (value) resetTimingRefs();
 963    }, [resetTimingRefs]);
 964  
 965    // Start time of the first turn that had swarm teammates running
 966    // Used to compute total elapsed time (including teammate execution) for the deferred message
 967    const swarmStartTimeRef = React.useRef<number | null>(null);
 968    const swarmBudgetInfoRef = React.useRef<{
 969      tokens: number;
 970      limit: number;
 971      nudges: number;
 972    } | undefined>(undefined);
 973  
 974    // Ref to track current focusedInputDialog for use in callbacks
 975    // This avoids stale closures when checking dialog state in timer callbacks
 976    const focusedInputDialogRef = React.useRef<ReturnType<typeof getFocusedInputDialog>>(undefined);
 977  
 978    // How long after the last keystroke before deferred dialogs are shown
 979    const PROMPT_SUPPRESSION_MS = 1500;
 980    // True when user is actively typing — defers interrupt dialogs so keystrokes
 981    // don't accidentally dismiss or answer a permission prompt the user hasn't read yet.
 982    const [isPromptInputActive, setIsPromptInputActive] = React.useState(false);
 983    const [autoUpdaterResult, setAutoUpdaterResult] = useState<AutoUpdaterResult | null>(null);
 984    useEffect(() => {
 985      if (autoUpdaterResult?.notifications) {
 986        autoUpdaterResult.notifications.forEach(notification => {
 987          addNotification({
 988            key: 'auto-updater-notification',
 989            text: notification,
 990            priority: 'low'
 991          });
 992        });
 993      }
 994    }, [autoUpdaterResult, addNotification]);
 995  
 996    // tmux + fullscreen + `mouse off`: one-time hint that wheel won't scroll.
 997    // We no longer mutate tmux's session-scoped mouse option (it poisoned
 998    // sibling panes); tmux users already know this tradeoff from vim/less.
 999    useEffect(() => {
1000      if (isFullscreenEnvEnabled()) {
1001        void maybeGetTmuxMouseHint().then(hint => {
1002          if (hint) {
1003            addNotification({
1004              key: 'tmux-mouse-hint',
1005              text: hint,
1006              priority: 'low'
1007            });
1008          }
1009        });
1010      }
1011      // eslint-disable-next-line react-hooks/exhaustive-deps
1012    }, []);
1013    const [showUndercoverCallout, setShowUndercoverCallout] = useState(false);
1014    useEffect(() => {
1015      if ("external" === 'ant') {
1016        void (async () => {
1017          // Wait for repo classification to settle (memoized, no-op if primed).
1018          const {
1019            isInternalModelRepo
1020          } = await import('../utils/commitAttribution.js');
1021          await isInternalModelRepo();
1022          const {
1023            shouldShowUndercoverAutoNotice
1024          } = await import('../utils/undercover.js');
1025          if (shouldShowUndercoverAutoNotice()) {
1026            setShowUndercoverCallout(true);
1027          }
1028        })();
1029      }
1030      // eslint-disable-next-line react-hooks/exhaustive-deps
1031    }, []);
1032    const [toolJSX, setToolJSXInternal] = useState<{
1033      jsx: React.ReactNode | null;
1034      shouldHidePromptInput: boolean;
1035      shouldContinueAnimation?: true;
1036      showSpinner?: boolean;
1037      isLocalJSXCommand?: boolean;
1038      isImmediate?: boolean;
1039    } | null>(null);
1040  
1041    // Track local JSX commands separately so tools can't overwrite them.
1042    // This enables "immediate" commands (like /btw) to persist while Claude is processing.
1043    const localJSXCommandRef = useRef<{
1044      jsx: React.ReactNode | null;
1045      shouldHidePromptInput: boolean;
1046      shouldContinueAnimation?: true;
1047      showSpinner?: boolean;
1048      isLocalJSXCommand: true;
1049    } | null>(null);
1050  
1051    // Wrapper for setToolJSX that preserves local JSX commands (like /btw).
1052    // When a local JSX command is active, we ignore updates from tools
1053    // unless they explicitly set clearLocalJSX: true (from onDone callbacks).
1054    //
1055    // TO ADD A NEW IMMEDIATE COMMAND:
1056    // 1. Set `immediate: true` in the command definition
1057    // 2. Set `isLocalJSXCommand: true` when calling setToolJSX in the command's JSX
1058    // 3. In the onDone callback, use `setToolJSX({ jsx: null, shouldHidePromptInput: false, clearLocalJSX: true })`
1059    //    to explicitly clear the overlay when the user dismisses it
1060    const setToolJSX = useCallback((args: {
1061      jsx: React.ReactNode | null;
1062      shouldHidePromptInput: boolean;
1063      shouldContinueAnimation?: true;
1064      showSpinner?: boolean;
1065      isLocalJSXCommand?: boolean;
1066      clearLocalJSX?: boolean;
1067    } | null) => {
1068      // If setting a local JSX command, store it in the ref
1069      if (args?.isLocalJSXCommand) {
1070        const {
1071          clearLocalJSX: _,
1072          ...rest
1073        } = args;
1074        localJSXCommandRef.current = {
1075          ...rest,
1076          isLocalJSXCommand: true
1077        };
1078        setToolJSXInternal(rest);
1079        return;
1080      }
1081  
1082      // If there's an active local JSX command in the ref
1083      if (localJSXCommandRef.current) {
1084        // Allow clearing only if explicitly requested (from onDone callbacks)
1085        if (args?.clearLocalJSX) {
1086          localJSXCommandRef.current = null;
1087          setToolJSXInternal(null);
1088          return;
1089        }
1090        // Otherwise, keep the local JSX command visible - ignore tool updates
1091        return;
1092      }
1093  
1094      // No active local JSX command, allow any update
1095      if (args?.clearLocalJSX) {
1096        setToolJSXInternal(null);
1097        return;
1098      }
1099      setToolJSXInternal(args);
1100    }, []);
1101    const [toolUseConfirmQueue, setToolUseConfirmQueue] = useState<ToolUseConfirm[]>([]);
1102    // Sticky footer JSX registered by permission request components (currently
1103    // only ExitPlanModePermissionRequest). Renders in FullscreenLayout's `bottom`
1104    // slot so response options stay visible while the user scrolls a long plan.
1105    const [permissionStickyFooter, setPermissionStickyFooter] = useState<React.ReactNode | null>(null);
1106    const [sandboxPermissionRequestQueue, setSandboxPermissionRequestQueue] = useState<Array<{
1107      hostPattern: NetworkHostPattern;
1108      resolvePromise: (allowConnection: boolean) => void;
1109    }>>([]);
1110    const [promptQueue, setPromptQueue] = useState<Array<{
1111      request: PromptRequest;
1112      title: string;
1113      toolInputSummary?: string | null;
1114      resolve: (response: PromptResponse) => void;
1115      reject: (error: Error) => void;
1116    }>>([]);
1117  
1118    // Track bridge cleanup functions for sandbox permission requests so the
1119    // local dialog handler can cancel the remote prompt when the local user
1120    // responds first. Keyed by host to support concurrent same-host requests.
1121    const sandboxBridgeCleanupRef = useRef<Map<string, Array<() => void>>>(new Map());
1122  
1123    // -- Terminal title management
1124    // Session title (set via /rename or restored on resume) wins over
1125    // the agent name, which wins over the Haiku-extracted topic;
1126    // all fall back to the product name.
1127    const terminalTitleFromRename = useAppState(s => s.settings.terminalTitleFromRename) !== false;
1128    const sessionTitle = terminalTitleFromRename ? getCurrentSessionTitle(getSessionId()) : undefined;
1129    const [haikuTitle, setHaikuTitle] = useState<string>();
1130    // Gates the one-shot Haiku call that generates the tab title. Seeded true
1131    // on resume (initialMessages present) so we don't re-title a resumed
1132    // session from mid-conversation context.
1133    const haikuTitleAttemptedRef = useRef((initialMessages?.length ?? 0) > 0);
1134    const agentTitle = mainThreadAgentDefinition?.agentType;
1135    const terminalTitle = sessionTitle ?? agentTitle ?? haikuTitle ?? 'Claude Code';
1136    const isWaitingForApproval = toolUseConfirmQueue.length > 0 || promptQueue.length > 0 || pendingWorkerRequest || pendingSandboxRequest;
1137    // Local-jsx commands (like /plugin, /config) show user-facing dialogs that
1138    // wait for input. Require jsx != null — if the flag is stuck true but jsx
1139    // is null, treat as not-showing so TextInput focus and queue processor
1140    // aren't deadlocked by a phantom overlay.
1141    const isShowingLocalJSXCommand = toolJSX?.isLocalJSXCommand === true && toolJSX?.jsx != null;
1142    const titleIsAnimating = isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand;
1143    // Title animation state lives in <AnimatedTerminalTitle> so the 960ms tick
1144    // doesn't re-render REPL. titleDisabled/terminalTitle are still computed
1145    // here because onQueryImpl reads them (background session description,
1146    // haiku title extraction gate).
1147  
1148    // Prevent macOS from sleeping while Claude is working
1149    useEffect(() => {
1150      if (isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand) {
1151        startPreventSleep();
1152        return () => stopPreventSleep();
1153      }
1154    }, [isLoading, isWaitingForApproval, isShowingLocalJSXCommand]);
1155    const sessionStatus: TabStatusKind = isWaitingForApproval || isShowingLocalJSXCommand ? 'waiting' : isLoading ? 'busy' : 'idle';
1156    const waitingFor = sessionStatus !== 'waiting' ? undefined : toolUseConfirmQueue.length > 0 ? `approve ${toolUseConfirmQueue[0]!.tool.name}` : pendingWorkerRequest ? 'worker request' : pendingSandboxRequest ? 'sandbox request' : isShowingLocalJSXCommand ? 'dialog open' : 'input needed';
1157  
1158    // Push status to the PID file for `claude ps`. Fire-and-forget; ps falls
1159    // back to transcript-tail derivation when this is missing/stale.
1160    useEffect(() => {
1161      if (feature('BG_SESSIONS')) {
1162        void updateSessionActivity({
1163          status: sessionStatus,
1164          waitingFor
1165        });
1166      }
1167    }, [sessionStatus, waitingFor]);
1168  
1169    // 3P default: off — OSC 21337 is ant-only while the spec stabilizes.
1170    // Gated so we can roll back if the sidebar indicator conflicts with
1171    // the title spinner in terminals that render both. When the flag is
1172    // on, the user-facing config setting controls whether it's active.
1173    const tabStatusGateEnabled = getFeatureValue_CACHED_MAY_BE_STALE('tengu_terminal_sidebar', false);
1174    const showStatusInTerminalTab = tabStatusGateEnabled && (getGlobalConfig().showStatusInTerminalTab ?? false);
1175    useTabStatus(titleDisabled || !showStatusInTerminalTab ? null : sessionStatus);
1176  
1177    // Register the leader's setToolUseConfirmQueue for in-process teammates
1178    useEffect(() => {
1179      registerLeaderToolUseConfirmQueue(setToolUseConfirmQueue);
1180      return () => unregisterLeaderToolUseConfirmQueue();
1181    }, [setToolUseConfirmQueue]);
1182    const [messages, rawSetMessages] = useState<MessageType[]>(initialMessages ?? []);
1183    const messagesRef = useRef(messages);
1184    // Stores the willowMode variant that was shown (or false if no hint shown).
1185    // Captured at hint_shown time so hint_converted telemetry reports the same
1186    // variant — the GrowthBook value shouldn't change mid-session, but reading
1187    // it once guarantees consistency between the paired events.
1188    const idleHintShownRef = useRef<string | false>(false);
1189    // Wrap setMessages so messagesRef is always current the instant the
1190    // call returns — not when React later processes the batch.  Apply the
1191    // updater eagerly against the ref, then hand React the computed value
1192    // (not the function).  rawSetMessages batching becomes last-write-wins,
1193    // and the last write is correct because each call composes against the
1194    // already-updated ref.  This is the Zustand pattern: ref is source of
1195    // truth, React state is the render projection.  Without this, paths
1196    // that queue functional updaters then synchronously read the ref
1197    // (e.g. handleSpeculationAccept → onQuery) see stale data.
1198    const setMessages = useCallback((action: React.SetStateAction<MessageType[]>) => {
1199      const prev = messagesRef.current;
1200      const next = typeof action === 'function' ? action(messagesRef.current) : action;
1201      messagesRef.current = next;
1202      if (next.length < userInputBaselineRef.current) {
1203        // Shrank (compact/rewind/clear) — clamp so placeholderText's length
1204        // check can't go stale.
1205        userInputBaselineRef.current = 0;
1206      } else if (next.length > prev.length && userMessagePendingRef.current) {
1207        // Grew while the submitted user message hasn't landed yet. If the
1208        // added messages don't include it (bridge status, hook results,
1209        // scheduled tasks landing async during processUserInputBase), bump
1210        // baseline so the placeholder stays visible. Once the user message
1211        // lands, stop tracking — later additions (assistant stream) should
1212        // not re-show the placeholder.
1213        const delta = next.length - prev.length;
1214        const added = prev.length === 0 || next[0] === prev[0] ? next.slice(-delta) : next.slice(0, delta);
1215        if (added.some(isHumanTurn)) {
1216          userMessagePendingRef.current = false;
1217        } else {
1218          userInputBaselineRef.current = next.length;
1219        }
1220      }
1221      rawSetMessages(next);
1222    }, []);
1223    // Capture the baseline message count alongside the placeholder text so
1224    // the render can hide it once displayedMessages grows past the baseline.
1225    const setUserInputOnProcessing = useCallback((input: string | undefined) => {
1226      if (input !== undefined) {
1227        userInputBaselineRef.current = messagesRef.current.length;
1228        userMessagePendingRef.current = true;
1229      } else {
1230        userMessagePendingRef.current = false;
1231      }
1232      setUserInputOnProcessingRaw(input);
1233    }, []);
1234    // Fullscreen: track the unseen-divider position. dividerIndex changes
1235    // only ~twice/scroll-session (first scroll-away + repin). pillVisible
1236    // and stickyPrompt now live in FullscreenLayout — they subscribe to
1237    // ScrollBox directly so per-frame scroll never re-renders REPL.
1238    const {
1239      dividerIndex,
1240      dividerYRef,
1241      onScrollAway,
1242      onRepin,
1243      jumpToNew,
1244      shiftDivider
1245    } = useUnseenDivider(messages.length);
1246    if (feature('AWAY_SUMMARY')) {
1247      // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
1248      useAwaySummary(messages, setMessages, isLoading);
1249    }
1250    const [cursor, setCursor] = useState<MessageActionsState | null>(null);
1251    const cursorNavRef = useRef<MessageActionsNav | null>(null);
1252    // Memoized so Messages' React.memo holds.
1253    const unseenDivider = useMemo(() => computeUnseenDivider(messages, dividerIndex),
1254    // eslint-disable-next-line react-hooks/exhaustive-deps -- length change covers appends; useUnseenDivider's count-drop guard clears dividerIndex on replace/rewind
1255    [dividerIndex, messages.length]);
1256    // Re-pin scroll to bottom and clear the unseen-messages baseline. Called
1257    // on any user-driven return-to-live action (submit, type-into-empty,
1258    // overlay appear/dismiss).
1259    const repinScroll = useCallback(() => {
1260      scrollRef.current?.scrollToBottom();
1261      onRepin();
1262      setCursor(null);
1263    }, [onRepin, setCursor]);
1264    // Backstop for the submit-handler repin at onSubmit. If a buffered stdin
1265    // event (wheel/drag) races between handler-fire and state-commit, the
1266    // handler's scrollToBottom can be undone. This effect fires on the render
1267    // where the user's message actually lands — tied to React's commit cycle,
1268    // so it can't race with stdin. Keyed on lastMsg identity (not messages.length)
1269    // so useAssistantHistory's prepends don't spuriously repin.
1270    const lastMsg = messages.at(-1);
1271    const lastMsgIsHuman = lastMsg != null && isHumanTurn(lastMsg);
1272    useEffect(() => {
1273      if (lastMsgIsHuman) {
1274        repinScroll();
1275      }
1276    }, [lastMsgIsHuman, lastMsg, repinScroll]);
1277    // Assistant-chat: lazy-load remote history on scroll-up. No-op unless
1278    // KAIROS build + config.viewerOnly. feature() is build-time constant so
1279    // the branch is dead-code-eliminated in non-KAIROS builds (same pattern
1280    // as useUnseenDivider above).
1281    const {
1282      maybeLoadOlder
1283    } = feature('KAIROS') ?
1284    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
1285    useAssistantHistory({
1286      config: remoteSessionConfig,
1287      setMessages,
1288      scrollRef,
1289      onPrepend: shiftDivider
1290    }) : HISTORY_STUB;
1291    // Compose useUnseenDivider's callbacks with the lazy-load trigger.
1292    const composedOnScroll = useCallback((sticky: boolean, handle: ScrollBoxHandle) => {
1293      lastUserScrollTsRef.current = Date.now();
1294      if (sticky) {
1295        onRepin();
1296      } else {
1297        onScrollAway(handle);
1298        if (feature('KAIROS')) maybeLoadOlder(handle);
1299        // Dismiss the companion bubble on scroll — it's absolute-positioned
1300        // at bottom-right and covers transcript content. Scrolling = user is
1301        // trying to read something under it.
1302        if (feature('BUDDY')) {
1303          setAppState(prev => prev.companionReaction === undefined ? prev : {
1304            ...prev,
1305            companionReaction: undefined
1306          });
1307        }
1308      }
1309    }, [onRepin, onScrollAway, maybeLoadOlder, setAppState]);
1310    // Deferred SessionStart hook messages — REPL renders immediately and
1311    // hook messages are injected when they resolve. awaitPendingHooks()
1312    // must be called before the first API call so the model sees hook context.
1313    const awaitPendingHooks = useDeferredHookMessages(pendingHookMessages, setMessages);
1314  
1315    // Deferred messages for the Messages component — renders at transition
1316    // priority so the reconciler yields every 5ms, keeping input responsive
1317    // while the expensive message processing pipeline runs.
1318    const deferredMessages = useDeferredValue(messages);
1319    const deferredBehind = messages.length - deferredMessages.length;
1320    if (deferredBehind > 0) {
1321      logForDebugging(`[useDeferredValue] Messages deferred by ${deferredBehind} (${deferredMessages.length}→${messages.length})`);
1322    }
1323  
1324    // Frozen state for transcript mode - stores lengths instead of cloning arrays for memory efficiency
1325    const [frozenTranscriptState, setFrozenTranscriptState] = useState<{
1326      messagesLength: number;
1327      streamingToolUsesLength: number;
1328    } | null>(null);
1329    // Initialize input with any early input that was captured before REPL was ready.
1330    // Using lazy initialization ensures cursor offset is set correctly in PromptInput.
1331    const [inputValue, setInputValueRaw] = useState(() => consumeEarlyInput());
1332    const inputValueRef = useRef(inputValue);
1333    inputValueRef.current = inputValue;
1334    const insertTextRef = useRef<{
1335      insert: (text: string) => void;
1336      setInputWithCursor: (value: string, cursor: number) => void;
1337      cursorOffset: number;
1338    } | null>(null);
1339  
1340    // Wrap setInputValue to co-locate suppression state updates.
1341    // Both setState calls happen in the same synchronous context so React
1342    // batches them into a single render, eliminating the extra render that
1343    // the previous useEffect → setState pattern caused.
1344    const setInputValue = useCallback((value: string) => {
1345      if (trySuggestBgPRIntercept(inputValueRef.current, value)) return;
1346      // In fullscreen mode, typing into an empty prompt re-pins scroll to
1347      // bottom. Only fires on empty→non-empty so scrolling up to reference
1348      // something while composing a message doesn't yank the view back on
1349      // every keystroke. Restores the pre-fullscreen muscle memory of
1350      // typing to snap back to the end of the conversation.
1351      // Skipped if the user scrolled within the last 3s — they're actively
1352      // reading, not lost. lastUserScrollTsRef starts at 0 so the first-
1353      // ever keypress (no scroll yet) always repins.
1354      if (inputValueRef.current === '' && value !== '' && Date.now() - lastUserScrollTsRef.current >= RECENT_SCROLL_REPIN_WINDOW_MS) {
1355        repinScroll();
1356      }
1357      // Sync ref immediately (like setMessages) so callers that read
1358      // inputValueRef before React commits — e.g. the auto-restore finally
1359      // block's `=== ''` guard — see the fresh value, not the stale render.
1360      inputValueRef.current = value;
1361      setInputValueRaw(value);
1362      setIsPromptInputActive(value.trim().length > 0);
1363    }, [setIsPromptInputActive, repinScroll, trySuggestBgPRIntercept]);
1364  
1365    // Schedule a timeout to stop suppressing dialogs after the user stops typing.
1366    // Only manages the timeout — the immediate activation is handled by setInputValue above.
1367    useEffect(() => {
1368      if (inputValue.trim().length === 0) return;
1369      const timer = setTimeout(setIsPromptInputActive, PROMPT_SUPPRESSION_MS, false);
1370      return () => clearTimeout(timer);
1371    }, [inputValue]);
1372    const [inputMode, setInputMode] = useState<PromptInputMode>('prompt');
1373    const [stashedPrompt, setStashedPrompt] = useState<{
1374      text: string;
1375      cursorOffset: number;
1376      pastedContents: Record<number, PastedContent>;
1377    } | undefined>();
1378  
1379    // Callback to filter commands based on CCR's available slash commands
1380    const handleRemoteInit = useCallback((remoteSlashCommands: string[]) => {
1381      const remoteCommandSet = new Set(remoteSlashCommands);
1382      // Keep commands that CCR lists OR that are in the local-safe set
1383      setLocalCommands(prev => prev.filter(cmd => remoteCommandSet.has(cmd.name) || REMOTE_SAFE_COMMANDS.has(cmd)));
1384    }, [setLocalCommands]);
1385    const [inProgressToolUseIDs, setInProgressToolUseIDs] = useState<Set<string>>(new Set());
1386    const hasInterruptibleToolInProgressRef = useRef(false);
1387  
1388    // Remote session hook - manages WebSocket connection and message handling for --remote mode
1389    const remoteSession = useRemoteSession({
1390      config: remoteSessionConfig,
1391      setMessages,
1392      setIsLoading: setIsExternalLoading,
1393      onInit: handleRemoteInit,
1394      setToolUseConfirmQueue,
1395      tools: combinedInitialTools,
1396      setStreamingToolUses,
1397      setStreamMode,
1398      setInProgressToolUseIDs
1399    });
1400  
1401    // Direct connect hook - manages WebSocket to a claude server for `claude connect` mode
1402    const directConnect = useDirectConnect({
1403      config: directConnectConfig,
1404      setMessages,
1405      setIsLoading: setIsExternalLoading,
1406      setToolUseConfirmQueue,
1407      tools: combinedInitialTools
1408    });
1409  
1410    // SSH session hook - manages ssh child process for `claude ssh` mode.
1411    // Same callback shape as useDirectConnect; only the transport under the
1412    // hood differs (ChildProcess stdin/stdout vs WebSocket).
1413    const sshRemote = useSSHSession({
1414      session: sshSession,
1415      setMessages,
1416      setIsLoading: setIsExternalLoading,
1417      setToolUseConfirmQueue,
1418      tools: combinedInitialTools
1419    });
1420  
1421    // Use whichever remote mode is active
1422    const activeRemote = sshRemote.isRemoteMode ? sshRemote : directConnect.isRemoteMode ? directConnect : remoteSession;
1423    const [pastedContents, setPastedContents] = useState<Record<number, PastedContent>>({});
1424    const [submitCount, setSubmitCount] = useState(0);
1425    // Ref instead of state to avoid triggering React re-renders on every
1426    // streaming text_delta. The spinner reads this via its animation timer.
1427    const responseLengthRef = useRef(0);
1428    // API performance metrics ref for ant-only spinner display (TTFT/OTPS).
1429    // Accumulates metrics from all API requests in a turn for P50 aggregation.
1430    const apiMetricsRef = useRef<Array<{
1431      ttftMs: number;
1432      firstTokenTime: number;
1433      lastTokenTime: number;
1434      responseLengthBaseline: number;
1435      // Tracks responseLengthRef at the time of the last content addition.
1436      // Updated by both streaming deltas and subagent message content.
1437      // lastTokenTime is also updated at the same time, so the OTPS
1438      // denominator correctly includes subagent processing time.
1439      endResponseLength: number;
1440    }>>([]);
1441    const setResponseLength = useCallback((f: (prev: number) => number) => {
1442      const prev = responseLengthRef.current;
1443      responseLengthRef.current = f(prev);
1444      // When content is added (not a compaction reset), update the latest
1445      // metrics entry so OTPS reflects all content generation activity.
1446      // Updating lastTokenTime here ensures the denominator includes both
1447      // streaming time AND subagent execution time, preventing inflation.
1448      if (responseLengthRef.current > prev) {
1449        const entries = apiMetricsRef.current;
1450        if (entries.length > 0) {
1451          const lastEntry = entries.at(-1)!;
1452          lastEntry.lastTokenTime = Date.now();
1453          lastEntry.endResponseLength = responseLengthRef.current;
1454        }
1455      }
1456    }, []);
1457  
1458    // Streaming text display: set state directly per delta (Ink's 16ms render
1459    // throttle batches rapid updates). Cleared on message arrival (messages.ts)
1460    // so displayedMessages switches from deferredMessages to messages atomically.
1461    const [streamingText, setStreamingText] = useState<string | null>(null);
1462    const reducedMotion = useAppState(s => s.settings.prefersReducedMotion) ?? false;
1463    const showStreamingText = !reducedMotion && !hasCursorUpViewportYankBug();
1464    const onStreamingText = useCallback((f: (current: string | null) => string | null) => {
1465      if (!showStreamingText) return;
1466      setStreamingText(f);
1467    }, [showStreamingText]);
1468  
1469    // Hide the in-progress source line so text streams line-by-line, not
1470    // char-by-char. lastIndexOf returns -1 when no newline, giving '' → null.
1471    // Guard on showStreamingText so toggling reducedMotion mid-stream
1472    // immediately hides the streaming preview.
1473    const visibleStreamingText = streamingText && showStreamingText ? streamingText.substring(0, streamingText.lastIndexOf('\n') + 1) || null : null;
1474    const [lastQueryCompletionTime, setLastQueryCompletionTime] = useState(0);
1475    const [spinnerMessage, setSpinnerMessage] = useState<string | null>(null);
1476    const [spinnerColor, setSpinnerColor] = useState<keyof Theme | null>(null);
1477    const [spinnerShimmerColor, setSpinnerShimmerColor] = useState<keyof Theme | null>(null);
1478    const [isMessageSelectorVisible, setIsMessageSelectorVisible] = useState(false);
1479    const [messageSelectorPreselect, setMessageSelectorPreselect] = useState<UserMessage | undefined>(undefined);
1480    const [showCostDialog, setShowCostDialog] = useState(false);
1481    const [conversationId, setConversationId] = useState(randomUUID());
1482  
1483    // Idle-return dialog: shown when user submits after a long idle gap
1484    const [idleReturnPending, setIdleReturnPending] = useState<{
1485      input: string;
1486      idleMinutes: number;
1487    } | null>(null);
1488    const skipIdleCheckRef = useRef(false);
1489    const lastQueryCompletionTimeRef = useRef(lastQueryCompletionTime);
1490    lastQueryCompletionTimeRef.current = lastQueryCompletionTime;
1491  
1492    // Aggregate tool result budget: per-conversation decision tracking.
1493    // When the GrowthBook flag is on, query.ts enforces the budget; when
1494    // off (undefined), enforcement is skipped entirely. Stale entries after
1495    // /clear, rewind, or compact are harmless (tool_use_ids are UUIDs, stale
1496    // keys are never looked up). Memory is bounded by total replacement count
1497    // × ~2KB preview over the REPL lifetime — negligible.
1498    //
1499    // Lazy init via useState initializer — useRef(expr) evaluates expr on every
1500    // render (React ignores it after first, but the computation still runs).
1501    // For large resumed sessions, reconstruction does O(messages × blocks)
1502    // work; we only want that once.
1503    const [contentReplacementStateRef] = useState(() => ({
1504      current: provisionContentReplacementState(initialMessages, initialContentReplacements)
1505    }));
1506    const [haveShownCostDialog, setHaveShownCostDialog] = useState(getGlobalConfig().hasAcknowledgedCostThreshold);
1507    const [vimMode, setVimMode] = useState<VimMode>('INSERT');
1508    const [showBashesDialog, setShowBashesDialog] = useState<string | boolean>(false);
1509    const [isSearchingHistory, setIsSearchingHistory] = useState(false);
1510    const [isHelpOpen, setIsHelpOpen] = useState(false);
1511  
1512    // showBashesDialog is REPL-level so it survives PromptInput unmounting.
1513    // When ultraplan approval fires while the pill dialog is open, PromptInput
1514    // unmounts (focusedInputDialog → 'ultraplan-choice') but this stays true;
1515    // after accepting, PromptInput remounts into an empty "No tasks" dialog
1516    // (the completed ultraplan task has been filtered out). Close it here.
1517    useEffect(() => {
1518      if (ultraplanPendingChoice && showBashesDialog) {
1519        setShowBashesDialog(false);
1520      }
1521    }, [ultraplanPendingChoice, showBashesDialog]);
1522    const isTerminalFocused = useTerminalFocus();
1523    const terminalFocusRef = useRef(isTerminalFocused);
1524    terminalFocusRef.current = isTerminalFocused;
1525    const [theme] = useTheme();
1526  
1527    // resetLoadingState runs twice per turn (onQueryImpl tail + onQuery finally).
1528    // Without this guard, both calls pick a tip → two recordShownTip → two
1529    // saveGlobalConfig writes back-to-back. Reset at submit in onSubmit.
1530    const tipPickedThisTurnRef = React.useRef(false);
1531    const pickNewSpinnerTip = useCallback(() => {
1532      if (tipPickedThisTurnRef.current) return;
1533      tipPickedThisTurnRef.current = true;
1534      const newMessages = messagesRef.current.slice(bashToolsProcessedIdx.current);
1535      for (const tool of extractBashToolsFromMessages(newMessages)) {
1536        bashTools.current.add(tool);
1537      }
1538      bashToolsProcessedIdx.current = messagesRef.current.length;
1539      void getTipToShowOnSpinner({
1540        theme,
1541        readFileState: readFileState.current,
1542        bashTools: bashTools.current
1543      }).then(async tip => {
1544        if (tip) {
1545          const content = await tip.content({
1546            theme
1547          });
1548          setAppState(prev => ({
1549            ...prev,
1550            spinnerTip: content
1551          }));
1552          recordShownTip(tip);
1553        } else {
1554          setAppState(prev => {
1555            if (prev.spinnerTip === undefined) return prev;
1556            return {
1557              ...prev,
1558              spinnerTip: undefined
1559            };
1560          });
1561        }
1562      });
1563    }, [setAppState, theme]);
1564  
1565    // Resets UI loading state. Does NOT call onTurnComplete - that should be
1566    // called explicitly only when a query turn actually completes.
1567    const resetLoadingState = useCallback(() => {
1568      // isLoading is now derived from queryGuard — no setter call needed.
1569      // queryGuard.end() (onQuery finally) or cancelReservation() (executeUserInput
1570      // finally) have already transitioned the guard to idle by the time this runs.
1571      // External loading (remote/backgrounding) is reset separately by those hooks.
1572      setIsExternalLoading(false);
1573      setUserInputOnProcessing(undefined);
1574      responseLengthRef.current = 0;
1575      apiMetricsRef.current = [];
1576      setStreamingText(null);
1577      setStreamingToolUses([]);
1578      setSpinnerMessage(null);
1579      setSpinnerColor(null);
1580      setSpinnerShimmerColor(null);
1581      pickNewSpinnerTip();
1582      endInteractionSpan();
1583      // Speculative bash classifier checks are only valid for the current
1584      // turn's commands — clear after each turn to avoid accumulating
1585      // Promise chains for unconsumed checks (denied/aborted paths).
1586      clearSpeculativeChecks();
1587    }, [pickNewSpinnerTip]);
1588  
1589    // Session backgrounding — hook is below, after getToolUseContext
1590  
1591    const hasRunningTeammates = useMemo(() => getAllInProcessTeammateTasks(tasks).some(t => t.status === 'running'), [tasks]);
1592  
1593    // Show deferred turn duration message once all swarm teammates finish
1594    useEffect(() => {
1595      if (!hasRunningTeammates && swarmStartTimeRef.current !== null) {
1596        const totalMs = Date.now() - swarmStartTimeRef.current;
1597        const deferredBudget = swarmBudgetInfoRef.current;
1598        swarmStartTimeRef.current = null;
1599        swarmBudgetInfoRef.current = undefined;
1600        setMessages(prev => [...prev, createTurnDurationMessage(totalMs, deferredBudget,
1601        // Count only what recordTranscript will persist — ephemeral
1602        // progress ticks and non-ant attachments are filtered by
1603        // isLoggableMessage and never reach disk. Using raw prev.length
1604        // would make checkResumeConsistency report false delta<0 for
1605        // every turn that ran a progress-emitting tool.
1606        count(prev, isLoggableMessage))]);
1607      }
1608    }, [hasRunningTeammates, setMessages]);
1609  
1610    // Show auto permissions warning when entering auto mode
1611    // (either via Shift+Tab toggle or on startup). Debounced to avoid
1612    // flashing when the user is cycling through modes quickly.
1613    // Only shown 3 times total across sessions.
1614    const safeYoloMessageShownRef = useRef(false);
1615    useEffect(() => {
1616      if (feature('TRANSCRIPT_CLASSIFIER')) {
1617        if (toolPermissionContext.mode !== 'auto') {
1618          safeYoloMessageShownRef.current = false;
1619          return;
1620        }
1621        if (safeYoloMessageShownRef.current) return;
1622        const config = getGlobalConfig();
1623        const count = config.autoPermissionsNotificationCount ?? 0;
1624        if (count >= 3) return;
1625        const timer = setTimeout((ref, setMessages) => {
1626          ref.current = true;
1627          saveGlobalConfig(prev => {
1628            const prevCount = prev.autoPermissionsNotificationCount ?? 0;
1629            if (prevCount >= 3) return prev;
1630            return {
1631              ...prev,
1632              autoPermissionsNotificationCount: prevCount + 1
1633            };
1634          });
1635          setMessages(prev => [...prev, createSystemMessage(AUTO_MODE_DESCRIPTION, 'warning')]);
1636        }, 800, safeYoloMessageShownRef, setMessages);
1637        return () => clearTimeout(timer);
1638      }
1639    }, [toolPermissionContext.mode, setMessages]);
1640  
1641    // If worktree creation was slow and sparse-checkout isn't configured,
1642    // nudge the user toward settings.worktree.sparsePaths.
1643    const worktreeTipShownRef = useRef(false);
1644    useEffect(() => {
1645      if (worktreeTipShownRef.current) return;
1646      const wt = getCurrentWorktreeSession();
1647      if (!wt?.creationDurationMs || wt.usedSparsePaths) return;
1648      if (wt.creationDurationMs < 15_000) return;
1649      worktreeTipShownRef.current = true;
1650      const secs = Math.round(wt.creationDurationMs / 1000);
1651      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')]);
1652    }, [setMessages]);
1653  
1654    // Hide spinner when the only in-progress tool is Sleep
1655    const onlySleepToolActive = useMemo(() => {
1656      const lastAssistant = messages.findLast(m => m.type === 'assistant');
1657      if (lastAssistant?.type !== 'assistant') return false;
1658      const inProgressToolUses = lastAssistant.message.content.filter(b => b.type === 'tool_use' && inProgressToolUseIDs.has(b.id));
1659      return inProgressToolUses.length > 0 && inProgressToolUses.every(b => b.type === 'tool_use' && b.name === SLEEP_TOOL_NAME);
1660    }, [messages, inProgressToolUseIDs]);
1661    const {
1662      onBeforeQuery: mrOnBeforeQuery,
1663      onTurnComplete: mrOnTurnComplete,
1664      render: mrRender
1665    } = useMoreRight({
1666      enabled: moreRightEnabled,
1667      setMessages,
1668      inputValue,
1669      setInputValue,
1670      setToolJSX
1671    });
1672    const showSpinner = (!toolJSX || toolJSX.showSpinner === true) && toolUseConfirmQueue.length === 0 && promptQueue.length === 0 && (
1673    // Show spinner during input processing, API call, while teammates are running,
1674    // or while pending task notifications are queued (prevents spinner bounce between consecutive notifications)
1675    isLoading || userInputOnProcessing || hasRunningTeammates ||
1676    // Keep spinner visible while task notifications are queued for processing.
1677    // Without this, the spinner briefly disappears between consecutive notifications
1678    // (e.g., multiple background agents completing in rapid succession) because
1679    // isLoading goes false momentarily between processing each one.
1680    getCommandQueueLength() > 0) &&
1681    // Hide spinner when waiting for leader to approve permission request
1682    !pendingWorkerRequest && !onlySleepToolActive && (
1683    // Hide spinner when streaming text is visible (the text IS the feedback),
1684    // but keep it when isBriefOnly suppresses the streaming text display
1685    !visibleStreamingText || isBriefOnly);
1686  
1687    // Check if any permission or ask question prompt is currently visible
1688    // This is used to prevent the survey from opening while prompts are active
1689    const hasActivePrompt = toolUseConfirmQueue.length > 0 || promptQueue.length > 0 || sandboxPermissionRequestQueue.length > 0 || elicitation.queue.length > 0 || workerSandboxPermissions.queue.length > 0;
1690    const feedbackSurveyOriginal = useFeedbackSurvey(messages, isLoading, submitCount, 'session', hasActivePrompt);
1691    const skillImprovementSurvey = useSkillImprovementSurvey(setMessages);
1692    const showIssueFlagBanner = useIssueFlagBanner(messages, submitCount);
1693  
1694    // Wrap feedback survey handler to trigger auto-run /issue
1695    const feedbackSurvey = useMemo(() => ({
1696      ...feedbackSurveyOriginal,
1697      handleSelect: (selected: 'dismissed' | 'bad' | 'fine' | 'good') => {
1698        // Reset the ref when a new survey response comes in
1699        didAutoRunIssueRef.current = false;
1700        const showedTranscriptPrompt = feedbackSurveyOriginal.handleSelect(selected);
1701        // Auto-run /issue for "bad" if transcript prompt wasn't shown
1702        if (selected === 'bad' && !showedTranscriptPrompt && shouldAutoRunIssue('feedback_survey_bad')) {
1703          setAutoRunIssueReason('feedback_survey_bad');
1704          didAutoRunIssueRef.current = true;
1705        }
1706      }
1707    }), [feedbackSurveyOriginal]);
1708  
1709    // Post-compact survey: shown after compaction if feature gate is enabled
1710    const postCompactSurvey = usePostCompactSurvey(messages, isLoading, hasActivePrompt, {
1711      enabled: !isRemoteSession
1712    });
1713  
1714    // Memory survey: shown when the assistant mentions memory and a memory file
1715    // was read this conversation
1716    const memorySurvey = useMemorySurvey(messages, isLoading, hasActivePrompt, {
1717      enabled: !isRemoteSession
1718    });
1719  
1720    // Frustration detection: show transcript sharing prompt after detecting frustrated messages
1721    const frustrationDetection = useFrustrationDetection(messages, isLoading, hasActivePrompt, feedbackSurvey.state !== 'closed' || postCompactSurvey.state !== 'closed' || memorySurvey.state !== 'closed');
1722  
1723    // Initialize IDE integration
1724    useIDEIntegration({
1725      autoConnectIdeFlag,
1726      ideToInstallExtension,
1727      setDynamicMcpConfig,
1728      setShowIdeOnboarding,
1729      setIDEInstallationState: setIDEInstallationStatus
1730    });
1731    useFileHistorySnapshotInit(initialFileHistorySnapshots, fileHistory, fileHistoryState => setAppState(prev => ({
1732      ...prev,
1733      fileHistory: fileHistoryState
1734    })));
1735    const resume = useCallback(async (sessionId: UUID, log: LogOption, entrypoint: ResumeEntrypoint) => {
1736      const resumeStart = performance.now();
1737      try {
1738        // Deserialize messages to properly clean up the conversation
1739        // This filters unresolved tool uses and adds a synthetic assistant message if needed
1740        const messages = deserializeMessages(log.messages);
1741  
1742        // Match coordinator/normal mode to the resumed session
1743        if (feature('COORDINATOR_MODE')) {
1744          /* eslint-disable @typescript-eslint/no-require-imports */
1745          const coordinatorModule = require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js');
1746          /* eslint-enable @typescript-eslint/no-require-imports */
1747          const warning = coordinatorModule.matchSessionMode(log.mode);
1748          if (warning) {
1749            // Re-derive agent definitions after mode switch so built-in agents
1750            // reflect the new coordinator/normal mode
1751            /* eslint-disable @typescript-eslint/no-require-imports */
1752            const {
1753              getAgentDefinitionsWithOverrides,
1754              getActiveAgentsFromList
1755            } = require('../tools/AgentTool/loadAgentsDir.js') as typeof import('../tools/AgentTool/loadAgentsDir.js');
1756            /* eslint-enable @typescript-eslint/no-require-imports */
1757            getAgentDefinitionsWithOverrides.cache.clear?.();
1758            const freshAgentDefs = await getAgentDefinitionsWithOverrides(getOriginalCwd());
1759            setAppState(prev => ({
1760              ...prev,
1761              agentDefinitions: {
1762                ...freshAgentDefs,
1763                allAgents: freshAgentDefs.allAgents,
1764                activeAgents: getActiveAgentsFromList(freshAgentDefs.allAgents)
1765              }
1766            }));
1767            messages.push(createSystemMessage(warning, 'warning'));
1768          }
1769        }
1770  
1771        // Fire SessionEnd hooks for the current session before starting the
1772        // resumed one, mirroring the /clear flow in conversation.ts.
1773        const sessionEndTimeoutMs = getSessionEndHookTimeoutMs();
1774        await executeSessionEndHooks('resume', {
1775          getAppState: () => store.getState(),
1776          setAppState,
1777          signal: AbortSignal.timeout(sessionEndTimeoutMs),
1778          timeoutMs: sessionEndTimeoutMs
1779        });
1780  
1781        // Process session start hooks for resume
1782        const hookMessages = await processSessionStartHooks('resume', {
1783          sessionId,
1784          agentType: mainThreadAgentDefinition?.agentType,
1785          model: mainLoopModel
1786        });
1787  
1788        // Append hook messages to the conversation
1789        messages.push(...hookMessages);
1790        // For forks, generate a new plan slug and copy the plan content so the
1791        // original and forked sessions don't clobber each other's plan files.
1792        // For regular resumes, reuse the original session's plan slug.
1793        if (entrypoint === 'fork') {
1794          void copyPlanForFork(log, asSessionId(sessionId));
1795        } else {
1796          void copyPlanForResume(log, asSessionId(sessionId));
1797        }
1798  
1799        // Restore file history and attribution state from the resumed conversation
1800        restoreSessionStateFromLog(log, setAppState);
1801        if (log.fileHistorySnapshots) {
1802          void copyFileHistoryForResume(log);
1803        }
1804  
1805        // Restore agent setting from the resumed conversation
1806        // Always reset to the new session's values (or clear if none),
1807        // matching the standaloneAgentContext pattern below
1808        const {
1809          agentDefinition: restoredAgent
1810        } = restoreAgentFromSession(log.agentSetting, initialMainThreadAgentDefinition, agentDefinitions);
1811        setMainThreadAgentDefinition(restoredAgent);
1812        setAppState(prev => ({
1813          ...prev,
1814          agent: restoredAgent?.agentType
1815        }));
1816  
1817        // Restore standalone agent context from the resumed conversation
1818        // Always reset to the new session's values (or clear if none)
1819        setAppState(prev => ({
1820          ...prev,
1821          standaloneAgentContext: computeStandaloneAgentContext(log.agentName, log.agentColor)
1822        }));
1823        void updateSessionName(log.agentName);
1824  
1825        // Restore read file state from the message history
1826        restoreReadFileState(messages, log.projectPath ?? getOriginalCwd());
1827  
1828        // Clear any active loading state (no queryId since we're not in a query)
1829        resetLoadingState();
1830        setAbortController(null);
1831        setConversationId(sessionId);
1832  
1833        // Get target session's costs BEFORE saving current session
1834        // (saveCurrentSessionCosts overwrites the config, so we need to read first)
1835        const targetSessionCosts = getStoredSessionCosts(sessionId);
1836  
1837        // Save current session's costs before switching to avoid losing accumulated costs
1838        saveCurrentSessionCosts();
1839  
1840        // Reset cost state for clean slate before restoring target session
1841        resetCostState();
1842  
1843        // Switch session (id + project dir atomically). fullPath may point to
1844        // a different project (cross-worktree, /branch); null derives from
1845        // current originalCwd.
1846        switchSession(asSessionId(sessionId), log.fullPath ? dirname(log.fullPath) : null);
1847        // Rename asciicast recording to match the resumed session ID
1848        const {
1849          renameRecordingForSession
1850        } = await import('../utils/asciicast.js');
1851        await renameRecordingForSession();
1852        await resetSessionFilePointer();
1853  
1854        // Clear then restore session metadata so it's re-appended on exit via
1855        // reAppendSessionMetadata. clearSessionMetadata must be called first:
1856        // restoreSessionMetadata only sets-if-truthy, so without the clear,
1857        // a session without an agent name would inherit the previous session's
1858        // cached name and write it to the wrong transcript on first message.
1859        clearSessionMetadata();
1860        restoreSessionMetadata(log);
1861        // Resumed sessions shouldn't re-title from mid-conversation context
1862        // (same reasoning as the useRef seed), and the previous session's
1863        // Haiku title shouldn't carry over.
1864        haikuTitleAttemptedRef.current = true;
1865        setHaikuTitle(undefined);
1866  
1867        // Exit any worktree a prior /resume entered, then cd into the one
1868        // this session was in. Without the exit, resuming from worktree B
1869        // to non-worktree C leaves cwd/currentWorktreeSession stale;
1870        // resuming B→C where C is also a worktree fails entirely
1871        // (getCurrentWorktreeSession guard blocks the switch).
1872        //
1873        // Skipped for /branch: forkLog doesn't carry worktreeSession, so
1874        // this would kick the user out of a worktree they're still working
1875        // in. Same fork skip as processResumedConversation for the adopt —
1876        // fork materializes its own file via recordTranscript on REPL mount.
1877        if (entrypoint !== 'fork') {
1878          exitRestoredWorktree();
1879          restoreWorktreeForResume(log.worktreeSession);
1880          adoptResumedSessionFile();
1881          void restoreRemoteAgentTasks({
1882            abortController: new AbortController(),
1883            getAppState: () => store.getState(),
1884            setAppState
1885          });
1886        } else {
1887          // Fork: same re-persist as /clear (conversation.ts). The clear
1888          // above wiped currentSessionWorktree, forkLog doesn't carry it,
1889          // and the process is still in the same worktree.
1890          const ws = getCurrentWorktreeSession();
1891          if (ws) saveWorktreeState(ws);
1892        }
1893  
1894        // Persist the current mode so future resumes know what mode this session was in
1895        if (feature('COORDINATOR_MODE')) {
1896          /* eslint-disable @typescript-eslint/no-require-imports */
1897          const {
1898            saveMode
1899          } = require('../utils/sessionStorage.js');
1900          const {
1901            isCoordinatorMode
1902          } = require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js');
1903          /* eslint-enable @typescript-eslint/no-require-imports */
1904          saveMode(isCoordinatorMode() ? 'coordinator' : 'normal');
1905        }
1906  
1907        // Restore target session's costs from the data we read earlier
1908        if (targetSessionCosts) {
1909          setCostStateForRestore(targetSessionCosts);
1910        }
1911  
1912        // Reconstruct replacement state for the resumed session. Runs after
1913        // setSessionId so any NEW replacements post-resume write to the
1914        // resumed session's tool-results dir. Gated on ref.current: the
1915        // initial mount already read the feature flag, so we don't re-read
1916        // it here (mid-session flag flips stay unobservable in both
1917        // directions).
1918        //
1919        // Skipped for in-session /branch: the existing ref is already correct
1920        // (branch preserves tool_use_ids), so there's no need to reconstruct.
1921        // createFork() does write content-replacement entries to the forked
1922        // JSONL with the fork's sessionId, so `claude -r {forkId}` also works.
1923        if (contentReplacementStateRef.current && entrypoint !== 'fork') {
1924          contentReplacementStateRef.current = reconstructContentReplacementState(messages, log.contentReplacements ?? []);
1925        }
1926  
1927        // Reset messages to the provided initial messages
1928        // Use a callback to ensure we're not dependent on stale state
1929        setMessages(() => messages);
1930  
1931        // Clear any active tool JSX
1932        setToolJSX(null);
1933  
1934        // Clear input to ensure no residual state
1935        setInputValue('');
1936        logEvent('tengu_session_resumed', {
1937          entrypoint: entrypoint as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
1938          success: true,
1939          resume_duration_ms: Math.round(performance.now() - resumeStart)
1940        });
1941      } catch (error) {
1942        logEvent('tengu_session_resumed', {
1943          entrypoint: entrypoint as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
1944          success: false
1945        });
1946        throw error;
1947      }
1948    }, [resetLoadingState, setAppState]);
1949  
1950    // Lazy init: useRef(createX()) would call createX on every render and
1951    // discard the result. LRUCache construction inside FileStateCache is
1952    // expensive (~170ms), so we use useState's lazy initializer to create
1953    // it exactly once, then feed that stable reference into useRef.
1954    const [initialReadFileState] = useState(() => createFileStateCacheWithSizeLimit(READ_FILE_STATE_CACHE_SIZE));
1955    const readFileState = useRef(initialReadFileState);
1956    const bashTools = useRef(new Set<string>());
1957    const bashToolsProcessedIdx = useRef(0);
1958    // Session-scoped skill discovery tracking (feeds was_discovered on
1959    // tengu_skill_tool_invocation). Must persist across getToolUseContext
1960    // rebuilds within a session: turn-0 discovery writes via processUserInput
1961    // before onQuery builds its own context, and discovery on turn N must
1962    // still attribute a SkillTool call on turn N+k. Cleared in clearConversation.
1963    const discoveredSkillNamesRef = useRef(new Set<string>());
1964    // Session-level dedup for nested_memory CLAUDE.md attachments.
1965    // readFileState is a 100-entry LRU; once it evicts a CLAUDE.md path,
1966    // the next discovery cycle re-injects it. Cleared in clearConversation.
1967    const loadedNestedMemoryPathsRef = useRef(new Set<string>());
1968  
1969    // Helper to restore read file state from messages (used for resume flows)
1970    // This allows Claude to edit files that were read in previous sessions
1971    const restoreReadFileState = useCallback((messages: MessageType[], cwd: string) => {
1972      const extracted = extractReadFilesFromMessages(messages, cwd, READ_FILE_STATE_CACHE_SIZE);
1973      readFileState.current = mergeFileStateCaches(readFileState.current, extracted);
1974      for (const tool of extractBashToolsFromMessages(messages)) {
1975        bashTools.current.add(tool);
1976      }
1977    }, []);
1978  
1979    // Extract read file state from initialMessages on mount
1980    // This handles CLI flag resume (--resume-session) and ResumeConversation screen
1981    // where messages are passed as props rather than through the resume callback
1982    useEffect(() => {
1983      if (initialMessages && initialMessages.length > 0) {
1984        restoreReadFileState(initialMessages, getOriginalCwd());
1985        void restoreRemoteAgentTasks({
1986          abortController: new AbortController(),
1987          getAppState: () => store.getState(),
1988          setAppState
1989        });
1990      }
1991      // Only run on mount - initialMessages shouldn't change during component lifetime
1992      // eslint-disable-next-line react-hooks/exhaustive-deps
1993    }, []);
1994    const {
1995      status: apiKeyStatus,
1996      reverify
1997    } = useApiKeyVerification();
1998  
1999    // Auto-run /issue state
2000    const [autoRunIssueReason, setAutoRunIssueReason] = useState<AutoRunIssueReason | null>(null);
2001    // Ref to track if autoRunIssue was triggered this survey cycle,
2002    // so we can suppress the [1] follow-up prompt even after
2003    // autoRunIssueReason is cleared.
2004    const didAutoRunIssueRef = useRef(false);
2005  
2006    // State for exit feedback flow
2007    const [exitFlow, setExitFlow] = useState<React.ReactNode>(null);
2008    const [isExiting, setIsExiting] = useState(false);
2009  
2010    // Calculate if cost dialog should be shown
2011    const showingCostDialog = !isLoading && showCostDialog;
2012  
2013    // Determine which dialog should have focus (if any)
2014    // Permission and interactive dialogs can show even when toolJSX is set,
2015    // as long as shouldContinueAnimation is true. This prevents deadlocks when
2016    // agents set background hints while waiting for user interaction.
2017    function getFocusedInputDialog(): 'message-selector' | 'sandbox-permission' | 'tool-permission' | 'prompt' | 'worker-sandbox-permission' | 'elicitation' | 'cost' | 'idle-return' | 'init-onboarding' | 'ide-onboarding' | 'model-switch' | 'undercover-callout' | 'effort-callout' | 'remote-callout' | 'lsp-recommendation' | 'plugin-hint' | 'desktop-upsell' | 'ultraplan-choice' | 'ultraplan-launch' | undefined {
2018      // Exit states always take precedence
2019      if (isExiting || exitFlow) return undefined;
2020  
2021      // High priority dialogs (always show regardless of typing)
2022      if (isMessageSelectorVisible) return 'message-selector';
2023  
2024      // Suppress interrupt dialogs while user is actively typing
2025      if (isPromptInputActive) return undefined;
2026      if (sandboxPermissionRequestQueue[0]) return 'sandbox-permission';
2027  
2028      // Permission/interactive dialogs (show unless blocked by toolJSX)
2029      const allowDialogsWithAnimation = !toolJSX || toolJSX.shouldContinueAnimation;
2030      if (allowDialogsWithAnimation && toolUseConfirmQueue[0]) return 'tool-permission';
2031      if (allowDialogsWithAnimation && promptQueue[0]) return 'prompt';
2032      // Worker sandbox permission prompts (network access) from swarm workers
2033      if (allowDialogsWithAnimation && workerSandboxPermissions.queue[0]) return 'worker-sandbox-permission';
2034      if (allowDialogsWithAnimation && elicitation.queue[0]) return 'elicitation';
2035      if (allowDialogsWithAnimation && showingCostDialog) return 'cost';
2036      if (allowDialogsWithAnimation && idleReturnPending) return 'idle-return';
2037      if (feature('ULTRAPLAN') && allowDialogsWithAnimation && !isLoading && ultraplanPendingChoice) return 'ultraplan-choice';
2038      if (feature('ULTRAPLAN') && allowDialogsWithAnimation && !isLoading && ultraplanLaunchPending) return 'ultraplan-launch';
2039  
2040      // Onboarding dialogs (special conditions)
2041      if (allowDialogsWithAnimation && showIdeOnboarding) return 'ide-onboarding';
2042  
2043      // Model switch callout (ant-only, eliminated from external builds)
2044      if ("external" === 'ant' && allowDialogsWithAnimation && showModelSwitchCallout) return 'model-switch';
2045  
2046      // Undercover auto-enable explainer (ant-only, eliminated from external builds)
2047      if ("external" === 'ant' && allowDialogsWithAnimation && showUndercoverCallout) return 'undercover-callout';
2048  
2049      // Effort callout (shown once for Opus 4.6 users when effort is enabled)
2050      if (allowDialogsWithAnimation && showEffortCallout) return 'effort-callout';
2051  
2052      // Remote callout (shown once before first bridge enable)
2053      if (allowDialogsWithAnimation && showRemoteCallout) return 'remote-callout';
2054  
2055      // LSP plugin recommendation (lowest priority - non-blocking suggestion)
2056      if (allowDialogsWithAnimation && lspRecommendation) return 'lsp-recommendation';
2057  
2058      // Plugin hint from CLI/SDK stderr (same priority band as LSP rec)
2059      if (allowDialogsWithAnimation && hintRecommendation) return 'plugin-hint';
2060  
2061      // Desktop app upsell (max 3 launches, lowest priority)
2062      if (allowDialogsWithAnimation && showDesktopUpsellStartup) return 'desktop-upsell';
2063      return undefined;
2064    }
2065    const focusedInputDialog = getFocusedInputDialog();
2066  
2067    // True when permission prompts exist but are hidden because the user is typing
2068    const hasSuppressedDialogs = isPromptInputActive && (sandboxPermissionRequestQueue[0] || toolUseConfirmQueue[0] || promptQueue[0] || workerSandboxPermissions.queue[0] || elicitation.queue[0] || showingCostDialog);
2069  
2070    // Keep ref in sync so timer callbacks can read the current value
2071    focusedInputDialogRef.current = focusedInputDialog;
2072  
2073    // Immediately capture pause/resume when focusedInputDialog changes
2074    // This ensures accurate timing even under high system load, rather than
2075    // relying on the 100ms polling interval to detect state changes
2076    useEffect(() => {
2077      if (!isLoading) return;
2078      const isPaused = focusedInputDialog === 'tool-permission';
2079      const now = Date.now();
2080      if (isPaused && pauseStartTimeRef.current === null) {
2081        // Just entered pause state - record the exact moment
2082        pauseStartTimeRef.current = now;
2083      } else if (!isPaused && pauseStartTimeRef.current !== null) {
2084        // Just exited pause state - accumulate paused time immediately
2085        totalPausedMsRef.current += now - pauseStartTimeRef.current;
2086        pauseStartTimeRef.current = null;
2087      }
2088    }, [focusedInputDialog, isLoading]);
2089  
2090    // Re-pin scroll to bottom whenever the permission overlay appears or
2091    // dismisses. Overlay now renders below messages inside the same
2092    // ScrollBox (no remount), so we need an explicit scrollToBottom for:
2093    //  - appear: user may have been scrolled up (sticky broken) — the
2094    //    dialog is blocking and must be visible
2095    //  - dismiss: user may have scrolled up to read context during the
2096    //    overlay, and onScroll was suppressed so the pill state is stale
2097    // useLayoutEffect so the re-pin commits before the Ink frame renders —
2098    // no 1-frame flash of the wrong scroll position.
2099    const prevDialogRef = useRef(focusedInputDialog);
2100    useLayoutEffect(() => {
2101      const was = prevDialogRef.current === 'tool-permission';
2102      const now = focusedInputDialog === 'tool-permission';
2103      if (was !== now) repinScroll();
2104      prevDialogRef.current = focusedInputDialog;
2105    }, [focusedInputDialog, repinScroll]);
2106    function onCancel() {
2107      if (focusedInputDialog === 'elicitation') {
2108        // Elicitation dialog handles its own Escape, and closing it shouldn't affect any loading state.
2109        return;
2110      }
2111      logForDebugging(`[onCancel] focusedInputDialog=${focusedInputDialog} streamMode=${streamMode}`);
2112  
2113      // Pause proactive mode so the user gets control back.
2114      // It will resume when they submit their next input (see onSubmit).
2115      if (feature('PROACTIVE') || feature('KAIROS')) {
2116        proactiveModule?.pauseProactive();
2117      }
2118      queryGuard.forceEnd();
2119      skipIdleCheckRef.current = false;
2120  
2121      // Preserve partially-streamed text so the user can read what was
2122      // generated before pressing Esc. Pushed before resetLoadingState clears
2123      // streamingText, and before query.ts yields the async interrupt marker,
2124      // giving final order [user, partial-assistant, [Request interrupted by user]].
2125      if (streamingText?.trim()) {
2126        setMessages(prev => [...prev, createAssistantMessage({
2127          content: streamingText
2128        })]);
2129      }
2130      resetLoadingState();
2131  
2132      // Clear any active token budget so the backstop doesn't fire on
2133      // a stale budget if the query generator hasn't exited yet.
2134      if (feature('TOKEN_BUDGET')) {
2135        snapshotOutputTokensForTurn(null);
2136      }
2137      if (focusedInputDialog === 'tool-permission') {
2138        // Tool use confirm handles the abort signal itself
2139        toolUseConfirmQueue[0]?.onAbort();
2140        setToolUseConfirmQueue([]);
2141      } else if (focusedInputDialog === 'prompt') {
2142        // Reject all pending prompts and clear the queue
2143        for (const item of promptQueue) {
2144          item.reject(new Error('Prompt cancelled by user'));
2145        }
2146        setPromptQueue([]);
2147        abortController?.abort('user-cancel');
2148      } else if (activeRemote.isRemoteMode) {
2149        // Remote mode: send interrupt signal to CCR
2150        activeRemote.cancelRequest();
2151      } else {
2152        abortController?.abort('user-cancel');
2153      }
2154  
2155      // Clear the controller so subsequent Escape presses don't see a stale
2156      // aborted signal. Without this, canCancelRunningTask is false (signal
2157      // defined but .aborted === true), so isActive becomes false if no other
2158      // activating conditions hold — leaving the Escape keybinding inactive.
2159      setAbortController(null);
2160  
2161      // forceEnd() skips the finally path — fire directly (aborted=true).
2162      void mrOnTurnComplete(messagesRef.current, true);
2163    }
2164  
2165    // Function to handle queued command when canceling a permission request
2166    const handleQueuedCommandOnCancel = useCallback(() => {
2167      const result = popAllEditable(inputValue, 0);
2168      if (!result) return;
2169      setInputValue(result.text);
2170      setInputMode('prompt');
2171  
2172      // Restore images from queued commands to pastedContents
2173      if (result.images.length > 0) {
2174        setPastedContents(prev => {
2175          const newContents = {
2176            ...prev
2177          };
2178          for (const image of result.images) {
2179            newContents[image.id] = image;
2180          }
2181          return newContents;
2182        });
2183      }
2184    }, [setInputValue, setInputMode, inputValue, setPastedContents]);
2185  
2186    // CancelRequestHandler props - rendered inside KeybindingSetup
2187    const cancelRequestProps = {
2188      setToolUseConfirmQueue,
2189      onCancel,
2190      onAgentsKilled: () => setMessages(prev => [...prev, createAgentsKilledMessage()]),
2191      isMessageSelectorVisible: isMessageSelectorVisible || !!showBashesDialog,
2192      screen,
2193      abortSignal: abortController?.signal,
2194      popCommandFromQueue: handleQueuedCommandOnCancel,
2195      vimMode,
2196      isLocalJSXCommand: toolJSX?.isLocalJSXCommand,
2197      isSearchingHistory,
2198      isHelpOpen,
2199      inputMode,
2200      inputValue,
2201      streamMode
2202    };
2203    useEffect(() => {
2204      const totalCost = getTotalCost();
2205      if (totalCost >= 5 /* $5 */ && !showCostDialog && !haveShownCostDialog) {
2206        logEvent('tengu_cost_threshold_reached', {});
2207        // Mark as shown even if the dialog won't render (no console billing
2208        // access). Otherwise this effect re-fires on every message change for
2209        // the rest of the session — 200k+ spurious events observed.
2210        setHaveShownCostDialog(true);
2211        if (hasConsoleBillingAccess()) {
2212          setShowCostDialog(true);
2213        }
2214      }
2215    }, [messages, showCostDialog, haveShownCostDialog]);
2216    const sandboxAskCallback: SandboxAskCallback = useCallback(async (hostPattern: NetworkHostPattern) => {
2217      // If running as a swarm worker, forward the request to the leader via mailbox
2218      if (isAgentSwarmsEnabled() && isSwarmWorker()) {
2219        const requestId = generateSandboxRequestId();
2220  
2221        // Send the request to the leader via mailbox
2222        const sent = await sendSandboxPermissionRequestViaMailbox(hostPattern.host, requestId);
2223        return new Promise(resolveShouldAllowHost => {
2224          if (!sent) {
2225            // If we couldn't send via mailbox, fall back to local handling
2226            setSandboxPermissionRequestQueue(prev => [...prev, {
2227              hostPattern,
2228              resolvePromise: resolveShouldAllowHost
2229            }]);
2230            return;
2231          }
2232  
2233          // Register the callback for when the leader responds
2234          registerSandboxPermissionCallback({
2235            requestId,
2236            host: hostPattern.host,
2237            resolve: resolveShouldAllowHost
2238          });
2239  
2240          // Update AppState to show pending indicator
2241          setAppState(prev => ({
2242            ...prev,
2243            pendingSandboxRequest: {
2244              requestId,
2245              host: hostPattern.host
2246            }
2247          }));
2248        });
2249      }
2250  
2251      // Normal flow for non-workers: show local UI and optionally race
2252      // against the REPL bridge (Remote Control) if connected.
2253      return new Promise(resolveShouldAllowHost => {
2254        let resolved = false;
2255        function resolveOnce(allow: boolean): void {
2256          if (resolved) return;
2257          resolved = true;
2258          resolveShouldAllowHost(allow);
2259        }
2260  
2261        // Queue the local sandbox permission dialog
2262        setSandboxPermissionRequestQueue(prev => [...prev, {
2263          hostPattern,
2264          resolvePromise: resolveOnce
2265        }]);
2266  
2267        // When the REPL bridge is connected, also forward the sandbox
2268        // permission request as a can_use_tool control_request so the
2269        // remote user (e.g. on claude.ai) can approve it too.
2270        if (feature('BRIDGE_MODE')) {
2271          const bridgeCallbacks = store.getState().replBridgePermissionCallbacks;
2272          if (bridgeCallbacks) {
2273            const bridgeRequestId = randomUUID();
2274            bridgeCallbacks.sendRequest(bridgeRequestId, SANDBOX_NETWORK_ACCESS_TOOL_NAME, {
2275              host: hostPattern.host
2276            }, randomUUID(), `Allow network connection to ${hostPattern.host}?`);
2277            const unsubscribe = bridgeCallbacks.onResponse(bridgeRequestId, response => {
2278              unsubscribe();
2279              const allow = response.behavior === 'allow';
2280              // Resolve ALL pending requests for the same host, not just
2281              // this one — mirrors the local dialog handler pattern.
2282              setSandboxPermissionRequestQueue(queue => {
2283                queue.filter(item => item.hostPattern.host === hostPattern.host).forEach(item => item.resolvePromise(allow));
2284                return queue.filter(item => item.hostPattern.host !== hostPattern.host);
2285              });
2286              // Clean up all sibling bridge subscriptions for this host
2287              // (other concurrent same-host requests) before deleting.
2288              const siblingCleanups = sandboxBridgeCleanupRef.current.get(hostPattern.host);
2289              if (siblingCleanups) {
2290                for (const fn of siblingCleanups) {
2291                  fn();
2292                }
2293                sandboxBridgeCleanupRef.current.delete(hostPattern.host);
2294              }
2295            });
2296  
2297            // Register cleanup so the local dialog handler can cancel
2298            // the remote prompt and unsubscribe when the local user
2299            // responds first.
2300            const cleanup = () => {
2301              unsubscribe();
2302              bridgeCallbacks.cancelRequest(bridgeRequestId);
2303            };
2304            const existing = sandboxBridgeCleanupRef.current.get(hostPattern.host) ?? [];
2305            existing.push(cleanup);
2306            sandboxBridgeCleanupRef.current.set(hostPattern.host, existing);
2307          }
2308        }
2309      });
2310    }, [setAppState, store]);
2311  
2312    // #34044: if user explicitly set sandbox.enabled=true but deps are missing,
2313    // isSandboxingEnabled() returns false silently. Surface the reason once at
2314    // mount so users know their security config isn't being enforced. Full
2315    // reason goes to debug log; notification points to /sandbox for details.
2316    // addNotification is stable (useCallback) so the effect fires once.
2317    useEffect(() => {
2318      const reason = SandboxManager.getSandboxUnavailableReason();
2319      if (!reason) return;
2320      if (SandboxManager.isSandboxRequired()) {
2321        process.stderr.write(`\nError: sandbox required but unavailable: ${reason}\n` + `  sandbox.failIfUnavailable is set — refusing to start without a working sandbox.\n\n`);
2322        gracefulShutdownSync(1, 'other');
2323        return;
2324      }
2325      logForDebugging(`sandbox disabled: ${reason}`, {
2326        level: 'warn'
2327      });
2328      addNotification({
2329        key: 'sandbox-unavailable',
2330        jsx: <>
2331            <Text color="warning">sandbox disabled</Text>
2332            <Text dimColor> · /sandbox</Text>
2333          </>,
2334        priority: 'medium'
2335      });
2336    }, [addNotification]);
2337    if (SandboxManager.isSandboxingEnabled()) {
2338      // If sandboxing is enabled (setting.sandbox is defined, initialise the manager)
2339      SandboxManager.initialize(sandboxAskCallback).catch(err => {
2340        // Initialization/validation failed - display error and exit
2341        process.stderr.write(`\n❌ Sandbox Error: ${errorMessage(err)}\n`);
2342        gracefulShutdownSync(1, 'other');
2343      });
2344    }
2345    const setToolPermissionContext = useCallback((context: ToolPermissionContext, options?: {
2346      preserveMode?: boolean;
2347    }) => {
2348      setAppState(prev => ({
2349        ...prev,
2350        toolPermissionContext: {
2351          ...context,
2352          // Preserve the coordinator's mode only when explicitly requested.
2353          // Workers' getAppState() returns a transformed context with mode
2354          // 'acceptEdits' that must not leak into the coordinator's actual
2355          // state via permission-rule updates — those call sites pass
2356          // { preserveMode: true }. User-initiated mode changes (e.g.,
2357          // selecting "allow all edits") must NOT be overridden.
2358          mode: options?.preserveMode ? prev.toolPermissionContext.mode : context.mode
2359        }
2360      }));
2361  
2362      // When permission context changes, recheck all queued items
2363      // This handles the case where approving item1 with "don't ask again"
2364      // should auto-approve other queued items that now match the updated rules
2365      setImmediate(setToolUseConfirmQueue => {
2366        // Use setToolUseConfirmQueue callback to get current queue state
2367        // instead of capturing it in the closure, to avoid stale closure issues
2368        setToolUseConfirmQueue(currentQueue => {
2369          currentQueue.forEach(item => {
2370            void item.recheckPermission();
2371          });
2372          return currentQueue;
2373        });
2374      }, setToolUseConfirmQueue);
2375    }, [setAppState, setToolUseConfirmQueue]);
2376  
2377    // Register the leader's setToolPermissionContext for in-process teammates
2378    useEffect(() => {
2379      registerLeaderSetToolPermissionContext(setToolPermissionContext);
2380      return () => unregisterLeaderSetToolPermissionContext();
2381    }, [setToolPermissionContext]);
2382    const canUseTool = useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext);
2383    const requestPrompt = useCallback((title: string, toolInputSummary?: string | null) => (request: PromptRequest): Promise<PromptResponse> => new Promise<PromptResponse>((resolve, reject) => {
2384      setPromptQueue(prev => [...prev, {
2385        request,
2386        title,
2387        toolInputSummary,
2388        resolve,
2389        reject
2390      }]);
2391    }), []);
2392    const getToolUseContext = useCallback((messages: MessageType[], newMessages: MessageType[], abortController: AbortController, mainLoopModel: string): ProcessUserInputContext => {
2393      // Read mutable values fresh from the store rather than closure-capturing
2394      // useAppState() snapshots. Same values today (closure is refreshed by the
2395      // render between turns); decouples freshness from React's render cycle for
2396      // a future headless conversation loop. Same pattern refreshTools() uses.
2397      const s = store.getState();
2398  
2399      // Compute tools fresh from store.getState() rather than the closure-
2400      // captured `tools`. useManageMCPConnections populates appState.mcp
2401      // async as servers connect — the store may have newer MCP state than
2402      // the closure captured at render time. Also doubles as refreshTools()
2403      // for mid-query tool list updates.
2404      const computeTools = () => {
2405        const state = store.getState();
2406        const assembled = assembleToolPool(state.toolPermissionContext, state.mcp.tools);
2407        const merged = mergeAndFilterTools(combinedInitialTools, assembled, state.toolPermissionContext.mode);
2408        if (!mainThreadAgentDefinition) return merged;
2409        return resolveAgentTools(mainThreadAgentDefinition, merged, false, true).resolvedTools;
2410      };
2411      return {
2412        abortController,
2413        options: {
2414          commands,
2415          tools: computeTools(),
2416          debug,
2417          verbose: s.verbose,
2418          mainLoopModel,
2419          thinkingConfig: s.thinkingEnabled !== false ? thinkingConfig : {
2420            type: 'disabled'
2421          },
2422          // Merge fresh from store rather than closing over useMergedClients'
2423          // memoized output. initialMcpClients is a prop (session-constant).
2424          mcpClients: mergeClients(initialMcpClients, s.mcp.clients),
2425          mcpResources: s.mcp.resources,
2426          ideInstallationStatus: ideInstallationStatus,
2427          isNonInteractiveSession: false,
2428          dynamicMcpConfig,
2429          theme,
2430          agentDefinitions: allowedAgentTypes ? {
2431            ...s.agentDefinitions,
2432            allowedAgentTypes
2433          } : s.agentDefinitions,
2434          customSystemPrompt,
2435          appendSystemPrompt,
2436          refreshTools: computeTools
2437        },
2438        getAppState: () => store.getState(),
2439        setAppState,
2440        messages,
2441        setMessages,
2442        updateFileHistoryState(updater: (prev: FileHistoryState) => FileHistoryState) {
2443          // Perf: skip the setState when the updater returns the same reference
2444          // (e.g. fileHistoryTrackEdit returns `state` when the file is already
2445          // tracked). Otherwise every no-op call would notify all store listeners.
2446          setAppState(prev => {
2447            const updated = updater(prev.fileHistory);
2448            if (updated === prev.fileHistory) return prev;
2449            return {
2450              ...prev,
2451              fileHistory: updated
2452            };
2453          });
2454        },
2455        updateAttributionState(updater: (prev: AttributionState) => AttributionState) {
2456          setAppState(prev => {
2457            const updated = updater(prev.attribution);
2458            if (updated === prev.attribution) return prev;
2459            return {
2460              ...prev,
2461              attribution: updated
2462            };
2463          });
2464        },
2465        openMessageSelector: () => {
2466          if (!disabled) {
2467            setIsMessageSelectorVisible(true);
2468          }
2469        },
2470        onChangeAPIKey: reverify,
2471        readFileState: readFileState.current,
2472        setToolJSX,
2473        addNotification,
2474        appendSystemMessage: msg => setMessages(prev => [...prev, msg]),
2475        sendOSNotification: opts => {
2476          void sendNotification(opts, terminal);
2477        },
2478        onChangeDynamicMcpConfig,
2479        onInstallIDEExtension: setIDEToInstallExtension,
2480        nestedMemoryAttachmentTriggers: new Set<string>(),
2481        loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,
2482        dynamicSkillDirTriggers: new Set<string>(),
2483        discoveredSkillNames: discoveredSkillNamesRef.current,
2484        setResponseLength,
2485        pushApiMetricsEntry: "external" === 'ant' ? (ttftMs: number) => {
2486          const now = Date.now();
2487          const baseline = responseLengthRef.current;
2488          apiMetricsRef.current.push({
2489            ttftMs,
2490            firstTokenTime: now,
2491            lastTokenTime: now,
2492            responseLengthBaseline: baseline,
2493            endResponseLength: baseline
2494          });
2495        } : undefined,
2496        setStreamMode,
2497        onCompactProgress: event => {
2498          switch (event.type) {
2499            case 'hooks_start':
2500              setSpinnerColor('claudeBlue_FOR_SYSTEM_SPINNER');
2501              setSpinnerShimmerColor('claudeBlueShimmer_FOR_SYSTEM_SPINNER');
2502              setSpinnerMessage(event.hookType === 'pre_compact' ? 'Running PreCompact hooks\u2026' : event.hookType === 'post_compact' ? 'Running PostCompact hooks\u2026' : 'Running SessionStart hooks\u2026');
2503              break;
2504            case 'compact_start':
2505              setSpinnerMessage('Compacting conversation');
2506              break;
2507            case 'compact_end':
2508              setSpinnerMessage(null);
2509              setSpinnerColor(null);
2510              setSpinnerShimmerColor(null);
2511              break;
2512          }
2513        },
2514        setInProgressToolUseIDs,
2515        setHasInterruptibleToolInProgress: (v: boolean) => {
2516          hasInterruptibleToolInProgressRef.current = v;
2517        },
2518        resume,
2519        setConversationId,
2520        requestPrompt: feature('HOOK_PROMPTS') ? requestPrompt : undefined,
2521        contentReplacementState: contentReplacementStateRef.current
2522      };
2523    }, [commands, combinedInitialTools, mainThreadAgentDefinition, debug, initialMcpClients, ideInstallationStatus, dynamicMcpConfig, theme, allowedAgentTypes, store, setAppState, reverify, addNotification, setMessages, onChangeDynamicMcpConfig, resume, requestPrompt, disabled, customSystemPrompt, appendSystemPrompt, setConversationId]);
2524  
2525    // Session backgrounding (Ctrl+B to background/foreground)
2526    const handleBackgroundQuery = useCallback(() => {
2527      // Stop the foreground query so the background one takes over
2528      abortController?.abort('background');
2529      // Aborting subagents may produce task-completed notifications.
2530      // Clear task notifications so the queue processor doesn't immediately
2531      // start a new foreground query; forward them to the background session.
2532      const removedNotifications = removeByFilter(cmd => cmd.mode === 'task-notification');
2533      void (async () => {
2534        const toolUseContext = getToolUseContext(messagesRef.current, [], new AbortController(), mainLoopModel);
2535        const [defaultSystemPrompt, userContext, systemContext] = await Promise.all([getSystemPrompt(toolUseContext.options.tools, mainLoopModel, Array.from(toolPermissionContext.additionalWorkingDirectories.keys()), toolUseContext.options.mcpClients), getUserContext(), getSystemContext()]);
2536        const systemPrompt = buildEffectiveSystemPrompt({
2537          mainThreadAgentDefinition,
2538          toolUseContext,
2539          customSystemPrompt,
2540          defaultSystemPrompt,
2541          appendSystemPrompt
2542        });
2543        toolUseContext.renderedSystemPrompt = systemPrompt;
2544        const notificationAttachments = await getQueuedCommandAttachments(removedNotifications).catch(() => []);
2545        const notificationMessages = notificationAttachments.map(createAttachmentMessage);
2546  
2547        // Deduplicate: if the query loop already yielded a notification into
2548        // messagesRef before we removed it from the queue, skip duplicates.
2549        // We use prompt text for dedup because source_uuid is not set on
2550        // task-notification QueuedCommands (enqueuePendingNotification callers
2551        // don't pass uuid), so it would always be undefined.
2552        const existingPrompts = new Set<string>();
2553        for (const m of messagesRef.current) {
2554          if (m.type === 'attachment' && m.attachment.type === 'queued_command' && m.attachment.commandMode === 'task-notification' && typeof m.attachment.prompt === 'string') {
2555            existingPrompts.add(m.attachment.prompt);
2556          }
2557        }
2558        const uniqueNotifications = notificationMessages.filter(m => m.attachment.type === 'queued_command' && (typeof m.attachment.prompt !== 'string' || !existingPrompts.has(m.attachment.prompt)));
2559        startBackgroundSession({
2560          messages: [...messagesRef.current, ...uniqueNotifications],
2561          queryParams: {
2562            systemPrompt,
2563            userContext,
2564            systemContext,
2565            canUseTool,
2566            toolUseContext,
2567            querySource: getQuerySourceForREPL()
2568          },
2569          description: terminalTitle,
2570          setAppState,
2571          agentDefinition: mainThreadAgentDefinition
2572        });
2573      })();
2574    }, [abortController, mainLoopModel, toolPermissionContext, mainThreadAgentDefinition, getToolUseContext, customSystemPrompt, appendSystemPrompt, canUseTool, setAppState]);
2575    const {
2576      handleBackgroundSession
2577    } = useSessionBackgrounding({
2578      setMessages,
2579      setIsLoading: setIsExternalLoading,
2580      resetLoadingState,
2581      setAbortController,
2582      onBackgroundQuery: handleBackgroundQuery
2583    });
2584    const onQueryEvent = useCallback((event: Parameters<typeof handleMessageFromStream>[0]) => {
2585      handleMessageFromStream(event, newMessage => {
2586        if (isCompactBoundaryMessage(newMessage)) {
2587          // Fullscreen: keep pre-compact messages for scrollback. query.ts
2588          // slices at the boundary for API calls, Messages.tsx skips the
2589          // boundary filter in fullscreen, and useLogMessages treats this
2590          // as an incremental append (first uuid unchanged). Cap at one
2591          // compact-interval of scrollback — normalizeMessages/applyGrouping
2592          // are O(n) per render, so drop everything before the previous
2593          // boundary to keep n bounded across multi-day sessions.
2594          if (isFullscreenEnvEnabled()) {
2595            setMessages(old => [...getMessagesAfterCompactBoundary(old, {
2596              includeSnipped: true
2597            }), newMessage]);
2598          } else {
2599            setMessages(() => [newMessage]);
2600          }
2601          // Bump conversationId so Messages.tsx row keys change and
2602          // stale memoized rows remount with post-compact content.
2603          setConversationId(randomUUID());
2604          // Compaction succeeded — clear the context-blocked flag so ticks resume
2605          if (feature('PROACTIVE') || feature('KAIROS')) {
2606            proactiveModule?.setContextBlocked(false);
2607          }
2608        } else if (newMessage.type === 'progress' && isEphemeralToolProgress(newMessage.data.type)) {
2609          // Replace the previous ephemeral progress tick for the same tool
2610          // call instead of appending. Sleep/Bash emit a tick per second and
2611          // only the last one is rendered; appending blows up the messages
2612          // array (13k+ observed) and the transcript (120MB of sleep_progress
2613          // lines). useLogMessages tracks length, so same-length replacement
2614          // also skips the transcript write.
2615          // agent_progress / hook_progress / skill_progress are NOT ephemeral
2616          // — each carries distinct state the UI needs (e.g. subagent tool
2617          // history). Replacing those leaves the AgentTool UI stuck at
2618          // "Initializing…" because it renders the full progress trail.
2619          setMessages(oldMessages => {
2620            const last = oldMessages.at(-1);
2621            if (last?.type === 'progress' && last.parentToolUseID === newMessage.parentToolUseID && last.data.type === newMessage.data.type) {
2622              const copy = oldMessages.slice();
2623              copy[copy.length - 1] = newMessage;
2624              return copy;
2625            }
2626            return [...oldMessages, newMessage];
2627          });
2628        } else {
2629          setMessages(oldMessages => [...oldMessages, newMessage]);
2630        }
2631        // Block ticks on API errors to prevent tick → error → tick
2632        // runaway loops (e.g., auth failure, rate limit, blocking limit).
2633        // Cleared on compact boundary (above) or successful response (below).
2634        if (feature('PROACTIVE') || feature('KAIROS')) {
2635          if (newMessage.type === 'assistant' && 'isApiErrorMessage' in newMessage && newMessage.isApiErrorMessage) {
2636            proactiveModule?.setContextBlocked(true);
2637          } else if (newMessage.type === 'assistant') {
2638            proactiveModule?.setContextBlocked(false);
2639          }
2640        }
2641      }, newContent => {
2642        // setResponseLength handles updating both responseLengthRef (for
2643        // spinner animation) and apiMetricsRef (endResponseLength/lastTokenTime
2644        // for OTPS). No separate metrics update needed here.
2645        setResponseLength(length => length + newContent.length);
2646      }, setStreamMode, setStreamingToolUses, tombstonedMessage => {
2647        setMessages(oldMessages => oldMessages.filter(m => m !== tombstonedMessage));
2648        void removeTranscriptMessage(tombstonedMessage.uuid);
2649      }, setStreamingThinking, metrics => {
2650        const now = Date.now();
2651        const baseline = responseLengthRef.current;
2652        apiMetricsRef.current.push({
2653          ...metrics,
2654          firstTokenTime: now,
2655          lastTokenTime: now,
2656          responseLengthBaseline: baseline,
2657          endResponseLength: baseline
2658        });
2659      }, onStreamingText);
2660    }, [setMessages, setResponseLength, setStreamMode, setStreamingToolUses, setStreamingThinking, onStreamingText]);
2661    const onQueryImpl = useCallback(async (messagesIncludingNewMessages: MessageType[], newMessages: MessageType[], abortController: AbortController, shouldQuery: boolean, additionalAllowedTools: string[], mainLoopModelParam: string, effort?: EffortValue) => {
2662      // Prepare IDE integration for new prompt. Read mcpClients fresh from
2663      // store — useManageMCPConnections may have populated it since the
2664      // render that captured this closure (same pattern as computeTools).
2665      if (shouldQuery) {
2666        const freshClients = mergeClients(initialMcpClients, store.getState().mcp.clients);
2667        void diagnosticTracker.handleQueryStart(freshClients);
2668        const ideClient = getConnectedIdeClient(freshClients);
2669        if (ideClient) {
2670          void closeOpenDiffs(ideClient);
2671        }
2672      }
2673  
2674      // Mark onboarding as complete when any user message is sent to Claude
2675      void maybeMarkProjectOnboardingComplete();
2676  
2677      // Extract a session title from the first real user message. One-shot
2678      // via ref (was tengu_birch_mist experiment: first-message-only to save
2679      // Haiku calls). The ref replaces the old `messages.length <= 1` check,
2680      // which was broken by SessionStart hook messages (prepended via
2681      // useDeferredHookMessages) and attachment messages (appended by
2682      // processTextPrompt) — both pushed length past 1 on turn one, so the
2683      // title silently fell through to the "Claude Code" default.
2684      if (!titleDisabled && !sessionTitle && !agentTitle && !haikuTitleAttemptedRef.current) {
2685        const firstUserMessage = newMessages.find(m => m.type === 'user' && !m.isMeta);
2686        const text = firstUserMessage?.type === 'user' ? getContentText(firstUserMessage.message.content) : null;
2687        // Skip synthetic breadcrumbs — slash-command output, prompt-skill
2688        // expansions (/commit → <command-message>), local-command headers
2689        // (/help → <command-name>), and bash-mode (!cmd → <bash-input>).
2690        // None of these are the user's topic; wait for real prose.
2691        if (text && !text.startsWith(`<${LOCAL_COMMAND_STDOUT_TAG}>`) && !text.startsWith(`<${COMMAND_MESSAGE_TAG}>`) && !text.startsWith(`<${COMMAND_NAME_TAG}>`) && !text.startsWith(`<${BASH_INPUT_TAG}>`)) {
2692          haikuTitleAttemptedRef.current = true;
2693          void generateSessionTitle(text, new AbortController().signal).then(title => {
2694            if (title) setHaikuTitle(title);else haikuTitleAttemptedRef.current = false;
2695          }, () => {
2696            haikuTitleAttemptedRef.current = false;
2697          });
2698        }
2699      }
2700  
2701      // Apply slash-command-scoped allowedTools (from skill frontmatter) to the
2702      // store once per turn. This also covers the reset: the next non-skill turn
2703      // passes [] and clears it. Must run before the !shouldQuery gate: forked
2704      // commands (executeForkedSlashCommand) return shouldQuery=false, and
2705      // createGetAppStateWithAllowedTools in forkedAgent.ts reads this field, so
2706      // stale skill tools would otherwise leak into forked agent permissions.
2707      // Previously this write was hidden inside getToolUseContext's getAppState
2708      // (~85 calls/turn); hoisting it here makes getAppState a pure read and stops
2709      // ephemeral contexts (permission dialog, BackgroundTasksDialog) from
2710      // accidentally clearing it mid-turn.
2711      store.setState(prev => {
2712        const cur = prev.toolPermissionContext.alwaysAllowRules.command;
2713        if (cur === additionalAllowedTools || cur?.length === additionalAllowedTools.length && cur.every((v, i) => v === additionalAllowedTools[i])) {
2714          return prev;
2715        }
2716        return {
2717          ...prev,
2718          toolPermissionContext: {
2719            ...prev.toolPermissionContext,
2720            alwaysAllowRules: {
2721              ...prev.toolPermissionContext.alwaysAllowRules,
2722              command: additionalAllowedTools
2723            }
2724          }
2725        };
2726      });
2727  
2728      // The last message is an assistant message if the user input was a bash command,
2729      // or if the user input was an invalid slash command.
2730      if (!shouldQuery) {
2731        // Manual /compact sets messages directly (shouldQuery=false) bypassing
2732        // handleMessageFromStream. Clear context-blocked if a compact boundary
2733        // is present so proactive ticks resume after compaction.
2734        if (newMessages.some(isCompactBoundaryMessage)) {
2735          // Bump conversationId so Messages.tsx row keys change and
2736          // stale memoized rows remount with post-compact content.
2737          setConversationId(randomUUID());
2738          if (feature('PROACTIVE') || feature('KAIROS')) {
2739            proactiveModule?.setContextBlocked(false);
2740          }
2741        }
2742        resetLoadingState();
2743        setAbortController(null);
2744        return;
2745      }
2746      const toolUseContext = getToolUseContext(messagesIncludingNewMessages, newMessages, abortController, mainLoopModelParam);
2747      // getToolUseContext reads tools/mcpClients fresh from store.getState()
2748      // (via computeTools/mergeClients). Use those rather than the closure-
2749      // captured `tools`/`mcpClients` — useManageMCPConnections may have
2750      // flushed new MCP state between the render that captured this closure
2751      // and now. Turn 1 via processInitialMessage is the main beneficiary.
2752      const {
2753        tools: freshTools,
2754        mcpClients: freshMcpClients
2755      } = toolUseContext.options;
2756  
2757      // Scope the skill's effort override to this turn's context only —
2758      // wrapping getAppState keeps the override out of the global store so
2759      // background agents and UI subscribers (Spinner, LogoV2) never see it.
2760      if (effort !== undefined) {
2761        const previousGetAppState = toolUseContext.getAppState;
2762        toolUseContext.getAppState = () => ({
2763          ...previousGetAppState(),
2764          effortValue: effort
2765        });
2766      }
2767      queryCheckpoint('query_context_loading_start');
2768      const [,, defaultSystemPrompt, baseUserContext, systemContext] = await Promise.all([
2769      // IMPORTANT: do this after setMessages() above, to avoid UI jank
2770      checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState),
2771      // Gated on TRANSCRIPT_CLASSIFIER so GrowthBook kill switch runs wherever auto mode is built in
2772      feature('TRANSCRIPT_CLASSIFIER') ? checkAndDisableAutoModeIfNeeded(toolPermissionContext, setAppState, store.getState().fastMode) : undefined, getSystemPrompt(freshTools, mainLoopModelParam, Array.from(toolPermissionContext.additionalWorkingDirectories.keys()), freshMcpClients), getUserContext(), getSystemContext()]);
2773      const userContext = {
2774        ...baseUserContext,
2775        ...getCoordinatorUserContext(freshMcpClients, isScratchpadEnabled() ? getScratchpadDir() : undefined),
2776        ...((feature('PROACTIVE') || feature('KAIROS')) && proactiveModule?.isProactiveActive() && !terminalFocusRef.current ? {
2777          terminalFocus: 'The terminal is unfocused \u2014 the user is not actively watching.'
2778        } : {})
2779      };
2780      queryCheckpoint('query_context_loading_end');
2781      const systemPrompt = buildEffectiveSystemPrompt({
2782        mainThreadAgentDefinition,
2783        toolUseContext,
2784        customSystemPrompt,
2785        defaultSystemPrompt,
2786        appendSystemPrompt
2787      });
2788      toolUseContext.renderedSystemPrompt = systemPrompt;
2789      queryCheckpoint('query_query_start');
2790      resetTurnHookDuration();
2791      resetTurnToolDuration();
2792      resetTurnClassifierDuration();
2793      for await (const event of query({
2794        messages: messagesIncludingNewMessages,
2795        systemPrompt,
2796        userContext,
2797        systemContext,
2798        canUseTool,
2799        toolUseContext,
2800        querySource: getQuerySourceForREPL()
2801      })) {
2802        onQueryEvent(event);
2803      }
2804      if (feature('BUDDY')) {
2805        void fireCompanionObserver(messagesRef.current, reaction => setAppState(prev => prev.companionReaction === reaction ? prev : {
2806          ...prev,
2807          companionReaction: reaction
2808        }));
2809      }
2810      queryCheckpoint('query_end');
2811  
2812      // Capture ant-only API metrics before resetLoadingState clears the ref.
2813      // For multi-request turns (tool use loops), compute P50 across all requests.
2814      if ("external" === 'ant' && apiMetricsRef.current.length > 0) {
2815        const entries = apiMetricsRef.current;
2816        const ttfts = entries.map(e => e.ttftMs);
2817        // Compute per-request OTPS using only active streaming time and
2818        // streaming-only content. endResponseLength tracks content added by
2819        // streaming deltas only, excluding subagent/compaction inflation.
2820        const otpsValues = entries.map(e => {
2821          const delta = Math.round((e.endResponseLength - e.responseLengthBaseline) / 4);
2822          const samplingMs = e.lastTokenTime - e.firstTokenTime;
2823          return samplingMs > 0 ? Math.round(delta / (samplingMs / 1000)) : 0;
2824        });
2825        const isMultiRequest = entries.length > 1;
2826        const hookMs = getTurnHookDurationMs();
2827        const hookCount = getTurnHookCount();
2828        const toolMs = getTurnToolDurationMs();
2829        const toolCount = getTurnToolCount();
2830        const classifierMs = getTurnClassifierDurationMs();
2831        const classifierCount = getTurnClassifierCount();
2832        const turnMs = Date.now() - loadingStartTimeRef.current;
2833        setMessages(prev => [...prev, createApiMetricsMessage({
2834          ttftMs: isMultiRequest ? median(ttfts) : ttfts[0]!,
2835          otps: isMultiRequest ? median(otpsValues) : otpsValues[0]!,
2836          isP50: isMultiRequest,
2837          hookDurationMs: hookMs > 0 ? hookMs : undefined,
2838          hookCount: hookCount > 0 ? hookCount : undefined,
2839          turnDurationMs: turnMs > 0 ? turnMs : undefined,
2840          toolDurationMs: toolMs > 0 ? toolMs : undefined,
2841          toolCount: toolCount > 0 ? toolCount : undefined,
2842          classifierDurationMs: classifierMs > 0 ? classifierMs : undefined,
2843          classifierCount: classifierCount > 0 ? classifierCount : undefined,
2844          configWriteCount: getGlobalConfigWriteCount()
2845        })]);
2846      }
2847      resetLoadingState();
2848  
2849      // Log query profiling report if enabled
2850      logQueryProfileReport();
2851  
2852      // Signal that a query turn has completed successfully
2853      await onTurnComplete?.(messagesRef.current);
2854    }, [initialMcpClients, resetLoadingState, getToolUseContext, toolPermissionContext, setAppState, customSystemPrompt, onTurnComplete, appendSystemPrompt, canUseTool, mainThreadAgentDefinition, onQueryEvent, sessionTitle, titleDisabled]);
2855    const onQuery = useCallback(async (newMessages: MessageType[], abortController: AbortController, shouldQuery: boolean, additionalAllowedTools: string[], mainLoopModelParam: string, onBeforeQueryCallback?: (input: string, newMessages: MessageType[]) => Promise<boolean>, input?: string, effort?: EffortValue): Promise<void> => {
2856      // If this is a teammate, mark them as active when starting a turn
2857      if (isAgentSwarmsEnabled()) {
2858        const teamName = getTeamName();
2859        const agentName = getAgentName();
2860        if (teamName && agentName) {
2861          // Fire and forget - turn starts immediately, write happens in background
2862          void setMemberActive(teamName, agentName, true);
2863        }
2864      }
2865  
2866      // Concurrent guard via state machine. tryStart() atomically checks
2867      // and transitions idle→running, returning the generation number.
2868      // Returns null if already running — no separate check-then-set.
2869      const thisGeneration = queryGuard.tryStart();
2870      if (thisGeneration === null) {
2871        logEvent('tengu_concurrent_onquery_detected', {});
2872  
2873        // Extract and enqueue user message text, skipping meta messages
2874        // (e.g. expanded skill content, tick prompts) that should not be
2875        // replayed as user-visible text.
2876        newMessages.filter((m): m is UserMessage => m.type === 'user' && !m.isMeta).map(_ => getContentText(_.message.content)).filter(_ => _ !== null).forEach((msg, i) => {
2877          enqueue({
2878            value: msg,
2879            mode: 'prompt'
2880          });
2881          if (i === 0) {
2882            logEvent('tengu_concurrent_onquery_enqueued', {});
2883          }
2884        });
2885        return;
2886      }
2887      try {
2888        // isLoading is derived from queryGuard — tryStart() above already
2889        // transitioned dispatching→running, so no setter call needed here.
2890        resetTimingRefs();
2891        setMessages(oldMessages => [...oldMessages, ...newMessages]);
2892        responseLengthRef.current = 0;
2893        if (feature('TOKEN_BUDGET')) {
2894          const parsedBudget = input ? parseTokenBudget(input) : null;
2895          snapshotOutputTokensForTurn(parsedBudget ?? getCurrentTurnTokenBudget());
2896        }
2897        apiMetricsRef.current = [];
2898        setStreamingToolUses([]);
2899        setStreamingText(null);
2900  
2901        // messagesRef is updated synchronously by the setMessages wrapper
2902        // above, so it already includes newMessages from the append at the
2903        // top of this try block.  No reconstruction needed, no waiting for
2904        // React's scheduler (previously cost 20-56ms per prompt; the 56ms
2905        // case was a GC pause caught during the await).
2906        const latestMessages = messagesRef.current;
2907        if (input) {
2908          await mrOnBeforeQuery(input, latestMessages, newMessages.length);
2909        }
2910  
2911        // Pass full conversation history to callback
2912        if (onBeforeQueryCallback && input) {
2913          const shouldProceed = await onBeforeQueryCallback(input, latestMessages);
2914          if (!shouldProceed) {
2915            return;
2916          }
2917        }
2918        await onQueryImpl(latestMessages, newMessages, abortController, shouldQuery, additionalAllowedTools, mainLoopModelParam, effort);
2919      } finally {
2920        // queryGuard.end() atomically checks generation and transitions
2921        // running→idle. Returns false if a newer query owns the guard
2922        // (cancel+resubmit race where the stale finally fires as a microtask).
2923        if (queryGuard.end(thisGeneration)) {
2924          setLastQueryCompletionTime(Date.now());
2925          skipIdleCheckRef.current = false;
2926          // Always reset loading state in finally - this ensures cleanup even
2927          // if onQueryImpl throws. onTurnComplete is called separately in
2928          // onQueryImpl only on successful completion.
2929          resetLoadingState();
2930          await mrOnTurnComplete(messagesRef.current, abortController.signal.aborted);
2931  
2932          // Notify bridge clients that the turn is complete so mobile apps
2933          // can stop the spark animation and show post-turn UI.
2934          sendBridgeResultRef.current();
2935  
2936          // Auto-hide tungsten panel content at turn end (ant-only), but keep
2937          // tungstenActiveSession set so the pill stays in the footer and the user
2938          // can reopen the panel. Background tmux tasks (e.g. /hunter) run for
2939          // minutes — wiping the session made the pill disappear entirely, forcing
2940          // the user to re-invoke Tmux just to peek. Skip on abort so the panel
2941          // stays open for inspection (matches the turn-duration guard below).
2942          if ("external" === 'ant' && !abortController.signal.aborted) {
2943            setAppState(prev => {
2944              if (prev.tungstenActiveSession === undefined) return prev;
2945              if (prev.tungstenPanelAutoHidden === true) return prev;
2946              return {
2947                ...prev,
2948                tungstenPanelAutoHidden: true
2949              };
2950            });
2951          }
2952  
2953          // Capture budget info before clearing (ant-only)
2954          let budgetInfo: {
2955            tokens: number;
2956            limit: number;
2957            nudges: number;
2958          } | undefined;
2959          if (feature('TOKEN_BUDGET')) {
2960            if (getCurrentTurnTokenBudget() !== null && getCurrentTurnTokenBudget()! > 0 && !abortController.signal.aborted) {
2961              budgetInfo = {
2962                tokens: getTurnOutputTokens(),
2963                limit: getCurrentTurnTokenBudget()!,
2964                nudges: getBudgetContinuationCount()
2965              };
2966            }
2967            snapshotOutputTokensForTurn(null);
2968          }
2969  
2970          // Add turn duration message for turns longer than 30s or with a budget
2971          // Skip if user aborted or if in loop mode (too noisy between ticks)
2972          // Defer if swarm teammates are still running (show when they finish)
2973          const turnDurationMs = Date.now() - loadingStartTimeRef.current - totalPausedMsRef.current;
2974          if ((turnDurationMs > 30000 || budgetInfo !== undefined) && !abortController.signal.aborted && !proactiveActive) {
2975            const hasRunningSwarmAgents = getAllInProcessTeammateTasks(store.getState().tasks).some(t => t.status === 'running');
2976            if (hasRunningSwarmAgents) {
2977              // Only record start time on the first deferred turn
2978              if (swarmStartTimeRef.current === null) {
2979                swarmStartTimeRef.current = loadingStartTimeRef.current;
2980              }
2981              // Always update budget — later turns may carry the actual budget
2982              if (budgetInfo) {
2983                swarmBudgetInfoRef.current = budgetInfo;
2984              }
2985            } else {
2986              setMessages(prev => [...prev, createTurnDurationMessage(turnDurationMs, budgetInfo, count(prev, isLoggableMessage))]);
2987            }
2988          }
2989          // Clear the controller so CancelRequestHandler's canCancelRunningTask
2990          // reads false at the idle prompt. Without this, the stale non-aborted
2991          // controller makes ctrl+c fire onCancel() (aborting nothing) instead of
2992          // propagating to the double-press exit flow.
2993          setAbortController(null);
2994        }
2995  
2996        // Auto-restore: if the user interrupted before any meaningful response
2997        // arrived, rewind the conversation and restore their prompt — same as
2998        // opening the message selector and picking the last message.
2999        // This runs OUTSIDE the queryGuard.end() check because onCancel calls
3000        // forceEnd(), which bumps the generation so end() returns false above.
3001        // Guards: reason === 'user-cancel' (onCancel/Esc; programmatic aborts
3002        // use 'background'/'interrupt' and must not rewind — note abort() with
3003        // no args sets reason to a DOMException, not undefined), !isActive (no
3004        // newer query started — cancel+resubmit race), empty input (don't
3005        // clobber text typed during loading), no queued commands (user queued
3006        // B while A was loading → they've moved on, don't restore A; also
3007        // avoids removeLastFromHistory removing B's entry instead of A's),
3008        // not viewing a teammate (messagesRef is the main conversation — the
3009        // old Up-arrow quick-restore had this guard, preserve it).
3010        if (abortController.signal.reason === 'user-cancel' && !queryGuard.isActive && inputValueRef.current === '' && getCommandQueueLength() === 0 && !store.getState().viewingAgentTaskId) {
3011          const msgs = messagesRef.current;
3012          const lastUserMsg = msgs.findLast(selectableUserMessagesFilter);
3013          if (lastUserMsg) {
3014            const idx = msgs.lastIndexOf(lastUserMsg);
3015            if (messagesAfterAreOnlySynthetic(msgs, idx)) {
3016              // The submit is being undone — undo its history entry too,
3017              // otherwise Up-arrow shows the restored text twice.
3018              removeLastFromHistory();
3019              restoreMessageSyncRef.current(lastUserMsg);
3020            }
3021          }
3022        }
3023      }
3024    }, [onQueryImpl, setAppState, resetLoadingState, queryGuard, mrOnBeforeQuery, mrOnTurnComplete]);
3025  
3026    // Handle initial message (from CLI args or plan mode exit with context clear)
3027    // This effect runs when isLoading becomes false and there's a pending message
3028    const initialMessageRef = useRef(false);
3029    useEffect(() => {
3030      const pending = initialMessage;
3031      if (!pending || isLoading || initialMessageRef.current) return;
3032  
3033      // Mark as processing to prevent re-entry
3034      initialMessageRef.current = true;
3035      async function processInitialMessage(initialMsg: NonNullable<typeof pending>) {
3036        // Clear context if requested (plan mode exit)
3037        if (initialMsg.clearContext) {
3038          // Preserve the plan slug before clearing context, so the new session
3039          // can access the same plan file after regenerateSessionId()
3040          const oldPlanSlug = initialMsg.message.planContent ? getPlanSlug() : undefined;
3041          const {
3042            clearConversation
3043          } = await import('../commands/clear/conversation.js');
3044          await clearConversation({
3045            setMessages,
3046            readFileState: readFileState.current,
3047            discoveredSkillNames: discoveredSkillNamesRef.current,
3048            loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,
3049            getAppState: () => store.getState(),
3050            setAppState,
3051            setConversationId
3052          });
3053          haikuTitleAttemptedRef.current = false;
3054          setHaikuTitle(undefined);
3055          bashTools.current.clear();
3056          bashToolsProcessedIdx.current = 0;
3057  
3058          // Restore the plan slug for the new session so getPlan() finds the file
3059          if (oldPlanSlug) {
3060            setPlanSlug(getSessionId(), oldPlanSlug);
3061          }
3062        }
3063  
3064        // Atomically: clear initial message, set permission mode and rules, and store plan for verification
3065        const shouldStorePlanForVerification = initialMsg.message.planContent && "external" === 'ant' && isEnvTruthy(undefined);
3066        setAppState(prev => {
3067          // Build and apply permission updates (mode + allowedPrompts rules)
3068          let updatedToolPermissionContext = initialMsg.mode ? applyPermissionUpdates(prev.toolPermissionContext, buildPermissionUpdates(initialMsg.mode, initialMsg.allowedPrompts)) : prev.toolPermissionContext;
3069          // For auto, override the mode (buildPermissionUpdates maps
3070          // it to 'default' via toExternalPermissionMode) and strip dangerous rules
3071          if (feature('TRANSCRIPT_CLASSIFIER') && initialMsg.mode === 'auto') {
3072            updatedToolPermissionContext = stripDangerousPermissionsForAutoMode({
3073              ...updatedToolPermissionContext,
3074              mode: 'auto',
3075              prePlanMode: undefined
3076            });
3077          }
3078          return {
3079            ...prev,
3080            initialMessage: null,
3081            toolPermissionContext: updatedToolPermissionContext,
3082            ...(shouldStorePlanForVerification && {
3083              pendingPlanVerification: {
3084                plan: initialMsg.message.planContent!,
3085                verificationStarted: false,
3086                verificationCompleted: false
3087              }
3088            })
3089          };
3090        });
3091  
3092        // Create file history snapshot for code rewind
3093        if (fileHistoryEnabled()) {
3094          void fileHistoryMakeSnapshot((updater: (prev: FileHistoryState) => FileHistoryState) => {
3095            setAppState(prev => ({
3096              ...prev,
3097              fileHistory: updater(prev.fileHistory)
3098            }));
3099          }, initialMsg.message.uuid);
3100        }
3101  
3102        // Ensure SessionStart hook context is available before the first API
3103        // call. onSubmit calls this internally but the onQuery path below
3104        // bypasses onSubmit — hoist here so both paths see hook messages.
3105        await awaitPendingHooks();
3106  
3107        // Route all initial prompts through onSubmit to ensure UserPromptSubmit hooks fire
3108        // TODO: Simplify by always routing through onSubmit once it supports
3109        // ContentBlockParam arrays (images) as input
3110        const content = initialMsg.message.message.content;
3111  
3112        // Route all string content through onSubmit to ensure hooks fire
3113        // For complex content (images, etc.), fall back to direct onQuery
3114        // Plan messages bypass onSubmit to preserve planContent metadata for rendering
3115        if (typeof content === 'string' && !initialMsg.message.planContent) {
3116          // Route through onSubmit for proper processing including UserPromptSubmit hooks
3117          void onSubmit(content, {
3118            setCursorOffset: () => {},
3119            clearBuffer: () => {},
3120            resetHistory: () => {}
3121          });
3122        } else {
3123          // Plan messages or complex content (images, etc.) - send directly to model
3124          // Plan messages use onQuery to preserve planContent metadata for rendering
3125          // TODO: Once onSubmit supports ContentBlockParam arrays, remove this branch
3126          const newAbortController = createAbortController();
3127          setAbortController(newAbortController);
3128          void onQuery([initialMsg.message], newAbortController, true,
3129          // shouldQuery
3130          [],
3131          // additionalAllowedTools
3132          mainLoopModel);
3133        }
3134  
3135        // Reset ref after a delay to allow new initial messages
3136        setTimeout(ref => {
3137          ref.current = false;
3138        }, 100, initialMessageRef);
3139      }
3140      void processInitialMessage(pending);
3141    }, [initialMessage, isLoading, setMessages, setAppState, onQuery, mainLoopModel, tools]);
3142    const onSubmit = useCallback(async (input: string, helpers: PromptInputHelpers, speculationAccept?: {
3143      state: ActiveSpeculationState;
3144      speculationSessionTimeSavedMs: number;
3145      setAppState: SetAppState;
3146    }, options?: {
3147      fromKeybinding?: boolean;
3148    }) => {
3149      // Re-pin scroll to bottom on submit so the user always sees the new
3150      // exchange (matches OpenCode's auto-scroll behavior).
3151      repinScroll();
3152  
3153      // Resume loop mode if paused
3154      if (feature('PROACTIVE') || feature('KAIROS')) {
3155        proactiveModule?.resumeProactive();
3156      }
3157  
3158      // Handle immediate commands - these bypass the queue and execute right away
3159      // even while Claude is processing. Commands opt-in via `immediate: true`.
3160      // Commands triggered via keybindings are always treated as immediate.
3161      if (!speculationAccept && input.trim().startsWith('/')) {
3162        // Expand [Pasted text #N] refs so immediate commands (e.g. /btw) receive
3163        // the pasted content, not the placeholder. The non-immediate path gets
3164        // this expansion later in handlePromptSubmit.
3165        const trimmedInput = expandPastedTextRefs(input, pastedContents).trim();
3166        const spaceIndex = trimmedInput.indexOf(' ');
3167        const commandName = spaceIndex === -1 ? trimmedInput.slice(1) : trimmedInput.slice(1, spaceIndex);
3168        const commandArgs = spaceIndex === -1 ? '' : trimmedInput.slice(spaceIndex + 1).trim();
3169  
3170        // Find matching command - treat as immediate if:
3171        // 1. Command has `immediate: true`, OR
3172        // 2. Command was triggered via keybinding (fromKeybinding option)
3173        const matchingCommand = commands.find(cmd => isCommandEnabled(cmd) && (cmd.name === commandName || cmd.aliases?.includes(commandName) || getCommandName(cmd) === commandName));
3174        if (matchingCommand?.name === 'clear' && idleHintShownRef.current) {
3175          logEvent('tengu_idle_return_action', {
3176            action: 'hint_converted' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3177            variant: idleHintShownRef.current as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3178            idleMinutes: Math.round((Date.now() - lastQueryCompletionTimeRef.current) / 60_000),
3179            messageCount: messagesRef.current.length,
3180            totalInputTokens: getTotalInputTokens()
3181          });
3182          idleHintShownRef.current = false;
3183        }
3184        const shouldTreatAsImmediate = queryGuard.isActive && (matchingCommand?.immediate || options?.fromKeybinding);
3185        if (matchingCommand && shouldTreatAsImmediate && matchingCommand.type === 'local-jsx') {
3186          // Only clear input if the submitted text matches what's in the prompt.
3187          // When a command keybinding fires, input is "/<command>" but the actual
3188          // input value is the user's existing text - don't clear it in that case.
3189          if (input.trim() === inputValueRef.current.trim()) {
3190            setInputValue('');
3191            helpers.setCursorOffset(0);
3192            helpers.clearBuffer();
3193            setPastedContents({});
3194          }
3195          const pastedTextRefs = parseReferences(input).filter(r => pastedContents[r.id]?.type === 'text');
3196          const pastedTextCount = pastedTextRefs.length;
3197          const pastedTextBytes = pastedTextRefs.reduce((sum, r) => sum + (pastedContents[r.id]?.content.length ?? 0), 0);
3198          logEvent('tengu_paste_text', {
3199            pastedTextCount,
3200            pastedTextBytes
3201          });
3202          logEvent('tengu_immediate_command_executed', {
3203            commandName: matchingCommand.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3204            fromKeybinding: options?.fromKeybinding ?? false
3205          });
3206  
3207          // Execute the command directly
3208          const executeImmediateCommand = async (): Promise<void> => {
3209            let doneWasCalled = false;
3210            const onDone = (result?: string, doneOptions?: {
3211              display?: CommandResultDisplay;
3212              metaMessages?: string[];
3213            }): void => {
3214              doneWasCalled = true;
3215              setToolJSX({
3216                jsx: null,
3217                shouldHidePromptInput: false,
3218                clearLocalJSX: true
3219              });
3220              const newMessages: MessageType[] = [];
3221              if (result && doneOptions?.display !== 'skip') {
3222                addNotification({
3223                  key: `immediate-${matchingCommand.name}`,
3224                  text: result,
3225                  priority: 'immediate'
3226                });
3227                // In fullscreen the command just showed as a centered modal
3228                // pane — the notification above is enough feedback. Adding
3229                // "❯ /config" + "⎿ dismissed" to the transcript is clutter
3230                // (those messages are type:system subtype:local_command —
3231                // user-visible but NOT sent to the model, so skipping them
3232                // doesn't change model context). Outside fullscreen the
3233                // transcript entry stays so scrollback shows what ran.
3234                if (!isFullscreenEnvEnabled()) {
3235                  newMessages.push(createCommandInputMessage(formatCommandInputTags(getCommandName(matchingCommand), commandArgs)), createCommandInputMessage(`<${LOCAL_COMMAND_STDOUT_TAG}>${escapeXml(result)}</${LOCAL_COMMAND_STDOUT_TAG}>`));
3236                }
3237              }
3238              // Inject meta messages (model-visible, user-hidden) into the transcript
3239              if (doneOptions?.metaMessages?.length) {
3240                newMessages.push(...doneOptions.metaMessages.map(content => createUserMessage({
3241                  content,
3242                  isMeta: true
3243                })));
3244              }
3245              if (newMessages.length) {
3246                setMessages(prev => [...prev, ...newMessages]);
3247              }
3248              // Restore stashed prompt after local-jsx command completes.
3249              // The normal stash restoration path (below) is skipped because
3250              // local-jsx commands return early from onSubmit.
3251              if (stashedPrompt !== undefined) {
3252                setInputValue(stashedPrompt.text);
3253                helpers.setCursorOffset(stashedPrompt.cursorOffset);
3254                setPastedContents(stashedPrompt.pastedContents);
3255                setStashedPrompt(undefined);
3256              }
3257            };
3258  
3259            // Build context for the command (reuses existing getToolUseContext).
3260            // Read messages via ref to keep onSubmit stable across message
3261            // updates — matches the pattern at L2384/L2400/L2662 and avoids
3262            // pinning stale REPL render scopes in downstream closures.
3263            const context = getToolUseContext(messagesRef.current, [], createAbortController(), mainLoopModel);
3264            const mod = await matchingCommand.load();
3265            const jsx = await mod.call(onDone, context, commandArgs);
3266  
3267            // Skip if onDone already fired — prevents stuck isLocalJSXCommand
3268            // (see processSlashCommand.tsx local-jsx case for full mechanism).
3269            if (jsx && !doneWasCalled) {
3270              // shouldHidePromptInput: false keeps Notifications mounted
3271              // so the onDone result isn't lost
3272              setToolJSX({
3273                jsx,
3274                shouldHidePromptInput: false,
3275                isLocalJSXCommand: true
3276              });
3277            }
3278          };
3279          void executeImmediateCommand();
3280          return; // Always return early - don't add to history or queue
3281        }
3282      }
3283  
3284      // Remote mode: skip empty input early before any state mutations
3285      if (activeRemote.isRemoteMode && !input.trim()) {
3286        return;
3287      }
3288  
3289      // Idle-return: prompt returning users to start fresh when the
3290      // conversation is large and the cache is cold. tengu_willow_mode
3291      // controls treatment: "dialog" (blocking), "hint" (notification), "off".
3292      {
3293        const willowMode = getFeatureValue_CACHED_MAY_BE_STALE('tengu_willow_mode', 'off');
3294        const idleThresholdMin = Number(process.env.CLAUDE_CODE_IDLE_THRESHOLD_MINUTES ?? 75);
3295        const tokenThreshold = Number(process.env.CLAUDE_CODE_IDLE_TOKEN_THRESHOLD ?? 100_000);
3296        if (willowMode !== 'off' && !getGlobalConfig().idleReturnDismissed && !skipIdleCheckRef.current && !speculationAccept && !input.trim().startsWith('/') && lastQueryCompletionTimeRef.current > 0 && getTotalInputTokens() >= tokenThreshold) {
3297          const idleMs = Date.now() - lastQueryCompletionTimeRef.current;
3298          const idleMinutes = idleMs / 60_000;
3299          if (idleMinutes >= idleThresholdMin && willowMode === 'dialog') {
3300            setIdleReturnPending({
3301              input,
3302              idleMinutes
3303            });
3304            setInputValue('');
3305            helpers.setCursorOffset(0);
3306            helpers.clearBuffer();
3307            return;
3308          }
3309        }
3310      }
3311  
3312      // Add to history for direct user submissions.
3313      // Queued command processing (executeQueuedInput) doesn't call onSubmit,
3314      // so notifications and already-queued user input won't be added to history here.
3315      // Skip history for keybinding-triggered commands (user didn't type the command).
3316      if (!options?.fromKeybinding) {
3317        addToHistory({
3318          display: speculationAccept ? input : prependModeCharacterToInput(input, inputMode),
3319          pastedContents: speculationAccept ? {} : pastedContents
3320        });
3321        // Add the just-submitted command to the front of the ghost-text
3322        // cache so it's suggested immediately (not after the 60s TTL).
3323        if (inputMode === 'bash') {
3324          prependToShellHistoryCache(input.trim());
3325        }
3326      }
3327  
3328      // Restore stash if present, but NOT for slash commands or when loading.
3329      // - Slash commands (especially interactive ones like /model, /context) hide
3330      //   the prompt and show a picker UI. Restoring the stash during a command would
3331      //   place the text in a hidden input, and the user would lose it by typing the
3332      //   next command. Instead, preserve the stash so it survives across command runs.
3333      // - When loading, the submitted input will be queued and handlePromptSubmit
3334      //   will clear the input field (onInputChange('')), which would clobber the
3335      //   restored stash. Defer restoration to after handlePromptSubmit (below).
3336      //   Remote mode is exempt: it sends via WebSocket and returns early without
3337      //   calling handlePromptSubmit, so there's no clobbering risk — restore eagerly.
3338      // In both deferred cases, the stash is restored after await handlePromptSubmit.
3339      const isSlashCommand = !speculationAccept && input.trim().startsWith('/');
3340      // Submit runs "now" (not queued) when not already loading, or when
3341      // accepting speculation, or in remote mode (which sends via WS and
3342      // returns early without calling handlePromptSubmit).
3343      const submitsNow = !isLoading || speculationAccept || activeRemote.isRemoteMode;
3344      if (stashedPrompt !== undefined && !isSlashCommand && submitsNow) {
3345        setInputValue(stashedPrompt.text);
3346        helpers.setCursorOffset(stashedPrompt.cursorOffset);
3347        setPastedContents(stashedPrompt.pastedContents);
3348        setStashedPrompt(undefined);
3349      } else if (submitsNow) {
3350        if (!options?.fromKeybinding) {
3351          // Clear input when not loading or accepting speculation.
3352          // Preserve input for keybinding-triggered commands.
3353          setInputValue('');
3354          helpers.setCursorOffset(0);
3355        }
3356        setPastedContents({});
3357      }
3358      if (submitsNow) {
3359        setInputMode('prompt');
3360        setIDESelection(undefined);
3361        setSubmitCount(_ => _ + 1);
3362        helpers.clearBuffer();
3363        tipPickedThisTurnRef.current = false;
3364  
3365        // Show the placeholder in the same React batch as setInputValue('').
3366        // Skip for slash/bash (they have their own echo), speculation and remote
3367        // mode (both setMessages directly with no gap to bridge).
3368        if (!isSlashCommand && inputMode === 'prompt' && !speculationAccept && !activeRemote.isRemoteMode) {
3369          setUserInputOnProcessing(input);
3370          // showSpinner includes userInputOnProcessing, so the spinner appears
3371          // on this render. Reset timing refs now (before queryGuard.reserve()
3372          // would) so elapsed time doesn't read as Date.now() - 0. The
3373          // isQueryActive transition above does the same reset — idempotent.
3374          resetTimingRefs();
3375        }
3376  
3377        // Increment prompt count for attribution tracking and save snapshot
3378        // The snapshot persists promptCount so it survives compaction
3379        if (feature('COMMIT_ATTRIBUTION')) {
3380          setAppState(prev => ({
3381            ...prev,
3382            attribution: incrementPromptCount(prev.attribution, snapshot => {
3383              void recordAttributionSnapshot(snapshot).catch(error => {
3384                logForDebugging(`Attribution: Failed to save snapshot: ${error}`);
3385              });
3386            })
3387          }));
3388        }
3389      }
3390  
3391      // Handle speculation acceptance
3392      if (speculationAccept) {
3393        const {
3394          queryRequired
3395        } = await handleSpeculationAccept(speculationAccept.state, speculationAccept.speculationSessionTimeSavedMs, speculationAccept.setAppState, input, {
3396          setMessages,
3397          readFileState,
3398          cwd: getOriginalCwd()
3399        });
3400        if (queryRequired) {
3401          const newAbortController = createAbortController();
3402          setAbortController(newAbortController);
3403          void onQuery([], newAbortController, true, [], mainLoopModel);
3404        }
3405        return;
3406      }
3407  
3408      // Remote mode: send input via stream-json instead of local query.
3409      // Permission requests from the remote are bridged into toolUseConfirmQueue
3410      // and rendered using the standard PermissionRequest component.
3411      //
3412      // local-jsx slash commands (e.g. /agents, /config) render UI in THIS
3413      // process — they have no remote equivalent. Let those fall through to
3414      // handlePromptSubmit so they execute locally. Prompt commands and
3415      // plain text go to the remote.
3416      if (activeRemote.isRemoteMode && !(isSlashCommand && commands.find(c => {
3417        const name = input.trim().slice(1).split(/\s/)[0];
3418        return isCommandEnabled(c) && (c.name === name || c.aliases?.includes(name!) || getCommandName(c) === name);
3419      })?.type === 'local-jsx')) {
3420        // Build content blocks when there are pasted attachments (images)
3421        const pastedValues = Object.values(pastedContents);
3422        const imageContents = pastedValues.filter(c => c.type === 'image');
3423        const imagePasteIds = imageContents.length > 0 ? imageContents.map(c => c.id) : undefined;
3424        let messageContent: string | ContentBlockParam[] = input.trim();
3425        let remoteContent: RemoteMessageContent = input.trim();
3426        if (pastedValues.length > 0) {
3427          const contentBlocks: ContentBlockParam[] = [];
3428          const remoteBlocks: Array<{
3429            type: string;
3430            [key: string]: unknown;
3431          }> = [];
3432          const trimmedInput = input.trim();
3433          if (trimmedInput) {
3434            contentBlocks.push({
3435              type: 'text',
3436              text: trimmedInput
3437            });
3438            remoteBlocks.push({
3439              type: 'text',
3440              text: trimmedInput
3441            });
3442          }
3443          for (const pasted of pastedValues) {
3444            if (pasted.type === 'image') {
3445              const source = {
3446                type: 'base64' as const,
3447                media_type: (pasted.mediaType ?? 'image/png') as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp',
3448                data: pasted.content
3449              };
3450              contentBlocks.push({
3451                type: 'image',
3452                source
3453              });
3454              remoteBlocks.push({
3455                type: 'image',
3456                source
3457              });
3458            } else {
3459              contentBlocks.push({
3460                type: 'text',
3461                text: pasted.content
3462              });
3463              remoteBlocks.push({
3464                type: 'text',
3465                text: pasted.content
3466              });
3467            }
3468          }
3469          messageContent = contentBlocks;
3470          remoteContent = remoteBlocks;
3471        }
3472  
3473        // Create and add user message to UI
3474        // Note: empty input already handled by early return above
3475        const userMessage = createUserMessage({
3476          content: messageContent,
3477          imagePasteIds
3478        });
3479        setMessages(prev => [...prev, userMessage]);
3480  
3481        // Send to remote session
3482        await activeRemote.sendMessage(remoteContent, {
3483          uuid: userMessage.uuid
3484        });
3485        return;
3486      }
3487  
3488      // Ensure SessionStart hook context is available before the first API call.
3489      await awaitPendingHooks();
3490      await handlePromptSubmit({
3491        input,
3492        helpers,
3493        queryGuard,
3494        isExternalLoading,
3495        mode: inputMode,
3496        commands,
3497        onInputChange: setInputValue,
3498        setPastedContents,
3499        setToolJSX,
3500        getToolUseContext,
3501        messages: messagesRef.current,
3502        mainLoopModel,
3503        pastedContents,
3504        ideSelection,
3505        setUserInputOnProcessing,
3506        setAbortController,
3507        abortController,
3508        onQuery,
3509        setAppState,
3510        querySource: getQuerySourceForREPL(),
3511        onBeforeQuery,
3512        canUseTool,
3513        addNotification,
3514        setMessages,
3515        // Read via ref so streamMode can be dropped from onSubmit deps —
3516        // handlePromptSubmit only uses it for debug log + telemetry event.
3517        streamMode: streamModeRef.current,
3518        hasInterruptibleToolInProgress: hasInterruptibleToolInProgressRef.current
3519      });
3520  
3521      // Restore stash that was deferred above. Two cases:
3522      // - Slash command: handlePromptSubmit awaited the full command execution
3523      //   (including interactive pickers). Restoring now places the stash back in
3524      //   the visible input.
3525      // - Loading (queued): handlePromptSubmit enqueued + cleared input, then
3526      //   returned quickly. Restoring now places the stash back after the clear.
3527      if ((isSlashCommand || isLoading) && stashedPrompt !== undefined) {
3528        setInputValue(stashedPrompt.text);
3529        helpers.setCursorOffset(stashedPrompt.cursorOffset);
3530        setPastedContents(stashedPrompt.pastedContents);
3531        setStashedPrompt(undefined);
3532      }
3533    }, [queryGuard,
3534    // isLoading is read at the !isLoading checks above for input-clearing
3535    // and submitCount gating. It's derived from isQueryActive || isExternalLoading,
3536    // so including it here ensures the closure captures the fresh value.
3537    isLoading, isExternalLoading, inputMode, commands, setInputValue, setInputMode, setPastedContents, setSubmitCount, setIDESelection, setToolJSX, getToolUseContext,
3538    // messages is read via messagesRef.current inside the callback to
3539    // keep onSubmit stable across message updates (see L2384/L2400/L2662).
3540    // Without this, each setMessages call (~30× per turn) recreates
3541    // onSubmit, pinning the REPL render scope (1776B) + that render's
3542    // messages array in downstream closures (PromptInput, handleAutoRunIssue).
3543    // Heap analysis showed ~9 REPL scopes and ~15 messages array versions
3544    // accumulating after #20174/#20175, all traced to this dep.
3545    mainLoopModel, pastedContents, ideSelection, setUserInputOnProcessing, setAbortController, addNotification, onQuery, stashedPrompt, setStashedPrompt, setAppState, onBeforeQuery, canUseTool, remoteSession, setMessages, awaitPendingHooks, repinScroll]);
3546  
3547    // Callback for when user submits input while viewing a teammate's transcript
3548    const onAgentSubmit = useCallback(async (input: string, task: InProcessTeammateTaskState | LocalAgentTaskState, helpers: PromptInputHelpers) => {
3549      if (isLocalAgentTask(task)) {
3550        appendMessageToLocalAgent(task.id, createUserMessage({
3551          content: input
3552        }), setAppState);
3553        if (task.status === 'running') {
3554          queuePendingMessage(task.id, input, setAppState);
3555        } else {
3556          void resumeAgentBackground({
3557            agentId: task.id,
3558            prompt: input,
3559            toolUseContext: getToolUseContext(messagesRef.current, [], new AbortController(), mainLoopModel),
3560            canUseTool
3561          }).catch(err => {
3562            logForDebugging(`resumeAgentBackground failed: ${errorMessage(err)}`);
3563            addNotification({
3564              key: `resume-agent-failed-${task.id}`,
3565              jsx: <Text color="error">
3566                    Failed to resume agent: {errorMessage(err)}
3567                  </Text>,
3568              priority: 'low'
3569            });
3570          });
3571        }
3572      } else {
3573        injectUserMessageToTeammate(task.id, input, setAppState);
3574      }
3575      setInputValue('');
3576      helpers.setCursorOffset(0);
3577      helpers.clearBuffer();
3578    }, [setAppState, setInputValue, getToolUseContext, canUseTool, mainLoopModel, addNotification]);
3579  
3580    // Handlers for auto-run /issue or /good-claude (defined after onSubmit)
3581    const handleAutoRunIssue = useCallback(() => {
3582      const command = autoRunIssueReason ? getAutoRunCommand(autoRunIssueReason) : '/issue';
3583      setAutoRunIssueReason(null); // Clear the state
3584      onSubmit(command, {
3585        setCursorOffset: () => {},
3586        clearBuffer: () => {},
3587        resetHistory: () => {}
3588      }).catch(err => {
3589        logForDebugging(`Auto-run ${command} failed: ${errorMessage(err)}`);
3590      });
3591    }, [onSubmit, autoRunIssueReason]);
3592    const handleCancelAutoRunIssue = useCallback(() => {
3593      setAutoRunIssueReason(null);
3594    }, []);
3595  
3596    // Handler for when user presses 1 on survey thanks screen to share details
3597    const handleSurveyRequestFeedback = useCallback(() => {
3598      const command = "external" === 'ant' ? '/issue' : '/feedback';
3599      onSubmit(command, {
3600        setCursorOffset: () => {},
3601        clearBuffer: () => {},
3602        resetHistory: () => {}
3603      }).catch(err => {
3604        logForDebugging(`Survey feedback request failed: ${err instanceof Error ? err.message : String(err)}`);
3605      });
3606    }, [onSubmit]);
3607  
3608    // onSubmit is unstable (deps include `messages` which changes every turn).
3609    // `handleOpenRateLimitOptions` is prop-drilled to every MessageRow, and each
3610    // MessageRow fiber pins the closure (and transitively the entire REPL render
3611    // scope, ~1.8KB) at mount time. Using a ref keeps this callback stable so
3612    // old REPL scopes can be GC'd — saves ~35MB over a 1000-turn session.
3613    const onSubmitRef = useRef(onSubmit);
3614    onSubmitRef.current = onSubmit;
3615    const handleOpenRateLimitOptions = useCallback(() => {
3616      void onSubmitRef.current('/rate-limit-options', {
3617        setCursorOffset: () => {},
3618        clearBuffer: () => {},
3619        resetHistory: () => {}
3620      });
3621    }, []);
3622    const handleExit = useCallback(async () => {
3623      setIsExiting(true);
3624      // In bg sessions, always detach instead of kill — even when a worktree is
3625      // active. Without this guard, the worktree branch below short-circuits into
3626      // ExitFlow (which calls gracefulShutdown) before exit.tsx is ever loaded.
3627      if (feature('BG_SESSIONS') && isBgSession()) {
3628        spawnSync('tmux', ['detach-client'], {
3629          stdio: 'ignore'
3630        });
3631        setIsExiting(false);
3632        return;
3633      }
3634      const showWorktree = getCurrentWorktreeSession() !== null;
3635      if (showWorktree) {
3636        setExitFlow(<ExitFlow showWorktree onDone={() => {}} onCancel={() => {
3637          setExitFlow(null);
3638          setIsExiting(false);
3639        }} />);
3640        return;
3641      }
3642      const exitMod = await exit.load();
3643      const exitFlowResult = await exitMod.call(() => {});
3644      setExitFlow(exitFlowResult);
3645      // If call() returned without killing the process (bg session detach),
3646      // clear isExiting so the UI is usable on reattach. No-op on the normal
3647      // path — gracefulShutdown's process.exit() means we never get here.
3648      if (exitFlowResult === null) {
3649        setIsExiting(false);
3650      }
3651    }, []);
3652    const handleShowMessageSelector = useCallback(() => {
3653      setIsMessageSelectorVisible(prev => !prev);
3654    }, []);
3655  
3656    // Rewind conversation state to just before `message`: slice messages,
3657    // reset conversation ID, microcompact state, permission mode, prompt suggestion.
3658    // Does NOT touch the prompt input. Index is computed from messagesRef (always
3659    // fresh via the setMessages wrapper) so callers don't need to worry about
3660    // stale closures.
3661    const rewindConversationTo = useCallback((message: UserMessage) => {
3662      const prev = messagesRef.current;
3663      const messageIndex = prev.lastIndexOf(message);
3664      if (messageIndex === -1) return;
3665      logEvent('tengu_conversation_rewind', {
3666        preRewindMessageCount: prev.length,
3667        postRewindMessageCount: messageIndex,
3668        messagesRemoved: prev.length - messageIndex,
3669        rewindToMessageIndex: messageIndex
3670      });
3671      setMessages(prev.slice(0, messageIndex));
3672      // Careful, this has to happen after setMessages
3673      setConversationId(randomUUID());
3674      // Reset cached microcompact state so stale pinned cache edits
3675      // don't reference tool_use_ids from truncated messages
3676      resetMicrocompactState();
3677      if (feature('CONTEXT_COLLAPSE')) {
3678        // Rewind truncates the REPL array. Commits whose archived span
3679        // was past the rewind point can't be projected anymore
3680        // (projectView silently skips them) but the staged queue and ID
3681        // maps reference stale uuids. Simplest safe reset: drop
3682        // everything. The ctx-agent will re-stage on the next
3683        // threshold crossing.
3684        /* eslint-disable @typescript-eslint/no-require-imports */
3685        ;
3686        (require('../services/contextCollapse/index.js') as typeof import('../services/contextCollapse/index.js')).resetContextCollapse();
3687        /* eslint-enable @typescript-eslint/no-require-imports */
3688      }
3689  
3690      // Restore state from the message we're rewinding to
3691      setAppState(prev => ({
3692        ...prev,
3693        // Restore permission mode from the message
3694        toolPermissionContext: message.permissionMode && prev.toolPermissionContext.mode !== message.permissionMode ? {
3695          ...prev.toolPermissionContext,
3696          mode: message.permissionMode
3697        } : prev.toolPermissionContext,
3698        // Clear stale prompt suggestion from previous conversation state
3699        promptSuggestion: {
3700          text: null,
3701          promptId: null,
3702          shownAt: 0,
3703          acceptedAt: 0,
3704          generationRequestId: null
3705        }
3706      }));
3707    }, [setMessages, setAppState]);
3708  
3709    // Synchronous rewind + input population. Used directly by auto-restore on
3710    // interrupt (so React batches with the abort's setMessages → single render,
3711    // no flicker). MessageSelector wraps this in setImmediate via handleRestoreMessage.
3712    const restoreMessageSync = useCallback((message: UserMessage) => {
3713      rewindConversationTo(message);
3714      const r = textForResubmit(message);
3715      if (r) {
3716        setInputValue(r.text);
3717        setInputMode(r.mode);
3718      }
3719  
3720      // Restore pasted images
3721      if (Array.isArray(message.message.content) && message.message.content.some(block => block.type === 'image')) {
3722        const imageBlocks: Array<ImageBlockParam> = message.message.content.filter(block => block.type === 'image');
3723        if (imageBlocks.length > 0) {
3724          const newPastedContents: Record<number, PastedContent> = {};
3725          imageBlocks.forEach((block, index) => {
3726            if (block.source.type === 'base64') {
3727              const id = message.imagePasteIds?.[index] ?? index + 1;
3728              newPastedContents[id] = {
3729                id,
3730                type: 'image',
3731                content: block.source.data,
3732                mediaType: block.source.media_type
3733              };
3734            }
3735          });
3736          setPastedContents(newPastedContents);
3737        }
3738      }
3739    }, [rewindConversationTo, setInputValue]);
3740    restoreMessageSyncRef.current = restoreMessageSync;
3741  
3742    // MessageSelector path: defer via setImmediate so the "Interrupted" message
3743    // renders to static output before rewind — otherwise it remains vestigial
3744    // at the top of the screen.
3745    const handleRestoreMessage = useCallback(async (message: UserMessage) => {
3746      setImmediate((restore, message) => restore(message), restoreMessageSync, message);
3747    }, [restoreMessageSync]);
3748  
3749    // Not memoized — hook stores caps via ref, reads latest closure at dispatch.
3750    // 24-char prefix: deriveUUID preserves first 24, renderable uuid prefix-matches raw source.
3751    const findRawIndex = (uuid: string) => {
3752      const prefix = uuid.slice(0, 24);
3753      return messages.findIndex(m => m.uuid.slice(0, 24) === prefix);
3754    };
3755    const messageActionCaps: MessageActionCaps = {
3756      copy: text =>
3757      // setClipboard RETURNS OSC 52 — caller must stdout.write (tmux side-effects load-buffer, but that's tmux-only).
3758      void setClipboard(text).then(raw => {
3759        if (raw) process.stdout.write(raw);
3760        addNotification({
3761          // Same key as text-selection copy — repeated copies replace toast, don't queue.
3762          key: 'selection-copied',
3763          text: 'copied',
3764          color: 'success',
3765          priority: 'immediate',
3766          timeoutMs: 2000
3767        });
3768      }),
3769      edit: async msg => {
3770        // Same skip-confirm check as /rewind: lossless → direct, else confirm dialog.
3771        const rawIdx = findRawIndex(msg.uuid);
3772        const raw = rawIdx >= 0 ? messages[rawIdx] : undefined;
3773        if (!raw || !selectableUserMessagesFilter(raw)) return;
3774        const noFileChanges = !(await fileHistoryHasAnyChanges(fileHistory, raw.uuid));
3775        const onlySynthetic = messagesAfterAreOnlySynthetic(messages, rawIdx);
3776        if (noFileChanges && onlySynthetic) {
3777          // rewindConversationTo's setMessages races stream appends — cancel first (idempotent).
3778          onCancel();
3779          // handleRestoreMessage also restores pasted images.
3780          void handleRestoreMessage(raw);
3781        } else {
3782          // Dialog path: onPreRestore (= onCancel) fires when user CONFIRMS, not on nevermind.
3783          setMessageSelectorPreselect(raw);
3784          setIsMessageSelectorVisible(true);
3785        }
3786      }
3787    };
3788    const {
3789      enter: enterMessageActions,
3790      handlers: messageActionHandlers
3791    } = useMessageActions(cursor, setCursor, cursorNavRef, messageActionCaps);
3792    async function onInit() {
3793      // Always verify API key on startup, so we can show the user an error in the
3794      // bottom right corner of the screen if the API key is invalid.
3795      void reverify();
3796  
3797      // Populate readFileState with CLAUDE.md files at startup
3798      const memoryFiles = await getMemoryFiles();
3799      if (memoryFiles.length > 0) {
3800        const fileList = memoryFiles.map(f => `  [${f.type}] ${f.path} (${f.content.length} chars)${f.parent ? ` (included by ${f.parent})` : ''}`).join('\n');
3801        logForDebugging(`Loaded ${memoryFiles.length} CLAUDE.md/rules files:\n${fileList}`);
3802      } else {
3803        logForDebugging('No CLAUDE.md/rules files found');
3804      }
3805      for (const file of memoryFiles) {
3806        // When the injected content doesn't match disk (stripped HTML comments,
3807        // stripped frontmatter, MEMORY.md truncation), cache the RAW disk bytes
3808        // with isPartialView so Edit/Write require a real Read first while
3809        // getChangedFiles + nested_memory dedup still work.
3810        readFileState.current.set(file.path, {
3811          content: file.contentDiffersFromDisk ? file.rawContent ?? file.content : file.content,
3812          timestamp: Date.now(),
3813          offset: undefined,
3814          limit: undefined,
3815          isPartialView: file.contentDiffersFromDisk
3816        });
3817      }
3818  
3819      // Initial message handling is done via the initialMessage effect
3820    }
3821  
3822    // Register cost summary tracker
3823    useCostSummary(useFpsMetrics());
3824  
3825    // Record transcripts locally, for debugging and conversation recovery
3826    // Don't record conversation if we only have initial messages; optimizes
3827    // the case where user resumes a conversation then quites before doing
3828    // anything else
3829    useLogMessages(messages, messages.length === initialMessages?.length);
3830  
3831    // REPL Bridge: replicate user/assistant messages to the bridge session
3832    // for remote access via claude.ai. No-op in external builds or when not enabled.
3833    const {
3834      sendBridgeResult
3835    } = useReplBridge(messages, setMessages, abortControllerRef, commands, mainLoopModel);
3836    sendBridgeResultRef.current = sendBridgeResult;
3837    useAfterFirstRender();
3838  
3839    // Track prompt queue usage for analytics. Fire once per transition from
3840    // empty to non-empty, not on every length change -- otherwise a render loop
3841    // (concurrent onQuery thrashing, etc.) spams saveGlobalConfig, which hits
3842    // ELOCKED under concurrent sessions and falls back to unlocked writes.
3843    // That write storm is the primary trigger for ~/.claude.json corruption
3844    // (GH #3117).
3845    const hasCountedQueueUseRef = useRef(false);
3846    useEffect(() => {
3847      if (queuedCommands.length < 1) {
3848        hasCountedQueueUseRef.current = false;
3849        return;
3850      }
3851      if (hasCountedQueueUseRef.current) return;
3852      hasCountedQueueUseRef.current = true;
3853      saveGlobalConfig(current => ({
3854        ...current,
3855        promptQueueUseCount: (current.promptQueueUseCount ?? 0) + 1
3856      }));
3857    }, [queuedCommands.length]);
3858  
3859    // Process queued commands when query completes and queue has items
3860  
3861    const executeQueuedInput = useCallback(async (queuedCommands: QueuedCommand[]) => {
3862      await handlePromptSubmit({
3863        helpers: {
3864          setCursorOffset: () => {},
3865          clearBuffer: () => {},
3866          resetHistory: () => {}
3867        },
3868        queryGuard,
3869        commands,
3870        onInputChange: () => {},
3871        setPastedContents: () => {},
3872        setToolJSX,
3873        getToolUseContext,
3874        messages,
3875        mainLoopModel,
3876        ideSelection,
3877        setUserInputOnProcessing,
3878        setAbortController,
3879        onQuery,
3880        setAppState,
3881        querySource: getQuerySourceForREPL(),
3882        onBeforeQuery,
3883        canUseTool,
3884        addNotification,
3885        setMessages,
3886        queuedCommands
3887      });
3888    }, [queryGuard, commands, setToolJSX, getToolUseContext, messages, mainLoopModel, ideSelection, setUserInputOnProcessing, canUseTool, setAbortController, onQuery, addNotification, setAppState, onBeforeQuery]);
3889    useQueueProcessor({
3890      executeQueuedInput,
3891      hasActiveLocalJsxUI: isShowingLocalJSXCommand,
3892      queryGuard
3893    });
3894  
3895    // We'll use the global lastInteractionTime from state.ts
3896  
3897    // Update last interaction time when input changes.
3898    // Must be immediate because useEffect runs after the Ink render cycle flush.
3899    useEffect(() => {
3900      activityManager.recordUserActivity();
3901      updateLastInteractionTime(true);
3902    }, [inputValue, submitCount]);
3903    useEffect(() => {
3904      if (submitCount === 1) {
3905        startBackgroundHousekeeping();
3906      }
3907    }, [submitCount]);
3908  
3909    // Show notification when Claude is done responding and user is idle
3910    useEffect(() => {
3911      // Don't set up notification if Claude is busy
3912      if (isLoading) return;
3913  
3914      // Only enable notifications after the first new interaction in this session
3915      if (submitCount === 0) return;
3916  
3917      // No query has completed yet
3918      if (lastQueryCompletionTime === 0) return;
3919  
3920      // Set timeout to check idle state
3921      const timer = setTimeout((lastQueryCompletionTime, isLoading, toolJSX, focusedInputDialogRef, terminal) => {
3922        // Check if user has interacted since the response ended
3923        const lastUserInteraction = getLastInteractionTime();
3924        if (lastUserInteraction > lastQueryCompletionTime) {
3925          // User has interacted since Claude finished - they're not idle, don't notify
3926          return;
3927        }
3928  
3929        // User hasn't interacted since response ended, check other conditions
3930        const idleTimeSinceResponse = Date.now() - lastQueryCompletionTime;
3931        if (!isLoading && !toolJSX &&
3932        // Use ref to get current dialog state, avoiding stale closure
3933        focusedInputDialogRef.current === undefined && idleTimeSinceResponse >= getGlobalConfig().messageIdleNotifThresholdMs) {
3934          void sendNotification({
3935            message: 'Claude is waiting for your input',
3936            notificationType: 'idle_prompt'
3937          }, terminal);
3938        }
3939      }, getGlobalConfig().messageIdleNotifThresholdMs, lastQueryCompletionTime, isLoading, toolJSX, focusedInputDialogRef, terminal);
3940      return () => clearTimeout(timer);
3941    }, [isLoading, toolJSX, submitCount, lastQueryCompletionTime, terminal]);
3942  
3943    // Idle-return hint: show notification when idle threshold is exceeded.
3944    // Timer fires after the configured idle period; notification persists until
3945    // dismissed or the user submits.
3946    useEffect(() => {
3947      if (lastQueryCompletionTime === 0) return;
3948      if (isLoading) return;
3949      const willowMode: string = getFeatureValue_CACHED_MAY_BE_STALE('tengu_willow_mode', 'off');
3950      if (willowMode !== 'hint' && willowMode !== 'hint_v2') return;
3951      if (getGlobalConfig().idleReturnDismissed) return;
3952      const tokenThreshold = Number(process.env.CLAUDE_CODE_IDLE_TOKEN_THRESHOLD ?? 100_000);
3953      if (getTotalInputTokens() < tokenThreshold) return;
3954      const idleThresholdMs = Number(process.env.CLAUDE_CODE_IDLE_THRESHOLD_MINUTES ?? 75) * 60_000;
3955      const elapsed = Date.now() - lastQueryCompletionTime;
3956      const remaining = idleThresholdMs - elapsed;
3957      const timer = setTimeout((lqct, addNotif, msgsRef, mode, hintRef) => {
3958        if (msgsRef.current.length === 0) return;
3959        const totalTokens = getTotalInputTokens();
3960        const formattedTokens = formatTokens(totalTokens);
3961        const idleMinutes = (Date.now() - lqct) / 60_000;
3962        addNotif({
3963          key: 'idle-return-hint',
3964          jsx: mode === 'hint_v2' ? <>
3965                  <Text dimColor>new task? </Text>
3966                  <Text color="suggestion">/clear</Text>
3967                  <Text dimColor> to save </Text>
3968                  <Text color="suggestion">{formattedTokens} tokens</Text>
3969                </> : <Text color="warning">
3970                  new task? /clear to save {formattedTokens} tokens
3971                </Text>,
3972          priority: 'medium',
3973          // Persist until submit — the hint fires at T+75min idle, user may
3974          // not return for hours. removeNotification in useEffect cleanup
3975          // handles dismissal. 0x7FFFFFFF = setTimeout max (~24.8 days).
3976          timeoutMs: 0x7fffffff
3977        });
3978        hintRef.current = mode;
3979        logEvent('tengu_idle_return_action', {
3980          action: 'hint_shown' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3981          variant: mode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
3982          idleMinutes: Math.round(idleMinutes),
3983          messageCount: msgsRef.current.length,
3984          totalInputTokens: totalTokens
3985        });
3986      }, Math.max(0, remaining), lastQueryCompletionTime, addNotification, messagesRef, willowMode, idleHintShownRef);
3987      return () => {
3988        clearTimeout(timer);
3989        removeNotification('idle-return-hint');
3990        idleHintShownRef.current = false;
3991      };
3992    }, [lastQueryCompletionTime, isLoading, addNotification, removeNotification]);
3993  
3994    // Submits incoming prompts from teammate messages or tasks mode as new turns
3995    // Returns true if submission succeeded, false if a query is already running
3996    const handleIncomingPrompt = useCallback((content: string, options?: {
3997      isMeta?: boolean;
3998    }): boolean => {
3999      if (queryGuard.isActive) return false;
4000  
4001      // Defer to user-queued commands — user input always takes priority
4002      // over system messages (teammate messages, task list items, etc.)
4003      // Read from the module-level store at call time (not the render-time
4004      // snapshot) to avoid a stale closure — this callback's deps don't
4005      // include the queue.
4006      if (getCommandQueue().some(cmd => cmd.mode === 'prompt' || cmd.mode === 'bash')) {
4007        return false;
4008      }
4009      const newAbortController = createAbortController();
4010      setAbortController(newAbortController);
4011  
4012      // Create a user message with the formatted content (includes XML wrapper)
4013      const userMessage = createUserMessage({
4014        content,
4015        isMeta: options?.isMeta ? true : undefined
4016      });
4017      void onQuery([userMessage], newAbortController, true, [], mainLoopModel);
4018      return true;
4019    }, [onQuery, mainLoopModel, store]);
4020  
4021    // Voice input integration (VOICE_MODE builds only)
4022    const voice = feature('VOICE_MODE') ?
4023    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
4024    useVoiceIntegration({
4025      setInputValueRaw,
4026      inputValueRef,
4027      insertTextRef
4028    }) : {
4029      stripTrailing: () => 0,
4030      handleKeyEvent: () => {},
4031      resetAnchor: () => {},
4032      interimRange: null
4033    };
4034    useInboxPoller({
4035      enabled: isAgentSwarmsEnabled(),
4036      isLoading,
4037      focusedInputDialog,
4038      onSubmitMessage: handleIncomingPrompt
4039    });
4040    useMailboxBridge({
4041      isLoading,
4042      onSubmitMessage: handleIncomingPrompt
4043    });
4044  
4045    // Scheduled tasks from .claude/scheduled_tasks.json (CronCreate/Delete/List)
4046    if (feature('AGENT_TRIGGERS')) {
4047      // Assistant mode bypasses the isLoading gate (the proactive tick →
4048      // Sleep → tick loop would otherwise starve the scheduler).
4049      // kairosEnabled is set once in initialState (main.tsx) and never mutated — no
4050      // subscription needed. The tengu_kairos_cron runtime gate is checked inside
4051      // useScheduledTasks's effect (not here) since wrapping a hook call in a dynamic
4052      // condition would break rules-of-hooks.
4053      const assistantMode = store.getState().kairosEnabled;
4054      // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
4055      useScheduledTasks!({
4056        isLoading,
4057        assistantMode,
4058        setMessages
4059      });
4060    }
4061  
4062    // Note: Permission polling is now handled by useInboxPoller
4063    // - Workers receive permission responses via mailbox messages
4064    // - Leaders receive permission requests via mailbox messages
4065  
4066    if ("external" === 'ant') {
4067      // Tasks mode: watch for tasks and auto-process them
4068      // eslint-disable-next-line react-hooks/rules-of-hooks
4069      // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds
4070      useTaskListWatcher({
4071        taskListId,
4072        isLoading,
4073        onSubmitTask: handleIncomingPrompt
4074      });
4075  
4076      // Loop mode: auto-tick when enabled (via /job command)
4077      // eslint-disable-next-line react-hooks/rules-of-hooks
4078      // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds
4079      useProactive?.({
4080        // Suppress ticks while an initial message is pending — the initial
4081        // message will be processed asynchronously and a premature tick would
4082        // race with it, causing concurrent-query enqueue of expanded skill text.
4083        isLoading: isLoading || initialMessage !== null,
4084        queuedCommandsLength: queuedCommands.length,
4085        hasActiveLocalJsxUI: isShowingLocalJSXCommand,
4086        isInPlanMode: toolPermissionContext.mode === 'plan',
4087        onSubmitTick: (prompt: string) => handleIncomingPrompt(prompt, {
4088          isMeta: true
4089        }),
4090        onQueueTick: (prompt: string) => enqueue({
4091          mode: 'prompt',
4092          value: prompt,
4093          isMeta: true
4094        })
4095      });
4096    }
4097  
4098    // Abort the current operation when a 'now' priority message arrives
4099    // (e.g. from a chat UI client via UDS).
4100    useEffect(() => {
4101      if (queuedCommands.some(cmd => cmd.priority === 'now')) {
4102        abortControllerRef.current?.abort('interrupt');
4103      }
4104    }, [queuedCommands]);
4105  
4106    // Initial load
4107    useEffect(() => {
4108      void onInit();
4109  
4110      // Cleanup on unmount
4111      return () => {
4112        void diagnosticTracker.shutdown();
4113      };
4114      // TODO: fix this
4115      // eslint-disable-next-line react-hooks/exhaustive-deps
4116    }, []);
4117  
4118    // Listen for suspend/resume events
4119    const {
4120      internal_eventEmitter
4121    } = useStdin();
4122    const [remountKey, setRemountKey] = useState(0);
4123    useEffect(() => {
4124      const handleSuspend = () => {
4125        // Print suspension instructions
4126        process.stdout.write(`\nClaude Code has been suspended. Run \`fg\` to bring Claude Code back.\nNote: ctrl + z now suspends Claude Code, ctrl + _ undoes input.\n`);
4127      };
4128      const handleResume = () => {
4129        // Force complete component tree replacement instead of terminal clear
4130        // Ink now handles line count reset internally on SIGCONT
4131        setRemountKey(prev => prev + 1);
4132      };
4133      internal_eventEmitter?.on('suspend', handleSuspend);
4134      internal_eventEmitter?.on('resume', handleResume);
4135      return () => {
4136        internal_eventEmitter?.off('suspend', handleSuspend);
4137        internal_eventEmitter?.off('resume', handleResume);
4138      };
4139    }, [internal_eventEmitter]);
4140  
4141    // Derive stop hook spinner suffix from messages state
4142    const stopHookSpinnerSuffix = useMemo(() => {
4143      if (!isLoading) return null;
4144  
4145      // Find stop hook progress messages
4146      const progressMsgs = messages.filter((m): m is ProgressMessage<HookProgress> => m.type === 'progress' && m.data.type === 'hook_progress' && (m.data.hookEvent === 'Stop' || m.data.hookEvent === 'SubagentStop'));
4147      if (progressMsgs.length === 0) return null;
4148  
4149      // Get the most recent stop hook execution
4150      const currentToolUseID = progressMsgs.at(-1)?.toolUseID;
4151      if (!currentToolUseID) return null;
4152  
4153      // Check if there's already a summary message for this execution (hooks completed)
4154      const hasSummaryForCurrentExecution = messages.some(m => m.type === 'system' && m.subtype === 'stop_hook_summary' && m.toolUseID === currentToolUseID);
4155      if (hasSummaryForCurrentExecution) return null;
4156      const currentHooks = progressMsgs.filter(p => p.toolUseID === currentToolUseID);
4157      const total = currentHooks.length;
4158  
4159      // Count completed hooks
4160      const completedCount = count(messages, m => {
4161        if (m.type !== 'attachment') return false;
4162        const attachment = m.attachment;
4163        return 'hookEvent' in attachment && (attachment.hookEvent === 'Stop' || attachment.hookEvent === 'SubagentStop') && 'toolUseID' in attachment && attachment.toolUseID === currentToolUseID;
4164      });
4165  
4166      // Check if any hook has a custom status message
4167      const customMessage = currentHooks.find(p => p.data.statusMessage)?.data.statusMessage;
4168      if (customMessage) {
4169        // Use custom message with progress counter if multiple hooks
4170        return total === 1 ? `${customMessage}…` : `${customMessage}… ${completedCount}/${total}`;
4171      }
4172  
4173      // Fall back to default behavior
4174      const hookType = currentHooks[0]?.data.hookEvent === 'SubagentStop' ? 'subagent stop' : 'stop';
4175      if ("external" === 'ant') {
4176        const cmd = currentHooks[completedCount]?.data.command;
4177        const label = cmd ? ` '${truncateToWidth(cmd, 40)}'` : '';
4178        return total === 1 ? `running ${hookType} hook${label}` : `running ${hookType} hook${label}\u2026 ${completedCount}/${total}`;
4179      }
4180      return total === 1 ? `running ${hookType} hook` : `running stop hooks… ${completedCount}/${total}`;
4181    }, [messages, isLoading]);
4182  
4183    // Callback to capture frozen state when entering transcript mode
4184    const handleEnterTranscript = useCallback(() => {
4185      setFrozenTranscriptState({
4186        messagesLength: messages.length,
4187        streamingToolUsesLength: streamingToolUses.length
4188      });
4189    }, [messages.length, streamingToolUses.length]);
4190  
4191    // Callback to clear frozen state when exiting transcript mode
4192    const handleExitTranscript = useCallback(() => {
4193      setFrozenTranscriptState(null);
4194    }, []);
4195  
4196    // Props for GlobalKeybindingHandlers component (rendered inside KeybindingSetup)
4197    const virtualScrollActive = isFullscreenEnvEnabled() && !disableVirtualScroll;
4198  
4199    // Transcript search state. Hooks must be unconditional so they live here
4200    // (not inside the `if (screen === 'transcript')` branch below); isActive
4201    // gates the useInput. Query persists across bar open/close so n/N keep
4202    // working after Enter dismisses the bar (less semantics).
4203    const jumpRef = useRef<JumpHandle | null>(null);
4204    const [searchOpen, setSearchOpen] = useState(false);
4205    const [searchQuery, setSearchQuery] = useState('');
4206    const [searchCount, setSearchCount] = useState(0);
4207    const [searchCurrent, setSearchCurrent] = useState(0);
4208    const onSearchMatchesChange = useCallback((count: number, current: number) => {
4209      setSearchCount(count);
4210      setSearchCurrent(current);
4211    }, []);
4212    useInput((input, key, event) => {
4213      if (key.ctrl || key.meta) return;
4214      // No Esc handling here — less has no navigating mode. Search state
4215      // (highlights, n/N) is just state. Esc/q/ctrl+c → transcript:exit
4216      // (ungated). Highlights clear on exit via the screen-change effect.
4217      if (input === '/') {
4218        // Capture scrollTop NOW — typing is a preview, 0-matches snaps
4219        // back here. Synchronous ref write, fires before the bar's
4220        // mount-effect calls setSearchQuery.
4221        jumpRef.current?.setAnchor();
4222        setSearchOpen(true);
4223        event.stopImmediatePropagation();
4224        return;
4225      }
4226      // Held-key batching: tokenizer coalesces to 'nnn'. Same uniform-batch
4227      // pattern as modalPagerAction in ScrollKeybindingHandler.tsx. Each
4228      // repeat is a step (n isn't idempotent like g).
4229      const c = input[0];
4230      if ((c === 'n' || c === 'N') && input === c.repeat(input.length) && searchCount > 0) {
4231        const fn = c === 'n' ? jumpRef.current?.nextMatch : jumpRef.current?.prevMatch;
4232        if (fn) for (let i = 0; i < input.length; i++) fn();
4233        event.stopImmediatePropagation();
4234      }
4235    },
4236    // Search needs virtual scroll (jumpRef drives VirtualMessageList). [
4237    // kills it, so !dumpMode — after [ there's nothing to jump in.
4238    {
4239      isActive: screen === 'transcript' && virtualScrollActive && !searchOpen && !dumpMode
4240    });
4241    const {
4242      setQuery: setHighlight,
4243      scanElement,
4244      setPositions
4245    } = useSearchHighlight();
4246  
4247    // Resize → abort search. Positions are (msg, query, WIDTH)-keyed —
4248    // cached positions are stale after a width change (new layout, new
4249    // wrapping). Clearing searchQuery triggers VML's setSearchQuery('')
4250    // which clears positionsCache + setPositions(null). Bar closes.
4251    // User hits / again → fresh everything.
4252    const transcriptCols = useTerminalSize().columns;
4253    const prevColsRef = React.useRef(transcriptCols);
4254    React.useEffect(() => {
4255      if (prevColsRef.current !== transcriptCols) {
4256        prevColsRef.current = transcriptCols;
4257        if (searchQuery || searchOpen) {
4258          setSearchOpen(false);
4259          setSearchQuery('');
4260          setSearchCount(0);
4261          setSearchCurrent(0);
4262          jumpRef.current?.disarmSearch();
4263          setHighlight('');
4264        }
4265      }
4266    }, [transcriptCols, searchQuery, searchOpen, setHighlight]);
4267  
4268    // Transcript escape hatches. Bare letters in modal context (no prompt
4269    // competing for input) — same class as g/G/j/k in ScrollKeybindingHandler.
4270    useInput((input, key, event) => {
4271      if (key.ctrl || key.meta) return;
4272      if (input === 'q') {
4273        // less: q quits the pager. ctrl+o toggles; q is the lineage exit.
4274        handleExitTranscript();
4275        event.stopImmediatePropagation();
4276        return;
4277      }
4278      if (input === '[' && !dumpMode) {
4279        // Force dump-to-scrollback. Also expand + uncap — no point dumping
4280        // a subset. Terminal/tmux cmd-F can now find anything. Guard here
4281        // (not in isActive) so v still works post-[ — dump-mode footer at
4282        // ~4898 wires editorStatus, confirming v is meant to stay live.
4283        setDumpMode(true);
4284        setShowAllInTranscript(true);
4285        event.stopImmediatePropagation();
4286      } else if (input === 'v') {
4287        // less-style: v opens the file in $VISUAL/$EDITOR. Render the full
4288        // transcript (same path /export uses), write to tmp, hand off.
4289        // openFileInExternalEditor handles alt-screen suspend/resume for
4290        // terminal editors; GUI editors spawn detached.
4291        event.stopImmediatePropagation();
4292        // Drop double-taps: the render is async and a second press before it
4293        // completes would run a second parallel render (double memory, two
4294        // tempfiles, two editor spawns). editorGenRef only guards
4295        // transcript-exit staleness, not same-session concurrency.
4296        if (editorRenderingRef.current) return;
4297        editorRenderingRef.current = true;
4298        // Capture generation + make a staleness-aware setter. Each write
4299        // checks gen (transcript exit bumps it → late writes from the
4300        // async render go silent).
4301        const gen = editorGenRef.current;
4302        const setStatus = (s: string): void => {
4303          if (gen !== editorGenRef.current) return;
4304          clearTimeout(editorTimerRef.current);
4305          setEditorStatus(s);
4306        };
4307        setStatus(`rendering ${deferredMessages.length} messages…`);
4308        void (async () => {
4309          try {
4310            // Width = terminal minus vim's line-number gutter (4 digits +
4311            // space + slack). Floor at 80. PassThrough has no .columns so
4312            // without this Ink defaults to 80. Trailing-space strip: right-
4313            // aligned timestamps still leave a flexbox spacer run at EOL.
4314            // eslint-disable-next-line custom-rules/prefer-use-terminal-size -- one-shot at keypress time, not a reactive render dep
4315            const w = Math.max(80, (process.stdout.columns ?? 80) - 6);
4316            const raw = await renderMessagesToPlainText(deferredMessages, tools, w);
4317            const text = raw.replace(/[ \t]+$/gm, '');
4318            const path = join(tmpdir(), `cc-transcript-${Date.now()}.txt`);
4319            await writeFile(path, text);
4320            const opened = openFileInExternalEditor(path);
4321            setStatus(opened ? `opening ${path}` : `wrote ${path} · no $VISUAL/$EDITOR set`);
4322          } catch (e) {
4323            setStatus(`render failed: ${e instanceof Error ? e.message : String(e)}`);
4324          }
4325          editorRenderingRef.current = false;
4326          if (gen !== editorGenRef.current) return;
4327          editorTimerRef.current = setTimeout(s => s(''), 4000, setEditorStatus);
4328        })();
4329      }
4330    },
4331    // !searchOpen: typing 'v' or '[' in the search bar is search input, not
4332    // a command. No !dumpMode here — v should work after [ (the [ handler
4333    // guards itself inline).
4334    {
4335      isActive: screen === 'transcript' && virtualScrollActive && !searchOpen
4336    });
4337  
4338    // Fresh `less` per transcript entry. Prevents stale highlights matching
4339    // unrelated normal-mode text (overlay is alt-screen-global) and avoids
4340    // surprise n/N on re-entry. Same exit resets [ dump mode — each ctrl+o
4341    // entry is a fresh instance.
4342    const inTranscript = screen === 'transcript' && virtualScrollActive;
4343    useEffect(() => {
4344      if (!inTranscript) {
4345        setSearchQuery('');
4346        setSearchCount(0);
4347        setSearchCurrent(0);
4348        setSearchOpen(false);
4349        editorGenRef.current++;
4350        clearTimeout(editorTimerRef.current);
4351        setDumpMode(false);
4352        setEditorStatus('');
4353      }
4354    }, [inTranscript]);
4355    useEffect(() => {
4356      setHighlight(inTranscript ? searchQuery : '');
4357      // Clear the position-based CURRENT (yellow) overlay too. setHighlight
4358      // only clears the scan-based inverse. Without this, the yellow box
4359      // persists at its last screen coords after ctrl-c exits transcript.
4360      if (!inTranscript) setPositions(null);
4361    }, [inTranscript, searchQuery, setHighlight, setPositions]);
4362    const globalKeybindingProps = {
4363      screen,
4364      setScreen,
4365      showAllInTranscript,
4366      setShowAllInTranscript,
4367      messageCount: messages.length,
4368      onEnterTranscript: handleEnterTranscript,
4369      onExitTranscript: handleExitTranscript,
4370      virtualScrollActive,
4371      // Bar-open is a mode (owns keystrokes — j/k type, Esc cancels).
4372      // Navigating (query set, bar closed) is NOT — Esc exits transcript,
4373      // same as less q with highlights still visible. useSearchInput
4374      // doesn't stopPropagation, so without this gate transcript:exit
4375      // would fire on the same Esc that cancels the bar (child registers
4376      // first, fires first, bubbles).
4377      searchBarOpen: searchOpen
4378    };
4379  
4380    // Use frozen lengths to slice arrays, avoiding memory overhead of cloning
4381    const transcriptMessages = frozenTranscriptState ? deferredMessages.slice(0, frozenTranscriptState.messagesLength) : deferredMessages;
4382    const transcriptStreamingToolUses = frozenTranscriptState ? streamingToolUses.slice(0, frozenTranscriptState.streamingToolUsesLength) : streamingToolUses;
4383  
4384    // Handle shift+down for teammate navigation and background task management.
4385    // Guard onOpenBackgroundTasks when a local-jsx dialog (e.g. /mcp) is open —
4386    // otherwise Shift+Down stacks BackgroundTasksDialog on top and deadlocks input.
4387    useBackgroundTaskNavigation({
4388      onOpenBackgroundTasks: isShowingLocalJSXCommand ? undefined : () => setShowBashesDialog(true)
4389    });
4390    // Auto-exit viewing mode when teammate completes or errors
4391    useTeammateViewAutoExit();
4392    if (screen === 'transcript') {
4393      // Virtual scroll replaces the 30-message cap: everything is scrollable
4394      // and memory is bounded by the viewport. Without it, wrapping transcript
4395      // in a ScrollBox would mount all messages (~250 MB on long sessions —
4396      // the exact problem), so the kill switch and non-fullscreen paths must
4397      // fall through to the legacy render: no alt screen, dump to terminal
4398      // scrollback, 30-cap + Ctrl+E. Reusing scrollRef is safe — normal-mode
4399      // and transcript-mode are mutually exclusive (this early return), so
4400      // only one ScrollBox is ever mounted at a time.
4401      const transcriptScrollRef = isFullscreenEnvEnabled() && !disableVirtualScroll && !dumpMode ? scrollRef : undefined;
4402      const transcriptMessagesElement = <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} />;
4403      const transcriptToolJSX = toolJSX && <Box flexDirection="column" width="100%">
4404          {toolJSX.jsx}
4405        </Box>;
4406      const transcriptReturn = <KeybindingSetup>
4407          <AnimatedTerminalTitle isAnimating={titleIsAnimating} title={terminalTitle} disabled={titleDisabled} noPrefix={showStatusInTerminalTab} />
4408          <GlobalKeybindingHandlers {...globalKeybindingProps} />
4409          {feature('VOICE_MODE') ? <VoiceKeybindingHandler voiceHandleKeyEvent={voice.handleKeyEvent} stripTrailing={voice.stripTrailing} resetAnchor={voice.resetAnchor} isActive={!toolJSX?.isLocalJSXCommand} /> : null}
4410          <CommandKeybindingHandlers onSubmit={onSubmit} isActive={!toolJSX?.isLocalJSXCommand} />
4411          {transcriptScrollRef ?
4412        // ScrollKeybindingHandler must mount before CancelRequestHandler so
4413        // ctrl+c-with-selection copies instead of cancelling the active task.
4414        // Its raw useInput handler only stops propagation when a selection
4415        // exists — without one, ctrl+c falls through to CancelRequestHandler.
4416        <ScrollKeybindingHandler scrollRef={scrollRef}
4417        // Yield wheel/ctrl+u/d to UltraplanChoiceDialog's own scroll
4418        // handler while the modal is showing.
4419        isActive={focusedInputDialog !== 'ultraplan-choice'}
4420        // g/G/j/k/ctrl+u/ctrl+d would eat keystrokes the search bar
4421        // wants. Off while searching.
4422        isModal={!searchOpen}
4423        // Manual scroll exits the search context — clear the yellow
4424        // current-match marker. Positions are (msg, rowOffset)-keyed;
4425        // j/k changes scrollTop so rowOffset is stale → wrong row
4426        // gets yellow. Next n/N re-establishes via step()→jump().
4427        onScroll={() => jumpRef.current?.disarmSearch()} /> : null}
4428          <CancelRequestHandler {...cancelRequestProps} />
4429          {transcriptScrollRef ? <FullscreenLayout scrollRef={scrollRef} scrollable={<>
4430                  {transcriptMessagesElement}
4431                  {transcriptToolJSX}
4432                  <SandboxViolationExpandedView />
4433                </>} bottom={searchOpen ? <TranscriptSearchBar jumpRef={jumpRef}
4434        // Seed was tried (c01578c8) — broke /hello muscle
4435        // memory (cursor lands after 'foo', /hello → foohello).
4436        // Cancel-restore handles the 'don't lose prior search'
4437        // concern differently (onCancel re-applies searchQuery).
4438        initialQuery="" count={searchCount} current={searchCurrent} onClose={q => {
4439          // Enter — commit. 0-match guard: junk query shouldn't
4440          // persist (badge hidden, n/N dead anyway).
4441          setSearchQuery(searchCount > 0 ? q : '');
4442          setSearchOpen(false);
4443          // onCancel path: bar unmounts before its useEffect([query])
4444          // can fire with ''. Without this, searchCount stays stale
4445          // (n guard at :4956 passes) and VML's matches[] too
4446          // (nextMatch walks the old array). Phantom nav, no
4447          // highlight. onExit (Enter, q non-empty) still commits.
4448          if (!q) {
4449            setSearchCount(0);
4450            setSearchCurrent(0);
4451            jumpRef.current?.setSearchQuery('');
4452          }
4453        }} onCancel={() => {
4454          // Esc/ctrl+c/ctrl+g — undo. Bar's effect last fired
4455          // with whatever was typed. searchQuery (REPL state)
4456          // is unchanged since / (onClose = commit, didn't run).
4457          // Two VML calls: '' restores anchor (0-match else-
4458          // branch), then searchQuery re-scans from anchor's
4459          // nearest. Both synchronous — one React batch.
4460          // setHighlight explicit: REPL's sync-effect dep is
4461          // searchQuery (unchanged), wouldn't re-fire.
4462          setSearchOpen(false);
4463          jumpRef.current?.setSearchQuery('');
4464          jumpRef.current?.setSearchQuery(searchQuery);
4465          setHighlight(searchQuery);
4466        }} setHighlight={setHighlight} /> : <TranscriptModeFooter showAllInTranscript={showAllInTranscript} virtualScroll={true} status={editorStatus || undefined} searchBadge={searchQuery && searchCount > 0 ? {
4467          current: searchCurrent,
4468          count: searchCount
4469        } : undefined} />} /> : <>
4470              {transcriptMessagesElement}
4471              {transcriptToolJSX}
4472              <SandboxViolationExpandedView />
4473              <TranscriptModeFooter showAllInTranscript={showAllInTranscript} virtualScroll={false} suppressShowAll={dumpMode} status={editorStatus || undefined} />
4474            </>}
4475        </KeybindingSetup>;
4476      // The virtual-scroll branch (FullscreenLayout above) needs
4477      // <AlternateScreen>'s <Box height={rows}> constraint — without it,
4478      // ScrollBox's flexGrow has no ceiling, viewport = content height,
4479      // scrollTop pins at 0, and Ink's screen buffer sizes to the full
4480      // spacer (200×5k+ rows on long sessions). Same root type + props as
4481      // normal mode's wrap below so React reconciles and the alt buffer
4482      // stays entered across toggle. The 30-cap dump branch stays
4483      // unwrapped — it wants native terminal scrollback.
4484      if (transcriptScrollRef) {
4485        return <AlternateScreen mouseTracking={isMouseTrackingEnabled()}>
4486            {transcriptReturn}
4487          </AlternateScreen>;
4488      }
4489      return transcriptReturn;
4490    }
4491  
4492    // Get viewed agent task (inlined from selectors for explicit data flow).
4493    // viewedAgentTask: teammate OR local_agent — drives the boolean checks
4494    // below. viewedTeammateTask: teammate-only narrowed, for teammate-specific
4495    // field access (inProgressToolUseIDs).
4496    const viewedTask = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined;
4497    const viewedTeammateTask = viewedTask && isInProcessTeammateTask(viewedTask) ? viewedTask : undefined;
4498    const viewedAgentTask = viewedTeammateTask ?? (viewedTask && isLocalAgentTask(viewedTask) ? viewedTask : undefined);
4499  
4500    // Bypass useDeferredValue when streaming text is showing so Messages renders
4501    // the final message in the same frame streaming text clears. Also bypass when
4502    // not loading — deferredMessages only matters during streaming (keeps input
4503    // responsive); after the turn ends, showing messages immediately prevents a
4504    // jitter gap where the spinner is gone but the answer hasn't appeared yet.
4505    // Only reducedMotion users keep the deferred path during loading.
4506    const usesSyncMessages = showStreamingText || !isLoading;
4507    // When viewing an agent, never fall through to leader — empty until
4508    // bootstrap/stream fills. Closes the see-leader-type-agent footgun.
4509    const displayedMessages = viewedAgentTask ? viewedAgentTask.messages ?? [] : usesSyncMessages ? messages : deferredMessages;
4510    // Show the placeholder until the real user message appears in
4511    // displayedMessages. userInputOnProcessing stays set for the whole turn
4512    // (cleared in resetLoadingState); this length check hides it once
4513    // displayedMessages grows past the baseline captured at submit time.
4514    // Covers both gaps: before setMessages is called (processUserInput), and
4515    // while deferredMessages lags behind messages. Suppressed when viewing an
4516    // agent — displayedMessages is a different array there, and onAgentSubmit
4517    // doesn't use the placeholder anyway.
4518    const placeholderText = userInputOnProcessing && !viewedAgentTask && displayedMessages.length <= userInputBaselineRef.current ? userInputOnProcessing : undefined;
4519    const toolPermissionOverlay = focusedInputDialog === 'tool-permission' ? <PermissionRequest key={toolUseConfirmQueue[0]?.toolUseID} 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} /> : null;
4520  
4521    // Narrow terminals: companion collapses to a one-liner that REPL stacks
4522    // on its own row (above input in fullscreen, below in scrollback) instead
4523    // of row-beside. Wide terminals keep the row layout with sprite on the right.
4524    const companionNarrow = transcriptCols < MIN_COLS_FOR_FULL_SPRITE;
4525    // Hide the sprite when PromptInput early-returns BackgroundTasksDialog.
4526    // The sprite sits as a row sibling of PromptInput, so the dialog's Pane
4527    // divider draws at useTerminalSize() width but only gets terminalWidth -
4528    // spriteWidth — divider stops short and dialog text wraps early. Don't
4529    // check footerSelection: pill FOCUS (arrow-down to tasks pill) must keep
4530    // the sprite visible so arrow-right can navigate to it.
4531    const companionVisible = !toolJSX?.shouldHidePromptInput && !focusedInputDialog && !showBashesDialog;
4532  
4533    // In fullscreen, ALL local-jsx slash commands float in the modal slot —
4534    // FullscreenLayout wraps them in an absolute-positioned bottom-anchored
4535    // pane (▔ divider, ModalContext). Pane/Dialog inside detect the context
4536    // and skip their own top-level frame. Non-fullscreen keeps the inline
4537    // render paths below. Commands that used to route through bottom
4538    // (immediate: /model, /mcp, /btw, ...) and scrollable (non-immediate:
4539    // /config, /theme, /diff, ...) both go here now.
4540    const toolJsxCentered = isFullscreenEnvEnabled() && toolJSX?.isLocalJSXCommand === true;
4541    const centeredModal: React.ReactNode = toolJsxCentered ? toolJSX!.jsx : null;
4542  
4543    // <AlternateScreen> at the root: everything below is inside its
4544    // <Box height={rows}>. Handlers/contexts are zero-height so ScrollBox's
4545    // flexGrow in FullscreenLayout resolves against this Box. The transcript
4546    // early return above wraps its virtual-scroll branch the same way; only
4547    // the 30-cap dump branch stays unwrapped for native terminal scrollback.
4548    const mainReturn = <KeybindingSetup>
4549        <AnimatedTerminalTitle isAnimating={titleIsAnimating} title={terminalTitle} disabled={titleDisabled} noPrefix={showStatusInTerminalTab} />
4550        <GlobalKeybindingHandlers {...globalKeybindingProps} />
4551        {feature('VOICE_MODE') ? <VoiceKeybindingHandler voiceHandleKeyEvent={voice.handleKeyEvent} stripTrailing={voice.stripTrailing} resetAnchor={voice.resetAnchor} isActive={!toolJSX?.isLocalJSXCommand} /> : null}
4552        <CommandKeybindingHandlers onSubmit={onSubmit} isActive={!toolJSX?.isLocalJSXCommand} />
4553        {/* ScrollKeybindingHandler must mount before CancelRequestHandler so
4554            ctrl+c-with-selection copies instead of cancelling the active task.
4555            Its raw useInput handler only stops propagation when a selection
4556            exists — without one, ctrl+c falls through to CancelRequestHandler.
4557            PgUp/PgDn/wheel always scroll the transcript behind the modal —
4558            the modal's inner ScrollBox is not keyboard-driven. onScroll
4559            stays suppressed while a modal is showing so scroll doesn't
4560            stamp divider/pill state. */}
4561        <ScrollKeybindingHandler scrollRef={scrollRef} isActive={isFullscreenEnvEnabled() && (centeredModal != null || !focusedInputDialog || focusedInputDialog === 'tool-permission')} onScroll={centeredModal || toolPermissionOverlay || viewedAgentTask ? undefined : composedOnScroll} />
4562        {feature('MESSAGE_ACTIONS') && isFullscreenEnvEnabled() && !disableMessageActions ? <MessageActionsKeybindings handlers={messageActionHandlers} isActive={cursor !== null} /> : null}
4563        <CancelRequestHandler {...cancelRequestProps} />
4564        <MCPConnectionManager key={remountKey} dynamicMcpConfig={dynamicMcpConfig} isStrictMcpConfig={strictMcpConfig}>
4565          <FullscreenLayout scrollRef={scrollRef} overlay={toolPermissionOverlay} bottomFloat={feature('BUDDY') && companionVisible && !companionNarrow ? <CompanionFloatingBubble /> : undefined} modal={centeredModal} modalScrollRef={modalScrollRef} dividerYRef={dividerYRef} hidePill={!!viewedAgentTask} hideSticky={!!viewedTeammateTask} newMessageCount={unseenDivider?.count ?? 0} onPillClick={() => {
4566          setCursor(null);
4567          jumpToNew(scrollRef.current);
4568        }} scrollable={<>
4569                <TeammateViewHeader />
4570                <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} />
4571                <AwsAuthStatusBox />
4572                {/* Hide the processing placeholder while a modal is showing —
4573                    it would sit at the last visible transcript row right above
4574                    the ▔ divider, showing "❯ /config" as redundant clutter
4575                    (the modal IS the /config UI). Outside modals it stays so
4576                    the user sees their input echoed while Claude processes. */}
4577                {!disabled && placeholderText && !centeredModal && <UserTextMessage param={{
4578            text: placeholderText,
4579            type: 'text'
4580          }} addMargin={true} verbose={verbose} />}
4581                {toolJSX && !(toolJSX.isLocalJSXCommand && toolJSX.isImmediate) && !toolJsxCentered && <Box flexDirection="column" width="100%">
4582                      {toolJSX.jsx}
4583                    </Box>}
4584                {"external" === 'ant' && <TungstenLiveMonitor />}
4585                {feature('WEB_BROWSER_TOOL') ? WebBrowserPanelModule && <WebBrowserPanelModule.WebBrowserPanel /> : null}
4586                <Box flexGrow={1} />
4587                {showSpinner && <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} />}
4588                {!showSpinner && !isLoading && !userInputOnProcessing && !hasRunningTeammates && isBriefOnly && !viewedAgentTask && <BriefIdleStatus />}
4589                {isFullscreenEnvEnabled() && <PromptInputQueuedCommands />}
4590              </>} bottom={<Box flexDirection={feature('BUDDY') && companionNarrow ? 'column' : 'row'} width="100%" alignItems={feature('BUDDY') && companionNarrow ? undefined : 'flex-end'}>
4591                {feature('BUDDY') && companionNarrow && isFullscreenEnvEnabled() && companionVisible ? <CompanionSprite /> : null}
4592                <Box flexDirection="column" flexGrow={1}>
4593                  {permissionStickyFooter}
4594                  {/* Immediate local-jsx commands (/btw, /sandbox, /assistant,
4595                    /issue) render here, NOT inside scrollable. They stay mounted
4596                    while the main conversation streams behind them, so ScrollBox
4597                    relayouts on each new message would drag them around. bottom
4598                    is flexShrink={0} outside the ScrollBox — it never moves.
4599                    Non-immediate local-jsx (/diff, /status, /theme, ~40 others)
4600                    stays in scrollable: the main loop is paused so no jiggle,
4601                    and their tall content (DiffDetailView renders up to 400
4602                    lines with no internal scroll) needs the outer ScrollBox. */}
4603                  {toolJSX?.isLocalJSXCommand && toolJSX.isImmediate && !toolJsxCentered && <Box flexDirection="column" width="100%">
4604                        {toolJSX.jsx}
4605                      </Box>}
4606                  {!showSpinner && !toolJSX?.isLocalJSXCommand && showExpandedTodos && tasksV2 && tasksV2.length > 0 && <Box width="100%" flexDirection="column">
4607                        <TaskListV2 tasks={tasksV2} isStandalone={true} />
4608                      </Box>}
4609                  {focusedInputDialog === 'sandbox-permission' && <SandboxPermissionRequest key={sandboxPermissionRequestQueue[0]!.hostPattern.host} hostPattern={sandboxPermissionRequestQueue[0]!.hostPattern} onUserResponse={(response: {
4610              allow: boolean;
4611              persistToSettings: boolean;
4612            }) => {
4613              const {
4614                allow,
4615                persistToSettings
4616              } = response;
4617              const currentRequest = sandboxPermissionRequestQueue[0];
4618              if (!currentRequest) return;
4619              const approvedHost = currentRequest.hostPattern.host;
4620              if (persistToSettings) {
4621                const update = {
4622                  type: 'addRules' as const,
4623                  rules: [{
4624                    toolName: WEB_FETCH_TOOL_NAME,
4625                    ruleContent: `domain:${approvedHost}`
4626                  }],
4627                  behavior: (allow ? 'allow' : 'deny') as 'allow' | 'deny',
4628                  destination: 'localSettings' as const
4629                };
4630                setAppState(prev => ({
4631                  ...prev,
4632                  toolPermissionContext: applyPermissionUpdate(prev.toolPermissionContext, update)
4633                }));
4634                persistPermissionUpdate(update);
4635  
4636                // Immediately update sandbox in-memory config to prevent race conditions
4637                // where pending requests slip through before settings change is detected
4638                SandboxManager.refreshConfig();
4639              }
4640  
4641              // Resolve ALL pending requests for the same host (not just the first one)
4642              // This handles the case where multiple parallel requests came in for the same domain
4643              setSandboxPermissionRequestQueue(queue => {
4644                queue.filter(item => item.hostPattern.host === approvedHost).forEach(item => item.resolvePromise(allow));
4645                return queue.filter(item => item.hostPattern.host !== approvedHost);
4646              });
4647  
4648              // Clean up bridge subscriptions and cancel remote prompts
4649              // for this host since the local user already responded.
4650              const cleanups = sandboxBridgeCleanupRef.current.get(approvedHost);
4651              if (cleanups) {
4652                for (const fn of cleanups) {
4653                  fn();
4654                }
4655                sandboxBridgeCleanupRef.current.delete(approvedHost);
4656              }
4657            }} />}
4658                  {focusedInputDialog === 'prompt' && <PromptDialog key={promptQueue[0]!.request.prompt} title={promptQueue[0]!.title} toolInputSummary={promptQueue[0]!.toolInputSummary} request={promptQueue[0]!.request} onRespond={selectedKey => {
4659              const item = promptQueue[0];
4660              if (!item) return;
4661              item.resolve({
4662                prompt_response: item.request.prompt,
4663                selected: selectedKey
4664              });
4665              setPromptQueue(([, ...tail]) => tail);
4666            }} onAbort={() => {
4667              const item = promptQueue[0];
4668              if (!item) return;
4669              item.reject(new Error('Prompt cancelled by user'));
4670              setPromptQueue(([, ...tail]) => tail);
4671            }} />}
4672                  {/* Show pending indicator on worker while waiting for leader approval */}
4673                  {pendingWorkerRequest && <WorkerPendingPermission toolName={pendingWorkerRequest.toolName} description={pendingWorkerRequest.description} />}
4674                  {/* Show pending indicator for sandbox permission on worker side */}
4675                  {pendingSandboxRequest && <WorkerPendingPermission toolName="Network Access" description={`Waiting for leader to approve network access to ${pendingSandboxRequest.host}`} />}
4676                  {/* Worker sandbox permission requests from swarm workers */}
4677                  {focusedInputDialog === 'worker-sandbox-permission' && <SandboxPermissionRequest key={workerSandboxPermissions.queue[0]!.requestId} hostPattern={{
4678              host: workerSandboxPermissions.queue[0]!.host,
4679              port: undefined
4680            } as NetworkHostPattern} onUserResponse={(response: {
4681              allow: boolean;
4682              persistToSettings: boolean;
4683            }) => {
4684              const {
4685                allow,
4686                persistToSettings
4687              } = response;
4688              const currentRequest = workerSandboxPermissions.queue[0];
4689              if (!currentRequest) return;
4690              const approvedHost = currentRequest.host;
4691  
4692              // Send response via mailbox to the worker
4693              void sendSandboxPermissionResponseViaMailbox(currentRequest.workerName, currentRequest.requestId, approvedHost, allow, teamContext?.teamName);
4694              if (persistToSettings && allow) {
4695                const update = {
4696                  type: 'addRules' as const,
4697                  rules: [{
4698                    toolName: WEB_FETCH_TOOL_NAME,
4699                    ruleContent: `domain:${approvedHost}`
4700                  }],
4701                  behavior: 'allow' as const,
4702                  destination: 'localSettings' as const
4703                };
4704                setAppState(prev => ({
4705                  ...prev,
4706                  toolPermissionContext: applyPermissionUpdate(prev.toolPermissionContext, update)
4707                }));
4708                persistPermissionUpdate(update);
4709                SandboxManager.refreshConfig();
4710              }
4711  
4712              // Remove from queue
4713              setAppState(prev => ({
4714                ...prev,
4715                workerSandboxPermissions: {
4716                  ...prev.workerSandboxPermissions,
4717                  queue: prev.workerSandboxPermissions.queue.slice(1)
4718                }
4719              }));
4720            }} />}
4721                  {focusedInputDialog === 'elicitation' && <ElicitationDialog key={elicitation.queue[0]!.serverName + ':' + String(elicitation.queue[0]!.requestId)} event={elicitation.queue[0]!} onResponse={(action, content) => {
4722              const currentRequest = elicitation.queue[0];
4723              if (!currentRequest) return;
4724              // Call respond callback to resolve Promise
4725              currentRequest.respond({
4726                action,
4727                content
4728              });
4729              // For URL accept, keep in queue for phase 2
4730              const isUrlAccept = currentRequest.params.mode === 'url' && action === 'accept';
4731              if (!isUrlAccept) {
4732                setAppState(prev => ({
4733                  ...prev,
4734                  elicitation: {
4735                    queue: prev.elicitation.queue.slice(1)
4736                  }
4737                }));
4738              }
4739            }} onWaitingDismiss={action => {
4740              const currentRequest = elicitation.queue[0];
4741              // Remove from queue
4742              setAppState(prev => ({
4743                ...prev,
4744                elicitation: {
4745                  queue: prev.elicitation.queue.slice(1)
4746                }
4747              }));
4748              currentRequest?.onWaitingDismiss?.(action);
4749            }} />}
4750                  {focusedInputDialog === 'cost' && <CostThresholdDialog onDone={() => {
4751              setShowCostDialog(false);
4752              setHaveShownCostDialog(true);
4753              saveGlobalConfig(current => ({
4754                ...current,
4755                hasAcknowledgedCostThreshold: true
4756              }));
4757              logEvent('tengu_cost_threshold_acknowledged', {});
4758            }} />}
4759                  {focusedInputDialog === 'idle-return' && idleReturnPending && <IdleReturnDialog idleMinutes={idleReturnPending.idleMinutes} totalInputTokens={getTotalInputTokens()} onDone={async action => {
4760              const pending = idleReturnPending;
4761              setIdleReturnPending(null);
4762              logEvent('tengu_idle_return_action', {
4763                action: action as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
4764                idleMinutes: Math.round(pending.idleMinutes),
4765                messageCount: messagesRef.current.length,
4766                totalInputTokens: getTotalInputTokens()
4767              });
4768              if (action === 'dismiss') {
4769                setInputValue(pending.input);
4770                return;
4771              }
4772              if (action === 'never') {
4773                saveGlobalConfig(current => {
4774                  if (current.idleReturnDismissed) return current;
4775                  return {
4776                    ...current,
4777                    idleReturnDismissed: true
4778                  };
4779                });
4780              }
4781              if (action === 'clear') {
4782                const {
4783                  clearConversation
4784                } = await import('../commands/clear/conversation.js');
4785                await clearConversation({
4786                  setMessages,
4787                  readFileState: readFileState.current,
4788                  discoveredSkillNames: discoveredSkillNamesRef.current,
4789                  loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,
4790                  getAppState: () => store.getState(),
4791                  setAppState,
4792                  setConversationId
4793                });
4794                haikuTitleAttemptedRef.current = false;
4795                setHaikuTitle(undefined);
4796                bashTools.current.clear();
4797                bashToolsProcessedIdx.current = 0;
4798              }
4799              skipIdleCheckRef.current = true;
4800              void onSubmitRef.current(pending.input, {
4801                setCursorOffset: () => {},
4802                clearBuffer: () => {},
4803                resetHistory: () => {}
4804              });
4805            }} />}
4806                  {focusedInputDialog === 'ide-onboarding' && <IdeOnboardingDialog onDone={() => setShowIdeOnboarding(false)} installationStatus={ideInstallationStatus} />}
4807                  {"external" === 'ant' && focusedInputDialog === 'model-switch' && AntModelSwitchCallout && <AntModelSwitchCallout onDone={(selection: string, modelAlias?: string) => {
4808              setShowModelSwitchCallout(false);
4809              if (selection === 'switch' && modelAlias) {
4810                setAppState(prev => ({
4811                  ...prev,
4812                  mainLoopModel: modelAlias,
4813                  mainLoopModelForSession: null
4814                }));
4815              }
4816            }} />}
4817                  {"external" === 'ant' && focusedInputDialog === 'undercover-callout' && UndercoverAutoCallout && <UndercoverAutoCallout onDone={() => setShowUndercoverCallout(false)} />}
4818                  {focusedInputDialog === 'effort-callout' && <EffortCallout model={mainLoopModel} onDone={selection => {
4819              setShowEffortCallout(false);
4820              if (selection !== 'dismiss') {
4821                setAppState(prev => ({
4822                  ...prev,
4823                  effortValue: selection
4824                }));
4825              }
4826            }} />}
4827                  {focusedInputDialog === 'remote-callout' && <RemoteCallout onDone={selection => {
4828              setAppState(prev => {
4829                if (!prev.showRemoteCallout) return prev;
4830                return {
4831                  ...prev,
4832                  showRemoteCallout: false,
4833                  ...(selection === 'enable' && {
4834                    replBridgeEnabled: true,
4835                    replBridgeExplicit: true,
4836                    replBridgeOutboundOnly: false
4837                  })
4838                };
4839              });
4840            }} />}
4841  
4842                  {exitFlow}
4843  
4844                  {focusedInputDialog === 'plugin-hint' && hintRecommendation && <PluginHintMenu pluginName={hintRecommendation.pluginName} pluginDescription={hintRecommendation.pluginDescription} marketplaceName={hintRecommendation.marketplaceName} sourceCommand={hintRecommendation.sourceCommand} onResponse={handleHintResponse} />}
4845  
4846                  {focusedInputDialog === 'lsp-recommendation' && lspRecommendation && <LspRecommendationMenu pluginName={lspRecommendation.pluginName} pluginDescription={lspRecommendation.pluginDescription} fileExtension={lspRecommendation.fileExtension} onResponse={handleLspResponse} />}
4847  
4848                  {focusedInputDialog === 'desktop-upsell' && <DesktopUpsellStartup onDone={() => setShowDesktopUpsellStartup(false)} />}
4849  
4850                  {feature('ULTRAPLAN') ? focusedInputDialog === 'ultraplan-choice' && ultraplanPendingChoice && <UltraplanChoiceDialog plan={ultraplanPendingChoice.plan} sessionId={ultraplanPendingChoice.sessionId} taskId={ultraplanPendingChoice.taskId} setMessages={setMessages} readFileState={readFileState.current} getAppState={() => store.getState()} setConversationId={setConversationId} /> : null}
4851  
4852                  {feature('ULTRAPLAN') ? focusedInputDialog === 'ultraplan-launch' && ultraplanLaunchPending && <UltraplanLaunchDialog onChoice={(choice, opts) => {
4853              const blurb = ultraplanLaunchPending.blurb;
4854              setAppState(prev => prev.ultraplanLaunchPending ? {
4855                ...prev,
4856                ultraplanLaunchPending: undefined
4857              } : prev);
4858              if (choice === 'cancel') return;
4859              // Command's onDone used display:'skip', so add the
4860              // echo here — gives immediate feedback before the
4861              // ~5s teleportToRemote resolves.
4862              setMessages(prev => [...prev, createCommandInputMessage(formatCommandInputTags('ultraplan', blurb))]);
4863              const appendStdout = (msg: string) => setMessages(prev => [...prev, createCommandInputMessage(`<${LOCAL_COMMAND_STDOUT_TAG}>${escapeXml(msg)}</${LOCAL_COMMAND_STDOUT_TAG}>`)]);
4864              // Defer the second message if a query is mid-turn
4865              // so it lands after the assistant reply, not
4866              // between the user's prompt and the reply.
4867              const appendWhenIdle = (msg: string) => {
4868                if (!queryGuard.isActive) {
4869                  appendStdout(msg);
4870                  return;
4871                }
4872                const unsub = queryGuard.subscribe(() => {
4873                  if (queryGuard.isActive) return;
4874                  unsub();
4875                  // Skip if the user stopped ultraplan while we
4876                  // were waiting — avoids a stale "Monitoring
4877                  // <url>" message for a session that's gone.
4878                  if (!store.getState().ultraplanSessionUrl) return;
4879                  appendStdout(msg);
4880                });
4881              };
4882              void launchUltraplan({
4883                blurb,
4884                getAppState: () => store.getState(),
4885                setAppState,
4886                signal: createAbortController().signal,
4887                disconnectedBridge: opts?.disconnectedBridge,
4888                onSessionReady: appendWhenIdle
4889              }).then(appendStdout).catch(logError);
4890            }} /> : null}
4891  
4892                  {mrRender()}
4893  
4894                  {!toolJSX?.shouldHidePromptInput && !focusedInputDialog && !isExiting && !disabled && !cursor && <>
4895                        {autoRunIssueReason && <AutoRunIssueNotification onRun={handleAutoRunIssue} onCancel={handleCancelAutoRunIssue} reason={getAutoRunIssueReasonText(autoRunIssueReason)} />}
4896                        {postCompactSurvey.state !== 'closed' ? <FeedbackSurvey state={postCompactSurvey.state} lastResponse={postCompactSurvey.lastResponse} handleSelect={postCompactSurvey.handleSelect} inputValue={inputValue} setInputValue={setInputValue} onRequestFeedback={handleSurveyRequestFeedback} /> : memorySurvey.state !== 'closed' ? <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)" /> : <FeedbackSurvey state={feedbackSurvey.state} lastResponse={feedbackSurvey.lastResponse} handleSelect={feedbackSurvey.handleSelect} handleTranscriptSelect={feedbackSurvey.handleTranscriptSelect} inputValue={inputValue} setInputValue={setInputValue} onRequestFeedback={didAutoRunIssueRef.current ? undefined : handleSurveyRequestFeedback} />}
4897                        {/* Frustration-triggered transcript sharing prompt */}
4898                        {frustrationDetection.state !== 'closed' && <FeedbackSurvey state={frustrationDetection.state} lastResponse={null} handleSelect={() => {}} handleTranscriptSelect={frustrationDetection.handleTranscriptSelect} inputValue={inputValue} setInputValue={setInputValue} />}
4899                        {/* Skill improvement survey - appears when improvements detected (ant-only) */}
4900                        {"external" === 'ant' && skillImprovementSurvey.suggestion && <SkillImprovementSurvey isOpen={skillImprovementSurvey.isOpen} skillName={skillImprovementSurvey.suggestion.skillName} updates={skillImprovementSurvey.suggestion.updates} handleSelect={skillImprovementSurvey.handleSelect} inputValue={inputValue} setInputValue={setInputValue} />}
4901                        {showIssueFlagBanner && <IssueFlagBanner />}
4902                        {}
4903                        <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={
4904              // Works during isLoading — edit cancels first; uuid selection survives appends.
4905              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} />
4906                        <SessionBackgroundHint onBackgroundSession={handleBackgroundSession} isLoading={isLoading} />
4907                      </>}
4908                  {cursor &&
4909            // inputValue is REPL state; typed text survives the round-trip.
4910            <MessageActionsBar cursor={cursor} />}
4911                  {focusedInputDialog === 'message-selector' && <MessageSelector messages={messages} preselectedMessage={messageSelectorPreselect} onPreRestore={onCancel} onRestoreCode={async (message: UserMessage) => {
4912              await fileHistoryRewind((updater: (prev: FileHistoryState) => FileHistoryState) => {
4913                setAppState(prev => ({
4914                  ...prev,
4915                  fileHistory: updater(prev.fileHistory)
4916                }));
4917              }, message.uuid);
4918            }} onSummarize={async (message: UserMessage, feedback?: string, direction: PartialCompactDirection = 'from') => {
4919              // Project snipped messages so the compact model
4920              // doesn't summarize content that was intentionally removed.
4921              const compactMessages = getMessagesAfterCompactBoundary(messages);
4922              const messageIndex = compactMessages.indexOf(message);
4923              if (messageIndex === -1) {
4924                // Selected a snipped or pre-compact message that the
4925                // selector still shows (REPL keeps full history for
4926                // scrollback). Surface why nothing happened instead
4927                // of silently no-oping.
4928                setMessages(prev => [...prev, createSystemMessage('That message is no longer in the active context (snipped or pre-compact). Choose a more recent message.', 'warning')]);
4929                return;
4930              }
4931              const newAbortController = createAbortController();
4932              const context = getToolUseContext(compactMessages, [], newAbortController, mainLoopModel);
4933              const appState = context.getAppState();
4934              const defaultSysPrompt = await getSystemPrompt(context.options.tools, context.options.mainLoopModel, Array.from(appState.toolPermissionContext.additionalWorkingDirectories.keys()), context.options.mcpClients);
4935              const systemPrompt = buildEffectiveSystemPrompt({
4936                mainThreadAgentDefinition: undefined,
4937                toolUseContext: context,
4938                customSystemPrompt: context.options.customSystemPrompt,
4939                defaultSystemPrompt: defaultSysPrompt,
4940                appendSystemPrompt: context.options.appendSystemPrompt
4941              });
4942              const [userContext, systemContext] = await Promise.all([getUserContext(), getSystemContext()]);
4943              const result = await partialCompactConversation(compactMessages, messageIndex, context, {
4944                systemPrompt,
4945                userContext,
4946                systemContext,
4947                toolUseContext: context,
4948                forkContextMessages: compactMessages
4949              }, feedback, direction);
4950              const kept = result.messagesToKeep ?? [];
4951              const ordered = direction === 'up_to' ? [...result.summaryMessages, ...kept] : [...kept, ...result.summaryMessages];
4952              const postCompact = [result.boundaryMarker, ...ordered, ...result.attachments, ...result.hookResults];
4953              // Fullscreen 'from' keeps scrollback; 'up_to' must not
4954              // (old[0] unchanged + grown array means incremental
4955              // useLogMessages path, so boundary never persisted).
4956              // Find by uuid since old is raw REPL history and snipped
4957              // entries can shift the projected messageIndex.
4958              if (isFullscreenEnvEnabled() && direction === 'from') {
4959                setMessages(old => {
4960                  const rawIdx = old.findIndex(m => m.uuid === message.uuid);
4961                  return [...old.slice(0, rawIdx === -1 ? 0 : rawIdx), ...postCompact];
4962                });
4963              } else {
4964                setMessages(postCompact);
4965              }
4966              // Partial compact bypasses handleMessageFromStream — clear
4967              // the context-blocked flag so proactive ticks resume.
4968              if (feature('PROACTIVE') || feature('KAIROS')) {
4969                proactiveModule?.setContextBlocked(false);
4970              }
4971              setConversationId(randomUUID());
4972              runPostCompactCleanup(context.options.querySource);
4973              if (direction === 'from') {
4974                const r = textForResubmit(message);
4975                if (r) {
4976                  setInputValue(r.text);
4977                  setInputMode(r.mode);
4978                }
4979              }
4980  
4981              // Show notification with ctrl+o hint
4982              const historyShortcut = getShortcutDisplay('app:toggleTranscript', 'Global', 'ctrl+o');
4983              addNotification({
4984                key: 'summarize-ctrl-o-hint',
4985                text: `Conversation summarized (${historyShortcut} for history)`,
4986                priority: 'medium',
4987                timeoutMs: 8000
4988              });
4989            }} onRestoreMessage={handleRestoreMessage} onClose={() => {
4990              setIsMessageSelectorVisible(false);
4991              setMessageSelectorPreselect(undefined);
4992            }} />}
4993                  {"external" === 'ant' && <DevBar />}
4994                </Box>
4995                {feature('BUDDY') && !(companionNarrow && isFullscreenEnvEnabled()) && companionVisible ? <CompanionSprite /> : null}
4996              </Box>} />
4997        </MCPConnectionManager>
4998      </KeybindingSetup>;
4999    if (isFullscreenEnvEnabled()) {
5000      return <AlternateScreen mouseTracking={isMouseTrackingEnabled()}>
5001          {mainReturn}
5002        </AlternateScreen>;
5003    }
5004    return mainReturn;
5005  }
5006  //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","spawnSync","snapshotOutputTokensForTurn","getCurrentTurnTokenBudget","getTurnOutputTokens","getBudgetContinuationCount","getTotalInputTokens","parseTokenBudget","count","dirname","join","tmpdir","figures","useInput","useSearchInput","useTerminalSize","useSearchHighlight","JumpHandle","renderMessagesToPlainText","openFileInExternalEditor","writeFile","Box","Text","useStdin","useTheme","useTerminalFocus","useTerminalTitle","useTabStatus","TabStatusKind","CostThresholdDialog","IdleReturnDialog","React","useEffect","useMemo","useRef","useState","useCallback","useDeferredValue","useLayoutEffect","RefObject","useNotifications","sendNotification","startPreventSleep","stopPreventSleep","useTerminalNotification","hasCursorUpViewportYankBug","createFileStateCacheWithSizeLimit","mergeFileStateCaches","READ_FILE_STATE_CACHE_SIZE","updateLastInteractionTime","getLastInteractionTime","getOriginalCwd","getProjectRoot","getSessionId","switchSession","setCostStateForRestore","getTurnHookDurationMs","getTurnHookCount","resetTurnHookDuration","getTurnToolDurationMs","getTurnToolCount","resetTurnToolDuration","getTurnClassifierDurationMs","getTurnClassifierCount","resetTurnClassifierDuration","asSessionId","asAgentId","logForDebugging","QueryGuard","isEnvTruthy","formatTokens","truncateToWidth","consumeEarlyInput","setMemberActive","isSwarmWorker","generateSandboxRequestId","sendSandboxPermissionRequestViaMailbox","sendSandboxPermissionResponseViaMailbox","registerSandboxPermissionCallback","getTeamName","getAgentName","WorkerPendingPermission","injectUserMessageToTeammate","getAllInProcessTeammateTasks","isLocalAgentTask","queuePendingMessage","appendMessageToLocalAgent","LocalAgentTaskState","registerLeaderToolUseConfirmQueue","unregisterLeaderToolUseConfirmQueue","registerLeaderSetToolPermissionContext","unregisterLeaderSetToolPermissionContext","endInteractionSpan","useLogMessages","useReplBridge","Command","CommandResultDisplay","ResumeEntrypoint","getCommandName","isCommandEnabled","PromptInputMode","QueuedCommand","VimMode","MessageSelector","selectableUserMessagesFilter","messagesAfterAreOnlySynthetic","useIdeLogging","PermissionRequest","ToolUseConfirm","ElicitationDialog","PromptDialog","PromptRequest","PromptResponse","PromptInput","PromptInputQueuedCommands","useRemoteSession","useDirectConnect","DirectConnectConfig","useSSHSession","useAssistantHistory","SSHSession","SkillImprovementSurvey","useSkillImprovementSurvey","useMoreRight","SpinnerWithVerb","BriefIdleStatus","SpinnerMode","getSystemPrompt","buildEffectiveSystemPrompt","getSystemContext","getUserContext","getMemoryFiles","startBackgroundHousekeeping","getTotalCost","saveCurrentSessionCosts","resetCostState","getStoredSessionCosts","useCostSummary","useFpsMetrics","useAfterFirstRender","useDeferredHookMessages","addToHistory","removeLastFromHistory","expandPastedTextRefs","parseReferences","prependModeCharacterToInput","prependToShellHistoryCache","useApiKeyVerification","GlobalKeybindingHandlers","CommandKeybindingHandlers","KeybindingSetup","useShortcutDisplay","getShortcutDisplay","CancelRequestHandler","useBackgroundTaskNavigation","useSwarmInitialization","useTeammateViewAutoExit","errorMessage","isHumanTurn","logError","useVoiceIntegration","require","stripTrailing","handleKeyEvent","resetAnchor","VoiceKeybindingHandler","useFrustrationDetection","state","handleTranscriptSelect","useAntOrgWarningNotification","getCoordinatorUserContext","mcpClients","ReadonlyArray","name","scratchpadDir","k","useCanUseTool","ToolPermissionContext","Tool","applyPermissionUpdate","applyPermissionUpdates","persistPermissionUpdate","buildPermissionUpdates","stripDangerousPermissionsForAutoMode","getScratchpadDir","isScratchpadEnabled","WEB_FETCH_TOOL_NAME","SLEEP_TOOL_NAME","clearSpeculativeChecks","AutoUpdaterResult","getGlobalConfig","saveGlobalConfig","getGlobalConfigWriteCount","hasConsoleBillingAccess","logEvent","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","getFeatureValue_CACHED_MAY_BE_STALE","textForResubmit","handleMessageFromStream","StreamingToolUse","StreamingThinking","isCompactBoundaryMessage","getMessagesAfterCompactBoundary","getContentText","createUserMessage","createAssistantMessage","createTurnDurationMessage","createAgentsKilledMessage","createApiMetricsMessage","createSystemMessage","createCommandInputMessage","formatCommandInputTags","generateSessionTitle","BASH_INPUT_TAG","COMMAND_MESSAGE_TAG","COMMAND_NAME_TAG","LOCAL_COMMAND_STDOUT_TAG","escapeXml","ThinkingConfig","gracefulShutdownSync","handlePromptSubmit","PromptInputHelpers","useQueueProcessor","useMailboxBridge","queryCheckpoint","logQueryProfileReport","Message","MessageType","UserMessage","ProgressMessage","HookResultMessage","PartialCompactDirection","query","mergeClients","useMergedClients","getQuerySourceForREPL","useMergedTools","mergeAndFilterTools","useMergedCommands","useSkillsChange","useManagePlugins","Messages","TaskListV2","TeammateViewHeader","useTasksV2WithCollapseEffect","maybeMarkProjectOnboardingComplete","MCPServerConnection","ScopedMcpServerConfig","randomUUID","UUID","processSessionStartHooks","executeSessionEndHooks","getSessionEndHookTimeoutMs","IDESelection","useIdeSelection","getTools","assembleToolPool","AgentDefinition","resolveAgentTools","resumeAgentBackground","useMainLoopModel","useAppState","useSetAppState","useAppStateStore","ContentBlockParam","ImageBlockParam","ProcessUserInputContext","PastedContent","copyPlanForFork","copyPlanForResume","getPlanSlug","setPlanSlug","clearSessionMetadata","resetSessionFilePointer","adoptResumedSessionFile","removeTranscriptMessage","restoreSessionMetadata","getCurrentSessionTitle","isEphemeralToolProgress","isLoggableMessage","saveWorktreeState","getAgentTranscript","deserializeMessages","extractReadFilesFromMessages","extractBashToolsFromMessages","resetMicrocompactState","runPostCompactCleanup","provisionContentReplacementState","reconstructContentReplacementState","ContentReplacementRecord","partialCompactConversation","LogOption","AgentColorName","fileHistoryMakeSnapshot","FileHistoryState","fileHistoryRewind","FileHistorySnapshot","copyFileHistoryForResume","fileHistoryEnabled","fileHistoryHasAnyChanges","AttributionState","incrementPromptCount","recordAttributionSnapshot","computeStandaloneAgentContext","restoreAgentFromSession","restoreSessionStateFromLog","restoreWorktreeForResume","exitRestoredWorktree","isBgSession","updateSessionName","updateSessionActivity","isInProcessTeammateTask","InProcessTeammateTaskState","restoreRemoteAgentTasks","useInboxPoller","proactiveModule","PROACTIVE_NO_OP_SUBSCRIBE","_cb","PROACTIVE_FALSE","SUGGEST_BG_PR_NOOP","_p","_n","useProactive","useScheduledTasks","isAgentSwarmsEnabled","useTaskListWatcher","SandboxAskCallback","NetworkHostPattern","IDEExtensionInstallationStatus","closeOpenDiffs","getConnectedIdeClient","IdeType","useIDEIntegration","exit","ExitFlow","getCurrentWorktreeSession","popAllEditable","enqueue","SetAppState","getCommandQueue","getCommandQueueLength","removeByFilter","useCommandQueue","SessionBackgroundHint","startBackgroundSession","useSessionBackgrounding","diagnosticTracker","handleSpeculationAccept","ActiveSpeculationState","IdeOnboardingDialog","EffortCallout","shouldShowEffortCallout","EffortValue","RemoteCallout","AntModelSwitchCallout","shouldShowAntModelSwitch","shouldShowModelSwitchCallout","UndercoverAutoCallout","activityManager","createAbortController","MCPConnectionManager","useFeedbackSurvey","useMemorySurvey","usePostCompactSurvey","FeedbackSurvey","useInstallMessages","useAwaySummary","useChromeExtensionNotification","useOfficialMarketplaceNotification","usePromptsFromClaudeInChrome","getTipToShowOnSpinner","recordShownTip","Theme","checkAndDisableBypassPermissionsIfNeeded","checkAndDisableAutoModeIfNeeded","useKickOffCheckAndDisableBypassPermissionsIfNeeded","useKickOffCheckAndDisableAutoModeIfNeeded","SandboxManager","SANDBOX_NETWORK_ACCESS_TOOL_NAME","useFileHistorySnapshotInit","SandboxPermissionRequest","SandboxViolationExpandedView","useSettingsErrors","useMcpConnectivityStatus","useAutoModeUnavailableNotification","AUTO_MODE_DESCRIPTION","useLspInitializationNotification","useLspPluginRecommendation","LspRecommendationMenu","useClaudeCodeHintRecommendation","PluginHintMenu","DesktopUpsellStartup","shouldShowDesktopUpsellStartup","usePluginInstallationStatus","usePluginAutoupdateNotification","performStartupChecks","UserTextMessage","AwsAuthStatusBox","useRateLimitWarningNotification","useDeprecationWarningNotification","useNpmDeprecationNotification","useIDEStatusIndicator","useModelMigrationNotifications","useCanSwitchToExistingSubscription","useTeammateLifecycleNotification","useFastModeNotification","AutoRunIssueNotification","shouldAutoRunIssue","getAutoRunIssueReasonText","getAutoRunCommand","AutoRunIssueReason","HookProgress","TungstenLiveMonitor","WebBrowserPanelModule","IssueFlagBanner","useIssueFlagBanner","CompanionSprite","CompanionFloatingBubble","MIN_COLS_FOR_FULL_SPRITE","DevBar","RemoteSessionConfig","REMOTE_SAFE_COMMANDS","RemoteMessageContent","FullscreenLayout","useUnseenDivider","computeUnseenDivider","isFullscreenEnvEnabled","maybeGetTmuxMouseHint","isMouseTrackingEnabled","AlternateScreen","ScrollKeybindingHandler","useMessageActions","MessageActionsKeybindings","MessageActionsBar","MessageActionsState","MessageActionsNav","MessageActionCaps","setClipboard","ScrollBoxHandle","createAttachmentMessage","getQueuedCommandAttachments","EMPTY_MCP_CLIENTS","HISTORY_STUB","maybeLoadOlder","_","RECENT_SCROLL_REPIN_WINDOW_MS","median","values","sorted","sort","a","b","mid","Math","floor","length","round","TranscriptModeFooter","t0","$","_c","showAllInTranscript","virtualScroll","searchBadge","suppressShowAll","t1","status","undefined","toggleShortcut","showAllShortcut","t2","arrowUp","arrowDown","t3","t4","current","t5","TranscriptSearchBar","jumpRef","onClose","onCancel","setHighlight","initialQuery","lastQuery","ReactNode","cursorOffset","isActive","onExit","indexStatus","setIndexStatus","ms","alive","warm","warmSearchIndex","then","setTimeout","warmDone","setSearchQuery","off","cursorChar","slice","TITLE_ANIMATION_FRAMES","TITLE_STATIC_PREFIX","TITLE_ANIMATION_INTERVAL_MS","AnimatedTerminalTitle","isAnimating","title","disabled","noPrefix","terminalFocused","frame","setFrame","interval","setInterval","_temp2","clearInterval","prefix","setFrame_0","_temp","f","Props","commands","debug","initialTools","initialMessages","pendingHookMessages","Promise","initialFileHistorySnapshots","initialContentReplacements","initialAgentName","initialAgentColor","dynamicMcpConfig","Record","autoConnectIdeFlag","strictMcpConfig","systemPrompt","appendSystemPrompt","onBeforeQuery","input","newMessages","onTurnComplete","messages","mainThreadAgentDefinition","disableSlashCommands","taskListId","remoteSessionConfig","directConnectConfig","sshSession","thinkingConfig","Screen","REPL","initialCommands","initialMcpClients","initialDynamicMcpConfig","customSystemPrompt","initialMainThreadAgentDefinition","isRemoteSession","titleDisabled","process","env","CLAUDE_CODE_DISABLE_TERMINAL_TITLE","moreRightEnabled","CLAUDE_MORERIGHT","disableVirtualScroll","CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL","disableMessageActions","CLAUDE_CODE_DISABLE_MESSAGE_ACTIONS","setMainThreadAgentDefinition","toolPermissionContext","s","verbose","mcp","plugins","agentDefinitions","fileHistory","initialMessage","queuedCommands","spinnerTip","showExpandedTodos","expandedView","pendingWorkerRequest","pendingSandboxRequest","teamContext","tasks","workerSandboxPermissions","elicitation","ultraplanPendingChoice","ultraplanLaunchPending","viewingAgentTaskId","setAppState","viewedLocalAgent","needsBootstrap","retain","diskLoaded","taskId","result","prev","t","live","liveUuids","Set","map","m","uuid","diskOnly","filter","has","store","terminal","mainLoopModel","localCommands","setLocalCommands","proactiveActive","useSyncExternalStore","subscribeToProactiveChanges","isProactiveActive","isBriefOnly","localTools","setDynamicMcpConfig","onChangeDynamicMcpConfig","config","screen","setScreen","setShowAllInTranscript","dumpMode","setDumpMode","editorStatus","setEditorStatus","editorGenRef","editorTimerRef","ReturnType","editorRenderingRef","addNotification","removeNotification","trySuggestBgPRIntercept","clients","ideSelection","setIDESelection","ideToInstallExtension","setIDEToInstallExtension","ideInstallationStatus","setIDEInstallationStatus","showIdeOnboarding","setShowIdeOnboarding","showModelSwitchCallout","setShowModelSwitchCallout","showEffortCallout","setShowEffortCallout","showRemoteCallout","showDesktopUpsellStartup","setShowDesktopUpsellStartup","recommendation","lspRecommendation","handleResponse","handleLspResponse","hintRecommendation","handleHintResponse","combinedInitialTools","enabled","tasksV2","mode","mergedTools","tools","allowedAgentTypes","resolved","resolvedTools","commandsWithPlugins","mergedCommands","streamMode","setStreamMode","streamModeRef","streamingToolUses","setStreamingToolUses","streamingThinking","setStreamingThinking","isStreaming","streamingEndedAt","elapsed","Date","now","remaining","timer","clearTimeout","abortController","setAbortController","AbortController","abortControllerRef","sendBridgeResultRef","restoreMessageSyncRef","scrollRef","modalScrollRef","lastUserScrollTsRef","queryGuard","isQueryActive","subscribe","getSnapshot","isExternalLoading","setIsExternalLoadingRaw","hasInitialPrompt","isLoading","userInputOnProcessing","setUserInputOnProcessingRaw","userInputBaselineRef","userMessagePendingRef","loadingStartTimeRef","totalPausedMsRef","pauseStartTimeRef","resetTimingRefs","wasQueryActiveRef","setIsExternalLoading","value","swarmStartTimeRef","swarmBudgetInfoRef","tokens","limit","nudges","focusedInputDialogRef","getFocusedInputDialog","PROMPT_SUPPRESSION_MS","isPromptInputActive","setIsPromptInputActive","autoUpdaterResult","setAutoUpdaterResult","notifications","forEach","notification","key","text","priority","hint","showUndercoverCallout","setShowUndercoverCallout","isInternalModelRepo","shouldShowUndercoverAutoNotice","toolJSX","setToolJSXInternal","jsx","shouldHidePromptInput","shouldContinueAnimation","showSpinner","isLocalJSXCommand","isImmediate","localJSXCommandRef","setToolJSX","args","clearLocalJSX","rest","toolUseConfirmQueue","setToolUseConfirmQueue","permissionStickyFooter","setPermissionStickyFooter","sandboxPermissionRequestQueue","setSandboxPermissionRequestQueue","Array","hostPattern","resolvePromise","allowConnection","promptQueue","setPromptQueue","request","toolInputSummary","resolve","response","reject","error","Error","sandboxBridgeCleanupRef","Map","terminalTitleFromRename","settings","sessionTitle","haikuTitle","setHaikuTitle","haikuTitleAttemptedRef","agentTitle","agentType","terminalTitle","isWaitingForApproval","isShowingLocalJSXCommand","titleIsAnimating","sessionStatus","waitingFor","tool","tabStatusGateEnabled","showStatusInTerminalTab","rawSetMessages","messagesRef","idleHintShownRef","setMessages","action","SetStateAction","next","delta","added","some","setUserInputOnProcessing","dividerIndex","dividerYRef","onScrollAway","onRepin","jumpToNew","shiftDivider","cursor","setCursor","cursorNavRef","unseenDivider","repinScroll","scrollToBottom","lastMsg","at","lastMsgIsHuman","onPrepend","composedOnScroll","sticky","handle","companionReaction","awaitPendingHooks","deferredMessages","deferredBehind","frozenTranscriptState","setFrozenTranscriptState","messagesLength","streamingToolUsesLength","inputValue","setInputValueRaw","inputValueRef","insertTextRef","insert","setInputWithCursor","setInputValue","trim","inputMode","setInputMode","stashedPrompt","setStashedPrompt","pastedContents","handleRemoteInit","remoteSlashCommands","remoteCommandSet","cmd","inProgressToolUseIDs","setInProgressToolUseIDs","hasInterruptibleToolInProgressRef","remoteSession","setIsLoading","onInit","directConnect","sshRemote","session","activeRemote","isRemoteMode","setPastedContents","submitCount","setSubmitCount","responseLengthRef","apiMetricsRef","ttftMs","firstTokenTime","lastTokenTime","responseLengthBaseline","endResponseLength","setResponseLength","entries","lastEntry","streamingText","setStreamingText","reducedMotion","prefersReducedMotion","showStreamingText","onStreamingText","visibleStreamingText","substring","lastIndexOf","lastQueryCompletionTime","setLastQueryCompletionTime","spinnerMessage","setSpinnerMessage","spinnerColor","setSpinnerColor","spinnerShimmerColor","setSpinnerShimmerColor","isMessageSelectorVisible","setIsMessageSelectorVisible","messageSelectorPreselect","setMessageSelectorPreselect","showCostDialog","setShowCostDialog","conversationId","setConversationId","idleReturnPending","setIdleReturnPending","idleMinutes","skipIdleCheckRef","lastQueryCompletionTimeRef","contentReplacementStateRef","haveShownCostDialog","setHaveShownCostDialog","hasAcknowledgedCostThreshold","vimMode","setVimMode","showBashesDialog","setShowBashesDialog","isSearchingHistory","setIsSearchingHistory","isHelpOpen","setIsHelpOpen","isTerminalFocused","terminalFocusRef","theme","tipPickedThisTurnRef","pickNewSpinnerTip","bashToolsProcessedIdx","bashTools","add","readFileState","tip","content","resetLoadingState","hasRunningTeammates","totalMs","deferredBudget","safeYoloMessageShownRef","autoPermissionsNotificationCount","ref","prevCount","worktreeTipShownRef","wt","creationDurationMs","usedSparsePaths","secs","onlySleepToolActive","lastAssistant","findLast","type","inProgressToolUses","message","id","every","mrOnBeforeQuery","mrOnTurnComplete","render","mrRender","hasActivePrompt","queue","feedbackSurveyOriginal","skillImprovementSurvey","showIssueFlagBanner","feedbackSurvey","handleSelect","selected","didAutoRunIssueRef","showedTranscriptPrompt","setAutoRunIssueReason","postCompactSurvey","memorySurvey","frustrationDetection","setIDEInstallationState","fileHistoryState","resume","sessionId","log","entrypoint","resumeStart","performance","coordinatorModule","warning","matchSessionMode","getAgentDefinitionsWithOverrides","getActiveAgentsFromList","cache","clear","freshAgentDefs","allAgents","activeAgents","push","sessionEndTimeoutMs","getAppState","getState","signal","AbortSignal","timeout","timeoutMs","hookMessages","model","fileHistorySnapshots","agentDefinition","restoredAgent","agentSetting","agent","standaloneAgentContext","agentName","agentColor","restoreReadFileState","projectPath","targetSessionCosts","fullPath","renameRecordingForSession","worktreeSession","ws","saveMode","isCoordinatorMode","contentReplacements","success","resume_duration_ms","initialReadFileState","discoveredSkillNamesRef","loadedNestedMemoryPathsRef","cwd","extracted","apiKeyStatus","reverify","autoRunIssueReason","exitFlow","setExitFlow","isExiting","setIsExiting","showingCostDialog","allowDialogsWithAnimation","focusedInputDialog","hasSuppressedDialogs","isPaused","prevDialogRef","was","pauseProactive","forceEnd","onAbort","item","abort","cancelRequest","handleQueuedCommandOnCancel","images","newContents","image","cancelRequestProps","onAgentsKilled","abortSignal","popCommandFromQueue","totalCost","sandboxAskCallback","requestId","sent","host","resolveShouldAllowHost","resolveOnce","allow","bridgeCallbacks","replBridgePermissionCallbacks","bridgeRequestId","sendRequest","unsubscribe","onResponse","behavior","siblingCleanups","get","fn","delete","cleanup","existing","set","reason","getSandboxUnavailableReason","isSandboxRequired","stderr","write","level","isSandboxingEnabled","initialize","catch","err","setToolPermissionContext","context","options","preserveMode","setImmediate","currentQueue","recheckPermission","canUseTool","requestPrompt","getToolUseContext","computeTools","assembled","merged","thinkingEnabled","mcpResources","resources","isNonInteractiveSession","refreshTools","updateFileHistoryState","updater","updated","updateAttributionState","attribution","openMessageSelector","onChangeAPIKey","appendSystemMessage","msg","sendOSNotification","opts","onInstallIDEExtension","nestedMemoryAttachmentTriggers","loadedNestedMemoryPaths","dynamicSkillDirTriggers","discoveredSkillNames","pushApiMetricsEntry","baseline","onCompactProgress","event","hookType","setHasInterruptibleToolInProgress","v","contentReplacementState","handleBackgroundQuery","removedNotifications","toolUseContext","defaultSystemPrompt","userContext","systemContext","all","from","additionalWorkingDirectories","keys","renderedSystemPrompt","notificationAttachments","notificationMessages","existingPrompts","attachment","commandMode","prompt","uniqueNotifications","queryParams","querySource","description","handleBackgroundSession","onBackgroundQuery","onQueryEvent","Parameters","newMessage","old","includeSnipped","setContextBlocked","data","oldMessages","last","parentToolUseID","copy","isApiErrorMessage","newContent","tombstonedMessage","metrics","onQueryImpl","messagesIncludingNewMessages","shouldQuery","additionalAllowedTools","mainLoopModelParam","effort","freshClients","handleQueryStart","ideClient","firstUserMessage","find","isMeta","startsWith","setState","cur","alwaysAllowRules","command","i","freshTools","freshMcpClients","previousGetAppState","effortValue","baseUserContext","fastMode","terminalFocus","fireCompanionObserver","reaction","ttfts","e","otpsValues","samplingMs","isMultiRequest","hookMs","hookCount","toolMs","toolCount","classifierMs","classifierCount","turnMs","otps","isP50","hookDurationMs","turnDurationMs","toolDurationMs","classifierDurationMs","configWriteCount","onQuery","onBeforeQueryCallback","teamName","thisGeneration","tryStart","parsedBudget","latestMessages","shouldProceed","end","aborted","tungstenActiveSession","tungstenPanelAutoHidden","budgetInfo","hasRunningSwarmAgents","msgs","lastUserMsg","idx","initialMessageRef","pending","processInitialMessage","initialMsg","NonNullable","clearContext","oldPlanSlug","planContent","clearConversation","shouldStorePlanForVerification","updatedToolPermissionContext","allowedPrompts","prePlanMode","pendingPlanVerification","plan","verificationStarted","verificationCompleted","onSubmit","setCursorOffset","clearBuffer","resetHistory","newAbortController","helpers","speculationAccept","speculationSessionTimeSavedMs","fromKeybinding","resumeProactive","trimmedInput","spaceIndex","indexOf","commandName","commandArgs","matchingCommand","aliases","includes","variant","messageCount","totalInputTokens","shouldTreatAsImmediate","immediate","pastedTextRefs","r","pastedTextCount","pastedTextBytes","reduce","sum","executeImmediateCommand","doneWasCalled","onDone","doneOptions","display","metaMessages","mod","load","call","willowMode","idleThresholdMin","Number","CLAUDE_CODE_IDLE_THRESHOLD_MINUTES","tokenThreshold","CLAUDE_CODE_IDLE_TOKEN_THRESHOLD","idleReturnDismissed","idleMs","isSlashCommand","submitsNow","snapshot","queryRequired","c","split","pastedValues","Object","imageContents","imagePasteIds","messageContent","remoteContent","contentBlocks","remoteBlocks","pasted","source","const","media_type","mediaType","userMessage","sendMessage","onInputChange","hasInterruptibleToolInProgress","onAgentSubmit","task","agentId","handleAutoRunIssue","handleCancelAutoRunIssue","handleSurveyRequestFeedback","String","onSubmitRef","handleOpenRateLimitOptions","handleExit","stdio","showWorktree","exitMod","exitFlowResult","handleShowMessageSelector","rewindConversationTo","messageIndex","preRewindMessageCount","postRewindMessageCount","messagesRemoved","rewindToMessageIndex","resetContextCollapse","permissionMode","promptSuggestion","promptId","shownAt","acceptedAt","generationRequestId","restoreMessageSync","isArray","block","imageBlocks","newPastedContents","index","handleRestoreMessage","restore","findRawIndex","findIndex","messageActionCaps","raw","stdout","color","edit","rawIdx","noFileChanges","onlySynthetic","enter","enterMessageActions","handlers","messageActionHandlers","memoryFiles","fileList","path","parent","file","contentDiffersFromDisk","rawContent","timestamp","offset","isPartialView","sendBridgeResult","hasCountedQueueUseRef","promptQueueUseCount","executeQueuedInput","hasActiveLocalJsxUI","recordUserActivity","lastUserInteraction","idleTimeSinceResponse","messageIdleNotifThresholdMs","notificationType","idleThresholdMs","lqct","addNotif","msgsRef","hintRef","totalTokens","formattedTokens","max","handleIncomingPrompt","voice","interimRange","onSubmitMessage","assistantMode","kairosEnabled","onSubmitTask","queuedCommandsLength","isInPlanMode","onSubmitTick","onQueueTick","shutdown","internal_eventEmitter","remountKey","setRemountKey","handleSuspend","handleResume","on","stopHookSpinnerSuffix","progressMsgs","hookEvent","currentToolUseID","toolUseID","hasSummaryForCurrentExecution","subtype","currentHooks","p","total","completedCount","customMessage","statusMessage","label","handleEnterTranscript","handleExitTranscript","virtualScrollActive","searchOpen","setSearchOpen","searchQuery","searchCount","setSearchCount","searchCurrent","setSearchCurrent","onSearchMatchesChange","ctrl","meta","setAnchor","stopImmediatePropagation","repeat","nextMatch","prevMatch","setQuery","scanElement","setPositions","transcriptCols","columns","prevColsRef","disarmSearch","gen","setStatus","w","replace","opened","inTranscript","globalKeybindingProps","onEnterTranscript","onExitTranscript","searchBarOpen","transcriptMessages","transcriptStreamingToolUses","onOpenBackgroundTasks","transcriptScrollRef","transcriptMessagesElement","transcriptToolJSX","transcriptReturn","q","viewedTask","viewedTeammateTask","viewedAgentTask","usesSyncMessages","displayedMessages","placeholderText","toolPermissionOverlay","tail","workerBadge","companionNarrow","companionVisible","toolJsxCentered","centeredModal","mainReturn","size","persistToSettings","currentRequest","approvedHost","update","rules","toolName","ruleContent","destination","refreshConfig","cleanups","selectedKey","prompt_response","port","workerName","serverName","respond","isUrlAccept","params","onWaitingDismiss","selection","modelAlias","mainLoopModelForSession","replBridgeEnabled","replBridgeExplicit","replBridgeOutboundOnly","pluginName","pluginDescription","marketplaceName","sourceCommand","fileExtension","choice","blurb","appendStdout","appendWhenIdle","unsub","ultraplanSessionUrl","launchUltraplan","disconnectedBridge","onSessionReady","lastResponse","suggestion","isOpen","skillName","updates","feedback","direction","compactMessages","appState","defaultSysPrompt","forkContextMessages","kept","messagesToKeep","ordered","summaryMessages","postCompact","boundaryMarker","attachments","hookResults","historyShortcut"],"sources":["REPL.tsx"],"sourcesContent":["// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered\nimport { feature } from 'bun:bundle'\nimport { spawnSync } from 'child_process'\nimport {\n  snapshotOutputTokensForTurn,\n  getCurrentTurnTokenBudget,\n  getTurnOutputTokens,\n  getBudgetContinuationCount,\n  getTotalInputTokens,\n} from '../bootstrap/state.js'\nimport { parseTokenBudget } from '../utils/tokenBudget.js'\nimport { count } from '../utils/array.js'\nimport { dirname, join } from 'path'\nimport { tmpdir } from 'os'\nimport figures from 'figures'\n// 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\nimport { useInput } from '../ink.js'\nimport { useSearchInput } from '../hooks/useSearchInput.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { useSearchHighlight } from '../ink/hooks/use-search-highlight.js'\nimport type { JumpHandle } from '../components/VirtualMessageList.js'\nimport { renderMessagesToPlainText } from '../utils/exportRenderer.js'\nimport { openFileInExternalEditor } from '../utils/editor.js'\nimport { writeFile } from 'fs/promises'\nimport {\n  Box,\n  Text,\n  useStdin,\n  useTheme,\n  useTerminalFocus,\n  useTerminalTitle,\n  useTabStatus,\n} from '../ink.js'\nimport type { TabStatusKind } from '../ink/hooks/use-tab-status.js'\nimport { CostThresholdDialog } from '../components/CostThresholdDialog.js'\nimport { IdleReturnDialog } from '../components/IdleReturnDialog.js'\nimport * as React from 'react'\nimport {\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  useCallback,\n  useDeferredValue,\n  useLayoutEffect,\n  type RefObject,\n} from 'react'\nimport { useNotifications } from '../context/notifications.js'\nimport { sendNotification } from '../services/notifier.js'\nimport {\n  startPreventSleep,\n  stopPreventSleep,\n} from '../services/preventSleep.js'\nimport { useTerminalNotification } from '../ink/useTerminalNotification.js'\nimport { hasCursorUpViewportYankBug } from '../ink/terminal.js'\nimport {\n  createFileStateCacheWithSizeLimit,\n  mergeFileStateCaches,\n  READ_FILE_STATE_CACHE_SIZE,\n} from '../utils/fileStateCache.js'\nimport {\n  updateLastInteractionTime,\n  getLastInteractionTime,\n  getOriginalCwd,\n  getProjectRoot,\n  getSessionId,\n  switchSession,\n  setCostStateForRestore,\n  getTurnHookDurationMs,\n  getTurnHookCount,\n  resetTurnHookDuration,\n  getTurnToolDurationMs,\n  getTurnToolCount,\n  resetTurnToolDuration,\n  getTurnClassifierDurationMs,\n  getTurnClassifierCount,\n  resetTurnClassifierDuration,\n} from '../bootstrap/state.js'\nimport { asSessionId, asAgentId } from '../types/ids.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { QueryGuard } from '../utils/QueryGuard.js'\nimport { isEnvTruthy } from '../utils/envUtils.js'\nimport { formatTokens, truncateToWidth } from '../utils/format.js'\nimport { consumeEarlyInput } from '../utils/earlyInput.js'\n\nimport { setMemberActive } from '../utils/swarm/teamHelpers.js'\nimport {\n  isSwarmWorker,\n  generateSandboxRequestId,\n  sendSandboxPermissionRequestViaMailbox,\n  sendSandboxPermissionResponseViaMailbox,\n} from '../utils/swarm/permissionSync.js'\nimport { registerSandboxPermissionCallback } from '../hooks/useSwarmPermissionPoller.js'\nimport { getTeamName, getAgentName } from '../utils/teammate.js'\nimport { WorkerPendingPermission } from '../components/permissions/WorkerPendingPermission.js'\nimport {\n  injectUserMessageToTeammate,\n  getAllInProcessTeammateTasks,\n} from '../tasks/InProcessTeammateTask/InProcessTeammateTask.js'\nimport {\n  isLocalAgentTask,\n  queuePendingMessage,\n  appendMessageToLocalAgent,\n  type LocalAgentTaskState,\n} from '../tasks/LocalAgentTask/LocalAgentTask.js'\nimport {\n  registerLeaderToolUseConfirmQueue,\n  unregisterLeaderToolUseConfirmQueue,\n  registerLeaderSetToolPermissionContext,\n  unregisterLeaderSetToolPermissionContext,\n} from '../utils/swarm/leaderPermissionBridge.js'\nimport { endInteractionSpan } from '../utils/telemetry/sessionTracing.js'\nimport { useLogMessages } from '../hooks/useLogMessages.js'\nimport { useReplBridge } from '../hooks/useReplBridge.js'\nimport {\n  type Command,\n  type CommandResultDisplay,\n  type ResumeEntrypoint,\n  getCommandName,\n  isCommandEnabled,\n} from '../commands.js'\nimport type {\n  PromptInputMode,\n  QueuedCommand,\n  VimMode,\n} from '../types/textInputTypes.js'\nimport {\n  MessageSelector,\n  selectableUserMessagesFilter,\n  messagesAfterAreOnlySynthetic,\n} from '../components/MessageSelector.js'\nimport { useIdeLogging } from '../hooks/useIdeLogging.js'\nimport {\n  PermissionRequest,\n  type ToolUseConfirm,\n} from '../components/permissions/PermissionRequest.js'\nimport { ElicitationDialog } from '../components/mcp/ElicitationDialog.js'\nimport { PromptDialog } from '../components/hooks/PromptDialog.js'\nimport type { PromptRequest, PromptResponse } from '../types/hooks.js'\nimport PromptInput from '../components/PromptInput/PromptInput.js'\nimport { PromptInputQueuedCommands } from '../components/PromptInput/PromptInputQueuedCommands.js'\nimport { useRemoteSession } from '../hooks/useRemoteSession.js'\nimport { useDirectConnect } from '../hooks/useDirectConnect.js'\nimport type { DirectConnectConfig } from '../server/directConnectManager.js'\nimport { useSSHSession } from '../hooks/useSSHSession.js'\nimport { useAssistantHistory } from '../hooks/useAssistantHistory.js'\nimport type { SSHSession } from '../ssh/createSSHSession.js'\nimport { SkillImprovementSurvey } from '../components/SkillImprovementSurvey.js'\nimport { useSkillImprovementSurvey } from '../hooks/useSkillImprovementSurvey.js'\nimport { useMoreRight } from '../moreright/useMoreRight.js'\nimport {\n  SpinnerWithVerb,\n  BriefIdleStatus,\n  type SpinnerMode,\n} from '../components/Spinner.js'\nimport { getSystemPrompt } from '../constants/prompts.js'\nimport { buildEffectiveSystemPrompt } from '../utils/systemPrompt.js'\nimport { getSystemContext, getUserContext } from '../context.js'\nimport { getMemoryFiles } from '../utils/claudemd.js'\nimport { startBackgroundHousekeeping } from '../utils/backgroundHousekeeping.js'\nimport {\n  getTotalCost,\n  saveCurrentSessionCosts,\n  resetCostState,\n  getStoredSessionCosts,\n} from '../cost-tracker.js'\nimport { useCostSummary } from '../costHook.js'\nimport { useFpsMetrics } from '../context/fpsMetrics.js'\nimport { useAfterFirstRender } from '../hooks/useAfterFirstRender.js'\nimport { useDeferredHookMessages } from '../hooks/useDeferredHookMessages.js'\nimport {\n  addToHistory,\n  removeLastFromHistory,\n  expandPastedTextRefs,\n  parseReferences,\n} from '../history.js'\nimport { prependModeCharacterToInput } from '../components/PromptInput/inputModes.js'\nimport { prependToShellHistoryCache } from '../utils/suggestions/shellHistoryCompletion.js'\nimport { useApiKeyVerification } from '../hooks/useApiKeyVerification.js'\nimport { GlobalKeybindingHandlers } from '../hooks/useGlobalKeybindings.js'\nimport { CommandKeybindingHandlers } from '../hooks/useCommandKeybindings.js'\nimport { KeybindingSetup } from '../keybindings/KeybindingProviderSetup.js'\nimport { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js'\nimport { getShortcutDisplay } from '../keybindings/shortcutFormat.js'\nimport { CancelRequestHandler } from '../hooks/useCancelRequest.js'\nimport { useBackgroundTaskNavigation } from '../hooks/useBackgroundTaskNavigation.js'\nimport { useSwarmInitialization } from '../hooks/useSwarmInitialization.js'\nimport { useTeammateViewAutoExit } from '../hooks/useTeammateViewAutoExit.js'\nimport { errorMessage } from '../utils/errors.js'\nimport { isHumanTurn } from '../utils/messagePredicates.js'\nimport { logError } from '../utils/log.js'\n// Dead code elimination: conditional imports\n/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */\nconst useVoiceIntegration: typeof import('../hooks/useVoiceIntegration.js').useVoiceIntegration =\n  feature('VOICE_MODE')\n    ? require('../hooks/useVoiceIntegration.js').useVoiceIntegration\n    : () => ({\n        stripTrailing: () => 0,\n        handleKeyEvent: () => {},\n        resetAnchor: () => {},\n      })\nconst VoiceKeybindingHandler: typeof import('../hooks/useVoiceIntegration.js').VoiceKeybindingHandler =\n  feature('VOICE_MODE')\n    ? require('../hooks/useVoiceIntegration.js').VoiceKeybindingHandler\n    : () => null\n// Frustration detection is ant-only (dogfooding). Conditional require so external\n// builds eliminate the module entirely (including its two O(n) useMemos that run\n// on every messages change, plus the GrowthBook fetch).\nconst useFrustrationDetection: typeof import('../components/FeedbackSurvey/useFrustrationDetection.js').useFrustrationDetection =\n  \"external\" === 'ant'\n    ? require('../components/FeedbackSurvey/useFrustrationDetection.js')\n        .useFrustrationDetection\n    : () => ({ state: 'closed', handleTranscriptSelect: () => {} })\n// Ant-only org warning. Conditional require so the org UUID list is\n// eliminated from external builds (one UUID is on excluded-strings).\nconst useAntOrgWarningNotification: typeof import('../hooks/notifs/useAntOrgWarningNotification.js').useAntOrgWarningNotification =\n  \"external\" === 'ant'\n    ? require('../hooks/notifs/useAntOrgWarningNotification.js')\n        .useAntOrgWarningNotification\n    : () => {}\n// Dead code elimination: conditional import for coordinator mode\nconst getCoordinatorUserContext: (\n  mcpClients: ReadonlyArray<{ name: string }>,\n  scratchpadDir?: string,\n) => { [k: string]: string } = feature('COORDINATOR_MODE')\n  ? require('../coordinator/coordinatorMode.js').getCoordinatorUserContext\n  : () => ({})\n/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */\nimport useCanUseTool from '../hooks/useCanUseTool.js'\nimport type { ToolPermissionContext, Tool } from '../Tool.js'\nimport {\n  applyPermissionUpdate,\n  applyPermissionUpdates,\n  persistPermissionUpdate,\n} from '../utils/permissions/PermissionUpdate.js'\nimport { buildPermissionUpdates } from '../components/permissions/ExitPlanModePermissionRequest/ExitPlanModePermissionRequest.js'\nimport { stripDangerousPermissionsForAutoMode } from '../utils/permissions/permissionSetup.js'\nimport {\n  getScratchpadDir,\n  isScratchpadEnabled,\n} from '../utils/permissions/filesystem.js'\nimport { WEB_FETCH_TOOL_NAME } from '../tools/WebFetchTool/prompt.js'\nimport { SLEEP_TOOL_NAME } from '../tools/SleepTool/prompt.js'\nimport { clearSpeculativeChecks } from '../tools/BashTool/bashPermissions.js'\nimport type { AutoUpdaterResult } from '../utils/autoUpdater.js'\nimport {\n  getGlobalConfig,\n  saveGlobalConfig,\n  getGlobalConfigWriteCount,\n} from '../utils/config.js'\nimport { hasConsoleBillingAccess } from '../utils/billing.js'\nimport {\n  logEvent,\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n} from 'src/services/analytics/index.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js'\nimport {\n  textForResubmit,\n  handleMessageFromStream,\n  type StreamingToolUse,\n  type StreamingThinking,\n  isCompactBoundaryMessage,\n  getMessagesAfterCompactBoundary,\n  getContentText,\n  createUserMessage,\n  createAssistantMessage,\n  createTurnDurationMessage,\n  createAgentsKilledMessage,\n  createApiMetricsMessage,\n  createSystemMessage,\n  createCommandInputMessage,\n  formatCommandInputTags,\n} from '../utils/messages.js'\nimport { generateSessionTitle } from '../utils/sessionTitle.js'\nimport {\n  BASH_INPUT_TAG,\n  COMMAND_MESSAGE_TAG,\n  COMMAND_NAME_TAG,\n  LOCAL_COMMAND_STDOUT_TAG,\n} from '../constants/xml.js'\nimport { escapeXml } from '../utils/xml.js'\nimport type { ThinkingConfig } from '../utils/thinking.js'\nimport { gracefulShutdownSync } from '../utils/gracefulShutdown.js'\nimport {\n  handlePromptSubmit,\n  type PromptInputHelpers,\n} from '../utils/handlePromptSubmit.js'\nimport { useQueueProcessor } from '../hooks/useQueueProcessor.js'\nimport { useMailboxBridge } from '../hooks/useMailboxBridge.js'\nimport {\n  queryCheckpoint,\n  logQueryProfileReport,\n} from '../utils/queryProfiler.js'\nimport type {\n  Message as MessageType,\n  UserMessage,\n  ProgressMessage,\n  HookResultMessage,\n  PartialCompactDirection,\n} from '../types/message.js'\nimport { query } from '../query.js'\nimport { mergeClients, useMergedClients } from '../hooks/useMergedClients.js'\nimport { getQuerySourceForREPL } from '../utils/promptCategory.js'\nimport { useMergedTools } from '../hooks/useMergedTools.js'\nimport { mergeAndFilterTools } from '../utils/toolPool.js'\nimport { useMergedCommands } from '../hooks/useMergedCommands.js'\nimport { useSkillsChange } from '../hooks/useSkillsChange.js'\nimport { useManagePlugins } from '../hooks/useManagePlugins.js'\nimport { Messages } from '../components/Messages.js'\nimport { TaskListV2 } from '../components/TaskListV2.js'\nimport { TeammateViewHeader } from '../components/TeammateViewHeader.js'\nimport { useTasksV2WithCollapseEffect } from '../hooks/useTasksV2.js'\nimport { maybeMarkProjectOnboardingComplete } from '../projectOnboardingState.js'\nimport type { MCPServerConnection } from '../services/mcp/types.js'\nimport type { ScopedMcpServerConfig } from '../services/mcp/types.js'\nimport { randomUUID, type UUID } from 'crypto'\nimport { processSessionStartHooks } from '../utils/sessionStart.js'\nimport {\n  executeSessionEndHooks,\n  getSessionEndHookTimeoutMs,\n} from '../utils/hooks.js'\nimport { type IDESelection, useIdeSelection } from '../hooks/useIdeSelection.js'\nimport { getTools, assembleToolPool } from '../tools.js'\nimport type { AgentDefinition } from '../tools/AgentTool/loadAgentsDir.js'\nimport { resolveAgentTools } from '../tools/AgentTool/agentToolUtils.js'\nimport { resumeAgentBackground } from '../tools/AgentTool/resumeAgent.js'\nimport { useMainLoopModel } from '../hooks/useMainLoopModel.js'\nimport {\n  useAppState,\n  useSetAppState,\n  useAppStateStore,\n} from '../state/AppState.js'\nimport type {\n  ContentBlockParam,\n  ImageBlockParam,\n} from '@anthropic-ai/sdk/resources/messages.mjs'\nimport type { ProcessUserInputContext } from '../utils/processUserInput/processUserInput.js'\nimport type { PastedContent } from '../utils/config.js'\nimport {\n  copyPlanForFork,\n  copyPlanForResume,\n  getPlanSlug,\n  setPlanSlug,\n} from '../utils/plans.js'\nimport {\n  clearSessionMetadata,\n  resetSessionFilePointer,\n  adoptResumedSessionFile,\n  removeTranscriptMessage,\n  restoreSessionMetadata,\n  getCurrentSessionTitle,\n  isEphemeralToolProgress,\n  isLoggableMessage,\n  saveWorktreeState,\n  getAgentTranscript,\n} from '../utils/sessionStorage.js'\nimport { deserializeMessages } from '../utils/conversationRecovery.js'\nimport {\n  extractReadFilesFromMessages,\n  extractBashToolsFromMessages,\n} from '../utils/queryHelpers.js'\nimport { resetMicrocompactState } from '../services/compact/microCompact.js'\nimport { runPostCompactCleanup } from '../services/compact/postCompactCleanup.js'\nimport {\n  provisionContentReplacementState,\n  reconstructContentReplacementState,\n  type ContentReplacementRecord,\n} from '../utils/toolResultStorage.js'\nimport { partialCompactConversation } from '../services/compact/compact.js'\nimport type { LogOption } from '../types/logs.js'\nimport type { AgentColorName } from '../tools/AgentTool/agentColorManager.js'\nimport {\n  fileHistoryMakeSnapshot,\n  type FileHistoryState,\n  fileHistoryRewind,\n  type FileHistorySnapshot,\n  copyFileHistoryForResume,\n  fileHistoryEnabled,\n  fileHistoryHasAnyChanges,\n} from '../utils/fileHistory.js'\nimport {\n  type AttributionState,\n  incrementPromptCount,\n} from '../utils/commitAttribution.js'\nimport { recordAttributionSnapshot } from '../utils/sessionStorage.js'\nimport {\n  computeStandaloneAgentContext,\n  restoreAgentFromSession,\n  restoreSessionStateFromLog,\n  restoreWorktreeForResume,\n  exitRestoredWorktree,\n} from '../utils/sessionRestore.js'\nimport {\n  isBgSession,\n  updateSessionName,\n  updateSessionActivity,\n} from '../utils/concurrentSessions.js'\nimport {\n  isInProcessTeammateTask,\n  type InProcessTeammateTaskState,\n} from '../tasks/InProcessTeammateTask/types.js'\nimport { restoreRemoteAgentTasks } from '../tasks/RemoteAgentTask/RemoteAgentTask.js'\nimport { useInboxPoller } from '../hooks/useInboxPoller.js'\n// Dead code elimination: conditional import for loop mode\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst proactiveModule =\n  feature('PROACTIVE') || feature('KAIROS')\n    ? require('../proactive/index.js')\n    : null\nconst PROACTIVE_NO_OP_SUBSCRIBE = (_cb: () => void) => () => {}\nconst PROACTIVE_FALSE = () => false\nconst SUGGEST_BG_PR_NOOP = (_p: string, _n: string): boolean => false\nconst useProactive =\n  feature('PROACTIVE') || feature('KAIROS')\n    ? require('../proactive/useProactive.js').useProactive\n    : null\nconst useScheduledTasks = feature('AGENT_TRIGGERS')\n  ? require('../hooks/useScheduledTasks.js').useScheduledTasks\n  : null\n/* eslint-enable @typescript-eslint/no-require-imports */\nimport { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js'\nimport { useTaskListWatcher } from '../hooks/useTaskListWatcher.js'\nimport type {\n  SandboxAskCallback,\n  NetworkHostPattern,\n} from '../utils/sandbox/sandbox-adapter.js'\n\nimport {\n  type IDEExtensionInstallationStatus,\n  closeOpenDiffs,\n  getConnectedIdeClient,\n  type IdeType,\n} from '../utils/ide.js'\nimport { useIDEIntegration } from '../hooks/useIDEIntegration.js'\nimport exit from '../commands/exit/index.js'\nimport { ExitFlow } from '../components/ExitFlow.js'\nimport { getCurrentWorktreeSession } from '../utils/worktree.js'\nimport {\n  popAllEditable,\n  enqueue,\n  type SetAppState,\n  getCommandQueue,\n  getCommandQueueLength,\n  removeByFilter,\n} from '../utils/messageQueueManager.js'\nimport { useCommandQueue } from '../hooks/useCommandQueue.js'\nimport { SessionBackgroundHint } from '../components/SessionBackgroundHint.js'\nimport { startBackgroundSession } from '../tasks/LocalMainSessionTask.js'\nimport { useSessionBackgrounding } from '../hooks/useSessionBackgrounding.js'\nimport { diagnosticTracker } from '../services/diagnosticTracking.js'\nimport {\n  handleSpeculationAccept,\n  type ActiveSpeculationState,\n} from '../services/PromptSuggestion/speculation.js'\nimport { IdeOnboardingDialog } from '../components/IdeOnboardingDialog.js'\nimport {\n  EffortCallout,\n  shouldShowEffortCallout,\n} from '../components/EffortCallout.js'\nimport type { EffortValue } from '../utils/effort.js'\nimport { RemoteCallout } from '../components/RemoteCallout.js'\n/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */\nconst AntModelSwitchCallout =\n  \"external\" === 'ant'\n    ? require('../components/AntModelSwitchCallout.js').AntModelSwitchCallout\n    : null\nconst shouldShowAntModelSwitch =\n  \"external\" === 'ant'\n    ? require('../components/AntModelSwitchCallout.js')\n        .shouldShowModelSwitchCallout\n    : (): boolean => false\nconst UndercoverAutoCallout =\n  \"external\" === 'ant'\n    ? require('../components/UndercoverAutoCallout.js').UndercoverAutoCallout\n    : null\n/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */\nimport { activityManager } from '../utils/activityManager.js'\nimport { createAbortController } from '../utils/abortController.js'\nimport { MCPConnectionManager } from 'src/services/mcp/MCPConnectionManager.js'\nimport { useFeedbackSurvey } from 'src/components/FeedbackSurvey/useFeedbackSurvey.js'\nimport { useMemorySurvey } from 'src/components/FeedbackSurvey/useMemorySurvey.js'\nimport { usePostCompactSurvey } from 'src/components/FeedbackSurvey/usePostCompactSurvey.js'\nimport { FeedbackSurvey } from 'src/components/FeedbackSurvey/FeedbackSurvey.js'\nimport { useInstallMessages } from 'src/hooks/notifs/useInstallMessages.js'\nimport { useAwaySummary } from 'src/hooks/useAwaySummary.js'\nimport { useChromeExtensionNotification } from 'src/hooks/useChromeExtensionNotification.js'\nimport { useOfficialMarketplaceNotification } from 'src/hooks/useOfficialMarketplaceNotification.js'\nimport { usePromptsFromClaudeInChrome } from 'src/hooks/usePromptsFromClaudeInChrome.js'\nimport {\n  getTipToShowOnSpinner,\n  recordShownTip,\n} from 'src/services/tips/tipScheduler.js'\nimport type { Theme } from 'src/utils/theme.js'\nimport {\n  checkAndDisableBypassPermissionsIfNeeded,\n  checkAndDisableAutoModeIfNeeded,\n  useKickOffCheckAndDisableBypassPermissionsIfNeeded,\n  useKickOffCheckAndDisableAutoModeIfNeeded,\n} from 'src/utils/permissions/bypassPermissionsKillswitch.js'\nimport { SandboxManager } from 'src/utils/sandbox/sandbox-adapter.js'\nimport { SANDBOX_NETWORK_ACCESS_TOOL_NAME } from 'src/cli/structuredIO.js'\nimport { useFileHistorySnapshotInit } from 'src/hooks/useFileHistorySnapshotInit.js'\nimport { SandboxPermissionRequest } from 'src/components/permissions/SandboxPermissionRequest.js'\nimport { SandboxViolationExpandedView } from 'src/components/SandboxViolationExpandedView.js'\nimport { useSettingsErrors } from 'src/hooks/notifs/useSettingsErrors.js'\nimport { useMcpConnectivityStatus } from 'src/hooks/notifs/useMcpConnectivityStatus.js'\nimport { useAutoModeUnavailableNotification } from 'src/hooks/notifs/useAutoModeUnavailableNotification.js'\nimport { AUTO_MODE_DESCRIPTION } from 'src/components/AutoModeOptInDialog.js'\nimport { useLspInitializationNotification } from 'src/hooks/notifs/useLspInitializationNotification.js'\nimport { useLspPluginRecommendation } from 'src/hooks/useLspPluginRecommendation.js'\nimport { LspRecommendationMenu } from 'src/components/LspRecommendation/LspRecommendationMenu.js'\nimport { useClaudeCodeHintRecommendation } from 'src/hooks/useClaudeCodeHintRecommendation.js'\nimport { PluginHintMenu } from 'src/components/ClaudeCodeHint/PluginHintMenu.js'\nimport {\n  DesktopUpsellStartup,\n  shouldShowDesktopUpsellStartup,\n} from 'src/components/DesktopUpsell/DesktopUpsellStartup.js'\nimport { usePluginInstallationStatus } from 'src/hooks/notifs/usePluginInstallationStatus.js'\nimport { usePluginAutoupdateNotification } from 'src/hooks/notifs/usePluginAutoupdateNotification.js'\nimport { performStartupChecks } from 'src/utils/plugins/performStartupChecks.js'\nimport { UserTextMessage } from 'src/components/messages/UserTextMessage.js'\nimport { AwsAuthStatusBox } from '../components/AwsAuthStatusBox.js'\nimport { useRateLimitWarningNotification } from 'src/hooks/notifs/useRateLimitWarningNotification.js'\nimport { useDeprecationWarningNotification } from 'src/hooks/notifs/useDeprecationWarningNotification.js'\nimport { useNpmDeprecationNotification } from 'src/hooks/notifs/useNpmDeprecationNotification.js'\nimport { useIDEStatusIndicator } from 'src/hooks/notifs/useIDEStatusIndicator.js'\nimport { useModelMigrationNotifications } from 'src/hooks/notifs/useModelMigrationNotifications.js'\nimport { useCanSwitchToExistingSubscription } from 'src/hooks/notifs/useCanSwitchToExistingSubscription.js'\nimport { useTeammateLifecycleNotification } from 'src/hooks/notifs/useTeammateShutdownNotification.js'\nimport { useFastModeNotification } from 'src/hooks/notifs/useFastModeNotification.js'\nimport {\n  AutoRunIssueNotification,\n  shouldAutoRunIssue,\n  getAutoRunIssueReasonText,\n  getAutoRunCommand,\n  type AutoRunIssueReason,\n} from '../utils/autoRunIssue.js'\nimport type { HookProgress } from '../types/hooks.js'\nimport { TungstenLiveMonitor } from '../tools/TungstenTool/TungstenLiveMonitor.js'\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst WebBrowserPanelModule = feature('WEB_BROWSER_TOOL')\n  ? (require('../tools/WebBrowserTool/WebBrowserPanel.js') as typeof import('../tools/WebBrowserTool/WebBrowserPanel.js'))\n  : null\n/* eslint-enable @typescript-eslint/no-require-imports */\nimport { IssueFlagBanner } from '../components/PromptInput/IssueFlagBanner.js'\nimport { useIssueFlagBanner } from '../hooks/useIssueFlagBanner.js'\nimport {\n  CompanionSprite,\n  CompanionFloatingBubble,\n  MIN_COLS_FOR_FULL_SPRITE,\n} from '../buddy/CompanionSprite.js'\nimport { DevBar } from '../components/DevBar.js'\n// Session manager removed - using AppState now\nimport type { RemoteSessionConfig } from '../remote/RemoteSessionManager.js'\nimport { REMOTE_SAFE_COMMANDS } from '../commands.js'\nimport type { RemoteMessageContent } from '../utils/teleport/api.js'\nimport {\n  FullscreenLayout,\n  useUnseenDivider,\n  computeUnseenDivider,\n} from '../components/FullscreenLayout.js'\nimport {\n  isFullscreenEnvEnabled,\n  maybeGetTmuxMouseHint,\n  isMouseTrackingEnabled,\n} from '../utils/fullscreen.js'\nimport { AlternateScreen } from '../ink/components/AlternateScreen.js'\nimport { ScrollKeybindingHandler } from '../components/ScrollKeybindingHandler.js'\nimport {\n  useMessageActions,\n  MessageActionsKeybindings,\n  MessageActionsBar,\n  type MessageActionsState,\n  type MessageActionsNav,\n  type MessageActionCaps,\n} from '../components/messageActions.js'\nimport { setClipboard } from '../ink/termio/osc.js'\nimport type { ScrollBoxHandle } from '../ink/components/ScrollBox.js'\nimport {\n  createAttachmentMessage,\n  getQueuedCommandAttachments,\n} from '../utils/attachments.js'\n\n// Stable empty array for hooks that accept MCPServerConnection[] — avoids\n// creating a new [] literal on every render in remote mode, which would\n// cause useEffect dependency changes and infinite re-render loops.\nconst EMPTY_MCP_CLIENTS: MCPServerConnection[] = []\n\n// Stable stub for useAssistantHistory's non-KAIROS branch — avoids a new\n// function identity each render, which would break composedOnScroll's memo.\nconst HISTORY_STUB = { maybeLoadOlder: (_: ScrollBoxHandle) => {} }\n// Window after a user-initiated scroll during which type-into-empty does NOT\n// repin to bottom. Josh Rosen's workflow: Claude emits long output → scroll\n// up to read the start → start typing → before this fix, snapped to bottom.\n// https://anthropic.slack.com/archives/C07VBSHV7EV/p1773545449871739\nconst RECENT_SCROLL_REPIN_WINDOW_MS = 3000\n\n// Use LRU cache to prevent unbounded memory growth\n// 100 files should be sufficient for most coding sessions while preventing\n// memory issues when working across many files in large projects\n\nfunction median(values: number[]): number {\n  const sorted = [...values].sort((a, b) => a - b)\n  const mid = Math.floor(sorted.length / 2)\n  return sorted.length % 2 === 0\n    ? Math.round((sorted[mid - 1]! + sorted[mid]!) / 2)\n    : sorted[mid]!\n}\n\n/**\n * Small component to display transcript mode footer with dynamic keybinding.\n * Must be rendered inside KeybindingSetup to access keybinding context.\n */\nfunction TranscriptModeFooter({\n  showAllInTranscript,\n  virtualScroll,\n  searchBadge,\n  suppressShowAll = false,\n  status,\n}: {\n  showAllInTranscript: boolean\n  virtualScroll: boolean\n  /** Minimap while navigating a closed-bar search. Shows n/N hints +\n   *  right-aligned count instead of scroll hints. */\n  searchBadge?: { current: number; count: number }\n  /** Hide the ctrl+e hint. The [ dump path shares this footer with\n   *  env-opted dump (CLAUDE_CODE_NO_FLICKER=0 / DISABLE_VIRTUAL_SCROLL=1),\n   *  but ctrl+e only works in the env case — useGlobalKeybindings.tsx\n   *  gates on !virtualScrollActive which is env-derived, doesn't know\n   *  [ happened. */\n  suppressShowAll?: boolean\n  /** Transient status (v-for-editor progress). Notifications render inside\n   *  PromptInput which isn't mounted in transcript — addNotification queues\n   *  but nothing draws it. */\n  status?: string\n}): React.ReactNode {\n  const toggleShortcut = useShortcutDisplay(\n    'app:toggleTranscript',\n    'Global',\n    'ctrl+o',\n  )\n  const showAllShortcut = useShortcutDisplay(\n    'transcript:toggleShowAll',\n    'Transcript',\n    'ctrl+e',\n  )\n  return (\n    <Box\n      noSelect\n      alignItems=\"center\"\n      alignSelf=\"center\"\n      borderTopDimColor\n      borderBottom={false}\n      borderLeft={false}\n      borderRight={false}\n      borderStyle=\"single\"\n      marginTop={1}\n      paddingLeft={2}\n      width=\"100%\"\n    >\n      <Text dimColor>\n        Showing detailed transcript · {toggleShortcut} to toggle\n        {searchBadge\n          ? ' · n/N to navigate'\n          : virtualScroll\n            ? ` · ${figures.arrowUp}${figures.arrowDown} scroll · home/end top/bottom`\n            : suppressShowAll\n              ? ''\n              : ` · ${showAllShortcut} to ${showAllInTranscript ? 'collapse' : 'show all'}`}\n      </Text>\n      {status ? (\n        // v-for-editor render progress — transient, preempts the search\n        // badge since the user just pressed v and wants to see what's\n        // happening. Clears after 4s.\n        <>\n          <Box flexGrow={1} />\n          <Text>{status} </Text>\n        </>\n      ) : searchBadge ? (\n        // Engine-counted — close enough for a rough location hint. May\n        // drift from render-count for ghost/phantom messages.\n        <>\n          <Box flexGrow={1} />\n          <Text dimColor>\n            {searchBadge.current}/{searchBadge.count}\n            {'  '}\n          </Text>\n        </>\n      ) : null}\n    </Box>\n  )\n}\n\n/** less-style / bar. 1-row, same border-top styling as TranscriptModeFooter\n *  so swapping them in the bottom slot doesn't shift ScrollBox height.\n *  useSearchInput handles readline editing; we report query changes and\n *  render the counter. Incremental — re-search + highlight per keystroke. */\nfunction TranscriptSearchBar({\n  jumpRef,\n  count,\n  current,\n  onClose,\n  onCancel,\n  setHighlight,\n  initialQuery,\n}: {\n  jumpRef: RefObject<JumpHandle | null>\n  count: number\n  current: number\n  /** Enter — commit. Query persists for n/N. */\n  onClose: (lastQuery: string) => void\n  /** Esc/ctrl+c/ctrl+g — undo to pre-/ state. */\n  onCancel: () => void\n  setHighlight: (query: string) => void\n  // Seed with the previous query (less: / shows last pattern). Mount-fire\n  // of the effect re-scans with the same query — idempotent (same matches,\n  // nearest-ptr, same highlights). User can edit or clear.\n  initialQuery: string\n}): React.ReactNode {\n  const { query, cursorOffset } = useSearchInput({\n    isActive: true,\n    initialQuery,\n    onExit: () => onClose(query),\n    onCancel,\n  })\n  // Index warm-up runs before the query effect so it measures the real\n  // cost — otherwise setSearchQuery fills the cache first and warm\n  // reports ~0ms while the user felt the actual lag.\n  // First / in a transcript session pays the extractSearchText cost.\n  // Subsequent / return 0 immediately (indexWarmed ref in VML).\n  // Transcript is frozen at ctrl+o so the cache stays valid.\n  // Initial 'building' so warmDone is false on mount — the [query] effect\n  // waits for the warm effect's first resolve instead of racing it. With\n  // null initial, warmDone would be true on mount → [query] fires →\n  // setSearchQuery fills cache → warm reports ~0ms while the user felt\n  // the real lag.\n  const [indexStatus, setIndexStatus] = React.useState<\n    'building' | { ms: number } | null\n  >('building')\n  React.useEffect(() => {\n    let alive = true\n    const warm = jumpRef.current?.warmSearchIndex\n    if (!warm) {\n      setIndexStatus(null) // VML not mounted yet — rare, skip indicator\n      return\n    }\n    setIndexStatus('building')\n    warm().then(ms => {\n      if (!alive) return\n      // <20ms = imperceptible. No point showing \"indexed in 3ms\".\n      if (ms < 20) {\n        setIndexStatus(null)\n      } else {\n        setIndexStatus({ ms })\n        setTimeout(() => alive && setIndexStatus(null), 2000)\n      }\n    })\n    return () => {\n      alive = false\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []) // mount-only: bar opens once per /\n  // Gate the query effect on warm completion. setHighlight stays instant\n  // (screen-space overlay, no indexing). setSearchQuery (the scan) waits.\n  const warmDone = indexStatus !== 'building'\n  useEffect(() => {\n    if (!warmDone) return\n    jumpRef.current?.setSearchQuery(query)\n    setHighlight(query)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [query, warmDone])\n  const off = cursorOffset\n  const cursorChar = off < query.length ? query[off] : ' '\n  return (\n    <Box\n      borderTopDimColor\n      borderBottom={false}\n      borderLeft={false}\n      borderRight={false}\n      borderStyle=\"single\"\n      marginTop={1}\n      paddingLeft={2}\n      width=\"100%\"\n      // applySearchHighlight scans the whole screen buffer. The query\n      // text rendered here IS on screen — /foo matches its own 'foo' in\n      // the bar. With no content matches that's the ONLY visible match →\n      // gets CURRENT → underlined. noSelect makes searchHighlight.ts:76\n      // skip these cells (same exclusion as gutters). You can't text-\n      // select the bar either; it's transient chrome, fine.\n      noSelect\n    >\n      <Text>/</Text>\n      <Text>{query.slice(0, off)}</Text>\n      <Text inverse>{cursorChar}</Text>\n      {off < query.length && <Text>{query.slice(off + 1)}</Text>}\n      <Box flexGrow={1} />\n      {indexStatus === 'building' ? (\n        <Text dimColor>indexing… </Text>\n      ) : indexStatus ? (\n        <Text dimColor>indexed in {indexStatus.ms}ms </Text>\n      ) : count === 0 && query ? (\n        <Text color=\"error\">no matches </Text>\n      ) : count > 0 ? (\n        // Engine-counted (indexOf on extractSearchText). May drift from\n        // render-count for ghost/phantom messages — badge is a rough\n        // location hint. scanElement gives exact per-message positions\n        // but counting ALL would cost ~1-3ms × matched-messages.\n        <Text dimColor>\n          {current}/{count}\n          {'  '}\n        </Text>\n      ) : null}\n    </Box>\n  )\n}\n\nconst TITLE_ANIMATION_FRAMES = ['⠂', '⠐']\nconst TITLE_STATIC_PREFIX = '✳'\nconst TITLE_ANIMATION_INTERVAL_MS = 960\n\n/**\n * Sets the terminal tab title, with an animated prefix glyph while a query\n * is running. Isolated from REPL so the 960ms animation tick re-renders only\n * this leaf component (which returns null — pure side-effect) instead of the\n * entire REPL tree. Before extraction, the tick was ~1 REPL render/sec for\n * the duration of every turn, dragging PromptInput and friends along.\n */\nfunction AnimatedTerminalTitle({\n  isAnimating,\n  title,\n  disabled,\n  noPrefix,\n}: {\n  isAnimating: boolean\n  title: string\n  disabled: boolean\n  noPrefix: boolean\n}): null {\n  const terminalFocused = useTerminalFocus()\n  const [frame, setFrame] = useState(0)\n  useEffect(() => {\n    if (disabled || noPrefix || !isAnimating || !terminalFocused) return\n    const interval = setInterval(\n      setFrame => setFrame(f => (f + 1) % TITLE_ANIMATION_FRAMES.length),\n      TITLE_ANIMATION_INTERVAL_MS,\n      setFrame,\n    )\n    return () => clearInterval(interval)\n  }, [disabled, noPrefix, isAnimating, terminalFocused])\n  const prefix = isAnimating\n    ? (TITLE_ANIMATION_FRAMES[frame] ?? TITLE_STATIC_PREFIX)\n    : TITLE_STATIC_PREFIX\n  useTerminalTitle(disabled ? null : noPrefix ? title : `${prefix} ${title}`)\n  return null\n}\n\nexport type Props = {\n  commands: Command[]\n  debug: boolean\n  initialTools: Tool[]\n  // Initial messages to populate the REPL with\n  initialMessages?: MessageType[]\n  // Deferred hook messages promise — REPL renders immediately and injects\n  // hook messages when they resolve. Awaited before the first API call.\n  pendingHookMessages?: Promise<HookResultMessage[]>\n  initialFileHistorySnapshots?: FileHistorySnapshot[]\n  // Content-replacement records from a resumed session's transcript — used to\n  // reconstruct contentReplacementState so the same results are re-replaced\n  initialContentReplacements?: ContentReplacementRecord[]\n  // Initial agent context for session resume (name/color set via /rename or /color)\n  initialAgentName?: string\n  initialAgentColor?: AgentColorName\n  mcpClients?: MCPServerConnection[]\n  dynamicMcpConfig?: Record<string, ScopedMcpServerConfig>\n  autoConnectIdeFlag?: boolean\n  strictMcpConfig?: boolean\n  systemPrompt?: string\n  appendSystemPrompt?: string\n  // Optional callback invoked before query execution\n  // Called after user message is added to conversation but before API call\n  // Return false to prevent query execution\n  onBeforeQuery?: (\n    input: string,\n    newMessages: MessageType[],\n  ) => Promise<boolean>\n  // Optional callback when a turn completes (model finishes responding)\n  onTurnComplete?: (messages: MessageType[]) => void | Promise<void>\n  // When true, disables REPL input (hides prompt and prevents message selector)\n  disabled?: boolean\n  // Optional agent definition to use for the main thread\n  mainThreadAgentDefinition?: AgentDefinition\n  // When true, disables all slash commands\n  disableSlashCommands?: boolean\n  // Task list id: when set, enables tasks mode that watches a task list and auto-processes tasks.\n  taskListId?: string\n  // Remote session config for --remote mode (uses CCR as execution engine)\n  remoteSessionConfig?: RemoteSessionConfig\n  // Direct connect config for `claude connect` mode (connects to a claude server)\n  directConnectConfig?: DirectConnectConfig\n  // SSH session for `claude ssh` mode (local REPL, remote tools over ssh)\n  sshSession?: SSHSession\n  // Thinking configuration to use when thinking is enabled\n  thinkingConfig: ThinkingConfig\n}\n\nexport type Screen = 'prompt' | 'transcript'\n\nexport function REPL({\n  commands: initialCommands,\n  debug,\n  initialTools,\n  initialMessages,\n  pendingHookMessages,\n  initialFileHistorySnapshots,\n  initialContentReplacements,\n  initialAgentName,\n  initialAgentColor,\n  mcpClients: initialMcpClients,\n  dynamicMcpConfig: initialDynamicMcpConfig,\n  autoConnectIdeFlag,\n  strictMcpConfig = false,\n  systemPrompt: customSystemPrompt,\n  appendSystemPrompt,\n  onBeforeQuery,\n  onTurnComplete,\n  disabled = false,\n  mainThreadAgentDefinition: initialMainThreadAgentDefinition,\n  disableSlashCommands = false,\n  taskListId,\n  remoteSessionConfig,\n  directConnectConfig,\n  sshSession,\n  thinkingConfig,\n}: Props): React.ReactNode {\n  const isRemoteSession = !!remoteSessionConfig\n\n  // Env-var gates hoisted to mount-time — isEnvTruthy does toLowerCase+trim+\n  // includes, and these were on the render path (hot during PageUp spam).\n  const titleDisabled = useMemo(\n    () => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_TERMINAL_TITLE),\n    [],\n  )\n  const moreRightEnabled = useMemo(\n    () =>\n      \"external\" === 'ant' &&\n      isEnvTruthy(process.env.CLAUDE_MORERIGHT),\n    [],\n  )\n  const disableVirtualScroll = useMemo(\n    () => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_VIRTUAL_SCROLL),\n    [],\n  )\n  const disableMessageActions = feature('MESSAGE_ACTIONS')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useMemo(\n        () => isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_MESSAGE_ACTIONS),\n        [],\n      )\n    : false\n\n  // Log REPL mount/unmount lifecycle\n  useEffect(() => {\n    logForDebugging(`[REPL:mount] REPL mounted, disabled=${disabled}`)\n    return () => logForDebugging(`[REPL:unmount] REPL unmounting`)\n  }, [disabled])\n\n  // Agent definition is state so /resume can update it mid-session\n  const [mainThreadAgentDefinition, setMainThreadAgentDefinition] = useState(\n    initialMainThreadAgentDefinition,\n  )\n\n  const toolPermissionContext = useAppState(s => s.toolPermissionContext)\n  const verbose = useAppState(s => s.verbose)\n  const mcp = useAppState(s => s.mcp)\n  const plugins = useAppState(s => s.plugins)\n  const agentDefinitions = useAppState(s => s.agentDefinitions)\n  const fileHistory = useAppState(s => s.fileHistory)\n  const initialMessage = useAppState(s => s.initialMessage)\n  const queuedCommands = useCommandQueue()\n  // feature() is a build-time constant — dead code elimination removes the hook\n  // call entirely in external builds, so this is safe despite looking conditional.\n  // These fields contain excluded strings that must not appear in external builds.\n  const spinnerTip = useAppState(s => s.spinnerTip)\n  const showExpandedTodos = useAppState(s => s.expandedView) === 'tasks'\n  const pendingWorkerRequest = useAppState(s => s.pendingWorkerRequest)\n  const pendingSandboxRequest = useAppState(s => s.pendingSandboxRequest)\n  const teamContext = useAppState(s => s.teamContext)\n  const tasks = useAppState(s => s.tasks)\n  const workerSandboxPermissions = useAppState(s => s.workerSandboxPermissions)\n  const elicitation = useAppState(s => s.elicitation)\n  const ultraplanPendingChoice = useAppState(s => s.ultraplanPendingChoice)\n  const ultraplanLaunchPending = useAppState(s => s.ultraplanLaunchPending)\n  const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId)\n  const setAppState = useSetAppState()\n\n  // Bootstrap: retained local_agent that hasn't loaded disk yet → read\n  // sidechain JSONL and UUID-merge with whatever stream has appended so far.\n  // Stream appends immediately on retain (no defer); bootstrap fills the\n  // prefix. Disk-write-before-yield means live is always a suffix of disk.\n  const viewedLocalAgent = viewingAgentTaskId\n    ? tasks[viewingAgentTaskId]\n    : undefined\n  const needsBootstrap =\n    isLocalAgentTask(viewedLocalAgent) &&\n    viewedLocalAgent.retain &&\n    !viewedLocalAgent.diskLoaded\n  useEffect(() => {\n    if (!viewingAgentTaskId || !needsBootstrap) return\n    const taskId = viewingAgentTaskId\n    void getAgentTranscript(asAgentId(taskId)).then(result => {\n      setAppState(prev => {\n        const t = prev.tasks[taskId]\n        if (!isLocalAgentTask(t) || t.diskLoaded || !t.retain) return prev\n        const live = t.messages ?? []\n        const liveUuids = new Set(live.map(m => m.uuid))\n        const diskOnly = result\n          ? result.messages.filter(m => !liveUuids.has(m.uuid))\n          : []\n        return {\n          ...prev,\n          tasks: {\n            ...prev.tasks,\n            [taskId]: {\n              ...t,\n              messages: [...diskOnly, ...live],\n              diskLoaded: true,\n            },\n          },\n        }\n      })\n    })\n  }, [viewingAgentTaskId, needsBootstrap, setAppState])\n\n  const store = useAppStateStore()\n  const terminal = useTerminalNotification()\n  const mainLoopModel = useMainLoopModel()\n\n  // Note: standaloneAgentContext is initialized in main.tsx (via initialState) or\n  // ResumeConversation.tsx (via setAppState before rendering REPL) to avoid\n  // useEffect-based state initialization on mount (per CLAUDE.md guidelines)\n\n  // Local state for commands (hot-reloadable when skill files change)\n  const [localCommands, setLocalCommands] = useState(initialCommands)\n\n  // Watch for skill file changes and reload all commands\n  useSkillsChange(\n    isRemoteSession ? undefined : getProjectRoot(),\n    setLocalCommands,\n  )\n\n  // Track proactive mode for tools dependency - SleepTool filters by proactive state\n  const proactiveActive = React.useSyncExternalStore(\n    proactiveModule?.subscribeToProactiveChanges ?? PROACTIVE_NO_OP_SUBSCRIBE,\n    proactiveModule?.isProactiveActive ?? PROACTIVE_FALSE,\n  )\n\n  // BriefTool.isEnabled() reads getUserMsgOptIn() from bootstrap state, which\n  // /brief flips mid-session alongside isBriefOnly. The memo below needs a\n  // React-visible dep to re-run getTools() when that happens; isBriefOnly is\n  // the AppState mirror that triggers the re-render. Without this, toggling\n  // /brief mid-session leaves the stale tool list (no SendUserMessage) and\n  // the model emits plain text the brief filter hides.\n  const isBriefOnly = useAppState(s => s.isBriefOnly)\n\n  const localTools = useMemo(\n    () => getTools(toolPermissionContext),\n    [toolPermissionContext, proactiveActive, isBriefOnly],\n  )\n\n  useKickOffCheckAndDisableBypassPermissionsIfNeeded()\n  useKickOffCheckAndDisableAutoModeIfNeeded()\n\n  const [dynamicMcpConfig, setDynamicMcpConfig] = useState<\n    Record<string, ScopedMcpServerConfig> | undefined\n  >(initialDynamicMcpConfig)\n\n  const onChangeDynamicMcpConfig = useCallback(\n    (config: Record<string, ScopedMcpServerConfig>) => {\n      setDynamicMcpConfig(config)\n    },\n    [setDynamicMcpConfig],\n  )\n\n  const [screen, setScreen] = useState<Screen>('prompt')\n  const [showAllInTranscript, setShowAllInTranscript] = useState(false)\n  // [ forces the dump-to-scrollback path inside transcript mode. Separate\n  // from CLAUDE_CODE_NO_FLICKER=0 (which is process-lifetime) — this is\n  // ephemeral, reset on transcript exit. Diagnostic escape hatch so\n  // terminal/tmux native cmd-F can search the full flat render.\n  const [dumpMode, setDumpMode] = useState(false)\n  // v-for-editor render progress. Inline in the footer — notifications\n  // render inside PromptInput which isn't mounted in transcript.\n  const [editorStatus, setEditorStatus] = useState('')\n  // Incremented on transcript exit. Async v-render captures this at start;\n  // each status write no-ops if stale (user left transcript mid-render —\n  // the stable setState would otherwise stamp a ghost toast into the next\n  // session). Also clears any pending 4s auto-clear.\n  const editorGenRef = useRef(0)\n  const editorTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(\n    undefined,\n  )\n  const editorRenderingRef = useRef(false)\n  const { addNotification, removeNotification } = useNotifications()\n\n  // eslint-disable-next-line prefer-const\n  let trySuggestBgPRIntercept = SUGGEST_BG_PR_NOOP\n\n  const mcpClients = useMergedClients(initialMcpClients, mcp.clients)\n\n  // IDE integration\n  const [ideSelection, setIDESelection] = useState<IDESelection | undefined>(\n    undefined,\n  )\n  const [ideToInstallExtension, setIDEToInstallExtension] =\n    useState<IdeType | null>(null)\n  const [ideInstallationStatus, setIDEInstallationStatus] =\n    useState<IDEExtensionInstallationStatus | null>(null)\n  const [showIdeOnboarding, setShowIdeOnboarding] = useState(false)\n  // Dead code elimination: model switch callout state (ant-only)\n  const [showModelSwitchCallout, setShowModelSwitchCallout] = useState(() => {\n    if (\"external\" === 'ant') {\n      return shouldShowAntModelSwitch()\n    }\n    return false\n  })\n  const [showEffortCallout, setShowEffortCallout] = useState(() =>\n    shouldShowEffortCallout(mainLoopModel),\n  )\n  const showRemoteCallout = useAppState(s => s.showRemoteCallout)\n  const [showDesktopUpsellStartup, setShowDesktopUpsellStartup] = useState(() =>\n    shouldShowDesktopUpsellStartup(),\n  )\n  // notifications\n  useModelMigrationNotifications()\n  useCanSwitchToExistingSubscription()\n  useIDEStatusIndicator({ ideSelection, mcpClients, ideInstallationStatus })\n  useMcpConnectivityStatus({ mcpClients })\n  useAutoModeUnavailableNotification()\n  usePluginInstallationStatus()\n  usePluginAutoupdateNotification()\n  useSettingsErrors()\n  useRateLimitWarningNotification(mainLoopModel)\n  useFastModeNotification()\n  useDeprecationWarningNotification(mainLoopModel)\n  useNpmDeprecationNotification()\n  useAntOrgWarningNotification()\n  useInstallMessages()\n  useChromeExtensionNotification()\n  useOfficialMarketplaceNotification()\n  useLspInitializationNotification()\n  useTeammateLifecycleNotification()\n  const {\n    recommendation: lspRecommendation,\n    handleResponse: handleLspResponse,\n  } = useLspPluginRecommendation()\n  const {\n    recommendation: hintRecommendation,\n    handleResponse: handleHintResponse,\n  } = useClaudeCodeHintRecommendation()\n\n  // Memoize the combined initial tools array to prevent reference changes\n  const combinedInitialTools = useMemo(() => {\n    return [...localTools, ...initialTools]\n  }, [localTools, initialTools])\n\n  // Initialize plugin management\n  useManagePlugins({ enabled: !isRemoteSession })\n\n  const tasksV2 = useTasksV2WithCollapseEffect()\n\n  // Start background plugin installations\n\n  // SECURITY: This code is guaranteed to run ONLY after the \"trust this folder\" dialog\n  // has been confirmed by the user. The trust dialog is shown in cli.tsx (line ~387)\n  // before the REPL component is rendered. The dialog blocks execution until the user\n  // accepts, and only then is the REPL component mounted and this effect runs.\n  // This ensures that plugin installations from repository and user settings only\n  // happen after explicit user consent to trust the current working directory.\n  useEffect(() => {\n    if (isRemoteSession) return\n    void performStartupChecks(setAppState)\n  }, [setAppState, isRemoteSession])\n\n  // Allow Claude in Chrome MCP to send prompts through MCP notifications\n  // and sync permission mode changes to the Chrome extension\n  usePromptsFromClaudeInChrome(\n    isRemoteSession ? EMPTY_MCP_CLIENTS : mcpClients,\n    toolPermissionContext.mode,\n  )\n\n  // Initialize swarm features: teammate hooks and context\n  // Handles both fresh spawns and resumed teammate sessions\n  useSwarmInitialization(setAppState, initialMessages, {\n    enabled: !isRemoteSession,\n  })\n\n  const mergedTools = useMergedTools(\n    combinedInitialTools,\n    mcp.tools,\n    toolPermissionContext,\n  )\n\n  // Apply agent tool restrictions if mainThreadAgentDefinition is set\n  const { tools, allowedAgentTypes } = useMemo(() => {\n    if (!mainThreadAgentDefinition) {\n      return {\n        tools: mergedTools,\n        allowedAgentTypes: undefined as string[] | undefined,\n      }\n    }\n    const resolved = resolveAgentTools(\n      mainThreadAgentDefinition,\n      mergedTools,\n      false,\n      true,\n    )\n    return {\n      tools: resolved.resolvedTools,\n      allowedAgentTypes: resolved.allowedAgentTypes,\n    }\n  }, [mainThreadAgentDefinition, mergedTools])\n\n  // Merge commands from local state, plugins, and MCP\n  const commandsWithPlugins = useMergedCommands(\n    localCommands,\n    plugins.commands as Command[],\n  )\n  const mergedCommands = useMergedCommands(\n    commandsWithPlugins,\n    mcp.commands as Command[],\n  )\n  // Filter out all commands if disableSlashCommands is true\n  const commands = useMemo(\n    () => (disableSlashCommands ? [] : mergedCommands),\n    [disableSlashCommands, mergedCommands],\n  )\n\n  useIdeLogging(isRemoteSession ? EMPTY_MCP_CLIENTS : mcp.clients)\n  useIdeSelection(\n    isRemoteSession ? EMPTY_MCP_CLIENTS : mcp.clients,\n    setIDESelection,\n  )\n\n  const [streamMode, setStreamMode] = useState<SpinnerMode>('responding')\n  // Ref mirror so onSubmit can read the latest value without adding\n  // streamMode to its deps. streamMode flips between\n  // requesting/responding/tool-use ~10x per turn during streaming; having it\n  // in onSubmit's deps was recreating onSubmit on every flip, which\n  // cascaded into PromptInput prop churn and downstream useCallback/useMemo\n  // invalidation. The only consumers inside callbacks are debug logging and\n  // telemetry (handlePromptSubmit.ts), so a stale-by-one-render value is\n  // harmless — but ref mirrors sync on every render anyway so it's fresh.\n  const streamModeRef = useRef(streamMode)\n  streamModeRef.current = streamMode\n  const [streamingToolUses, setStreamingToolUses] = useState<\n    StreamingToolUse[]\n  >([])\n  const [streamingThinking, setStreamingThinking] =\n    useState<StreamingThinking | null>(null)\n\n  // Auto-hide streaming thinking after 30 seconds of being completed\n  useEffect(() => {\n    if (\n      streamingThinking &&\n      !streamingThinking.isStreaming &&\n      streamingThinking.streamingEndedAt\n    ) {\n      const elapsed = Date.now() - streamingThinking.streamingEndedAt\n      const remaining = 30000 - elapsed\n      if (remaining > 0) {\n        const timer = setTimeout(setStreamingThinking, remaining, null)\n        return () => clearTimeout(timer)\n      } else {\n        setStreamingThinking(null)\n      }\n    }\n  }, [streamingThinking])\n\n  const [abortController, setAbortController] =\n    useState<AbortController | null>(null)\n  // Ref that always points to the current abort controller, used by the\n  // REPL bridge to abort the active query when a remote interrupt arrives.\n  const abortControllerRef = useRef<AbortController | null>(null)\n  abortControllerRef.current = abortController\n\n  // Ref for the bridge result callback — set after useReplBridge initializes,\n  // read in the onQuery finally block to notify mobile clients that a turn ended.\n  const sendBridgeResultRef = useRef<() => void>(() => {})\n\n  // Ref for the synchronous restore callback — set after restoreMessageSync is\n  // defined, read in the onQuery finally block for auto-restore on interrupt.\n  const restoreMessageSyncRef = useRef<(m: UserMessage) => void>(() => {})\n\n  // Ref to the fullscreen layout's scroll box for keyboard scrolling.\n  // Null when fullscreen mode is disabled (ref never attached).\n  const scrollRef = useRef<ScrollBoxHandle>(null)\n  // Separate ref for the modal slot's inner ScrollBox — passed through\n  // FullscreenLayout → ModalContext so Tabs can attach it to its own\n  // ScrollBox for tall content (e.g. /status's MCP-server list). NOT\n  // keyboard-driven — ScrollKeybindingHandler stays on the outer ref so\n  // PgUp/PgDn/wheel always scroll the transcript behind the modal.\n  // Plumbing kept for future modal-scroll wiring.\n  const modalScrollRef = useRef<ScrollBoxHandle>(null)\n  // Timestamp of the last user-initiated scroll (wheel, PgUp/PgDn, ctrl+u,\n  // End/Home, G, drag-to-scroll). Stamped in composedOnScroll — the single\n  // chokepoint ScrollKeybindingHandler calls for every user scroll action.\n  // Programmatic scrolls (repinScroll's scrollToBottom, sticky auto-follow)\n  // do NOT go through composedOnScroll, so they don't stamp this. Ref not\n  // state: no re-render on every wheel tick.\n  const lastUserScrollTsRef = useRef(0)\n\n  // Synchronous state machine for the query lifecycle. Replaces the\n  // error-prone dual-state pattern where isLoading (React state, async\n  // batched) and isQueryRunning (ref, sync) could desync. See QueryGuard.ts.\n  const queryGuard = React.useRef(new QueryGuard()).current\n\n  // Subscribe to the guard — true during dispatching or running.\n  // This is the single source of truth for \"is a local query in flight\".\n  const isQueryActive = React.useSyncExternalStore(\n    queryGuard.subscribe,\n    queryGuard.getSnapshot,\n  )\n\n  // Separate loading flag for operations outside the local query guard:\n  // remote sessions (useRemoteSession / useDirectConnect) and foregrounded\n  // background tasks (useSessionBackgrounding). These don't route through\n  // onQuery / queryGuard, so they need their own spinner-visibility state.\n  // Initialize true if remote mode with initial prompt (CCR processing it).\n  const [isExternalLoading, setIsExternalLoadingRaw] = React.useState(\n    remoteSessionConfig?.hasInitialPrompt ?? false,\n  )\n\n  // Derived: any loading source active. Read-only — no setter. Local query\n  // loading is driven by queryGuard (reserve/tryStart/end/cancelReservation),\n  // external loading by setIsExternalLoading.\n  const isLoading = isQueryActive || isExternalLoading\n\n  // Elapsed time is computed by SpinnerWithVerb from these refs on each\n  // animation frame, avoiding a useInterval that re-renders the entire REPL.\n  const [userInputOnProcessing, setUserInputOnProcessingRaw] = React.useState<\n    string | undefined\n  >(undefined)\n  // messagesRef.current.length at the moment userInputOnProcessing was set.\n  // The placeholder hides once displayedMessages grows past this — i.e. the\n  // real user message has landed in the visible transcript.\n  const userInputBaselineRef = React.useRef(0)\n  // True while the submitted prompt is being processed but its user message\n  // hasn't reached setMessages yet. setMessages uses this to keep the\n  // baseline in sync when unrelated async messages (bridge status, hook\n  // results, scheduled tasks) land during that window.\n  const userMessagePendingRef = React.useRef(false)\n\n  // Wall-clock time tracking refs for accurate elapsed time calculation\n  const loadingStartTimeRef = React.useRef<number>(0)\n  const totalPausedMsRef = React.useRef(0)\n  const pauseStartTimeRef = React.useRef<number | null>(null)\n  const resetTimingRefs = React.useCallback(() => {\n    loadingStartTimeRef.current = Date.now()\n    totalPausedMsRef.current = 0\n    pauseStartTimeRef.current = null\n  }, [])\n\n  // Reset timing refs inline when isQueryActive transitions false→true.\n  // queryGuard.reserve() (in executeUserInput) fires BEFORE processUserInput's\n  // first await, but the ref reset in onQuery's try block runs AFTER. During\n  // that gap, React renders the spinner with loadingStartTimeRef=0, computing\n  // elapsedTimeMs = Date.now() - 0 ≈ 56 years. This inline reset runs on the\n  // first render where isQueryActive is observed true — the same render that\n  // first shows the spinner — so the ref is correct by the time the spinner\n  // reads it. See INC-4549.\n  const wasQueryActiveRef = React.useRef(false)\n  if (isQueryActive && !wasQueryActiveRef.current) {\n    resetTimingRefs()\n  }\n  wasQueryActiveRef.current = isQueryActive\n\n  // Wrapper for setIsExternalLoading that resets timing refs on transition\n  // to true — SpinnerWithVerb reads these for elapsed time, so they must be\n  // reset for remote sessions / foregrounded tasks too (not just local\n  // queries, which reset them in onQuery). Without this, a remote-only\n  // session would show ~56 years elapsed (Date.now() - 0).\n  const setIsExternalLoading = React.useCallback(\n    (value: boolean) => {\n      setIsExternalLoadingRaw(value)\n      if (value) resetTimingRefs()\n    },\n    [resetTimingRefs],\n  )\n\n  // Start time of the first turn that had swarm teammates running\n  // Used to compute total elapsed time (including teammate execution) for the deferred message\n  const swarmStartTimeRef = React.useRef<number | null>(null)\n  const swarmBudgetInfoRef = React.useRef<\n    { tokens: number; limit: number; nudges: number } | undefined\n  >(undefined)\n\n  // Ref to track current focusedInputDialog for use in callbacks\n  // This avoids stale closures when checking dialog state in timer callbacks\n  const focusedInputDialogRef =\n    React.useRef<ReturnType<typeof getFocusedInputDialog>>(undefined)\n\n  // How long after the last keystroke before deferred dialogs are shown\n  const PROMPT_SUPPRESSION_MS = 1500\n  // True when user is actively typing — defers interrupt dialogs so keystrokes\n  // don't accidentally dismiss or answer a permission prompt the user hasn't read yet.\n  const [isPromptInputActive, setIsPromptInputActive] = React.useState(false)\n\n  const [autoUpdaterResult, setAutoUpdaterResult] =\n    useState<AutoUpdaterResult | null>(null)\n\n  useEffect(() => {\n    if (autoUpdaterResult?.notifications) {\n      autoUpdaterResult.notifications.forEach(notification => {\n        addNotification({\n          key: 'auto-updater-notification',\n          text: notification,\n          priority: 'low',\n        })\n      })\n    }\n  }, [autoUpdaterResult, addNotification])\n\n  // tmux + fullscreen + `mouse off`: one-time hint that wheel won't scroll.\n  // We no longer mutate tmux's session-scoped mouse option (it poisoned\n  // sibling panes); tmux users already know this tradeoff from vim/less.\n  useEffect(() => {\n    if (isFullscreenEnvEnabled()) {\n      void maybeGetTmuxMouseHint().then(hint => {\n        if (hint) {\n          addNotification({\n            key: 'tmux-mouse-hint',\n            text: hint,\n            priority: 'low',\n          })\n        }\n      })\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  const [showUndercoverCallout, setShowUndercoverCallout] = useState(false)\n  useEffect(() => {\n    if (\"external\" === 'ant') {\n      void (async () => {\n        // Wait for repo classification to settle (memoized, no-op if primed).\n        const { isInternalModelRepo } = await import(\n          '../utils/commitAttribution.js'\n        )\n        await isInternalModelRepo()\n        const { shouldShowUndercoverAutoNotice } = await import(\n          '../utils/undercover.js'\n        )\n        if (shouldShowUndercoverAutoNotice()) {\n          setShowUndercoverCallout(true)\n        }\n      })()\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  const [toolJSX, setToolJSXInternal] = useState<{\n    jsx: React.ReactNode | null\n    shouldHidePromptInput: boolean\n    shouldContinueAnimation?: true\n    showSpinner?: boolean\n    isLocalJSXCommand?: boolean\n    isImmediate?: boolean\n  } | null>(null)\n\n  // Track local JSX commands separately so tools can't overwrite them.\n  // This enables \"immediate\" commands (like /btw) to persist while Claude is processing.\n  const localJSXCommandRef = useRef<{\n    jsx: React.ReactNode | null\n    shouldHidePromptInput: boolean\n    shouldContinueAnimation?: true\n    showSpinner?: boolean\n    isLocalJSXCommand: true\n  } | null>(null)\n\n  // Wrapper for setToolJSX that preserves local JSX commands (like /btw).\n  // When a local JSX command is active, we ignore updates from tools\n  // unless they explicitly set clearLocalJSX: true (from onDone callbacks).\n  //\n  // TO ADD A NEW IMMEDIATE COMMAND:\n  // 1. Set `immediate: true` in the command definition\n  // 2. Set `isLocalJSXCommand: true` when calling setToolJSX in the command's JSX\n  // 3. In the onDone callback, use `setToolJSX({ jsx: null, shouldHidePromptInput: false, clearLocalJSX: true })`\n  //    to explicitly clear the overlay when the user dismisses it\n  const setToolJSX = useCallback(\n    (\n      args: {\n        jsx: React.ReactNode | null\n        shouldHidePromptInput: boolean\n        shouldContinueAnimation?: true\n        showSpinner?: boolean\n        isLocalJSXCommand?: boolean\n        clearLocalJSX?: boolean\n      } | null,\n    ) => {\n      // If setting a local JSX command, store it in the ref\n      if (args?.isLocalJSXCommand) {\n        const { clearLocalJSX: _, ...rest } = args\n        localJSXCommandRef.current = { ...rest, isLocalJSXCommand: true }\n        setToolJSXInternal(rest)\n        return\n      }\n\n      // If there's an active local JSX command in the ref\n      if (localJSXCommandRef.current) {\n        // Allow clearing only if explicitly requested (from onDone callbacks)\n        if (args?.clearLocalJSX) {\n          localJSXCommandRef.current = null\n          setToolJSXInternal(null)\n          return\n        }\n        // Otherwise, keep the local JSX command visible - ignore tool updates\n        return\n      }\n\n      // No active local JSX command, allow any update\n      if (args?.clearLocalJSX) {\n        setToolJSXInternal(null)\n        return\n      }\n      setToolJSXInternal(args)\n    },\n    [],\n  )\n  const [toolUseConfirmQueue, setToolUseConfirmQueue] = useState<\n    ToolUseConfirm[]\n  >([])\n  // Sticky footer JSX registered by permission request components (currently\n  // only ExitPlanModePermissionRequest). Renders in FullscreenLayout's `bottom`\n  // slot so response options stay visible while the user scrolls a long plan.\n  const [permissionStickyFooter, setPermissionStickyFooter] =\n    useState<React.ReactNode | null>(null)\n  const [sandboxPermissionRequestQueue, setSandboxPermissionRequestQueue] =\n    useState<\n      Array<{\n        hostPattern: NetworkHostPattern\n        resolvePromise: (allowConnection: boolean) => void\n      }>\n    >([])\n  const [promptQueue, setPromptQueue] = useState<\n    Array<{\n      request: PromptRequest\n      title: string\n      toolInputSummary?: string | null\n      resolve: (response: PromptResponse) => void\n      reject: (error: Error) => void\n    }>\n  >([])\n\n  // Track bridge cleanup functions for sandbox permission requests so the\n  // local dialog handler can cancel the remote prompt when the local user\n  // responds first. Keyed by host to support concurrent same-host requests.\n  const sandboxBridgeCleanupRef = useRef<Map<string, Array<() => void>>>(\n    new Map(),\n  )\n\n  // -- Terminal title management\n  // Session title (set via /rename or restored on resume) wins over\n  // the agent name, which wins over the Haiku-extracted topic;\n  // all fall back to the product name.\n  const terminalTitleFromRename =\n    useAppState(s => s.settings.terminalTitleFromRename) !== false\n  const sessionTitle = terminalTitleFromRename\n    ? getCurrentSessionTitle(getSessionId())\n    : undefined\n  const [haikuTitle, setHaikuTitle] = useState<string>()\n  // Gates the one-shot Haiku call that generates the tab title. Seeded true\n  // on resume (initialMessages present) so we don't re-title a resumed\n  // session from mid-conversation context.\n  const haikuTitleAttemptedRef = useRef((initialMessages?.length ?? 0) > 0)\n  const agentTitle = mainThreadAgentDefinition?.agentType\n  const terminalTitle =\n    sessionTitle ?? agentTitle ?? haikuTitle ?? 'Claude Code'\n  const isWaitingForApproval =\n    toolUseConfirmQueue.length > 0 ||\n    promptQueue.length > 0 ||\n    pendingWorkerRequest ||\n    pendingSandboxRequest\n  // Local-jsx commands (like /plugin, /config) show user-facing dialogs that\n  // wait for input. Require jsx != null — if the flag is stuck true but jsx\n  // is null, treat as not-showing so TextInput focus and queue processor\n  // aren't deadlocked by a phantom overlay.\n  const isShowingLocalJSXCommand =\n    toolJSX?.isLocalJSXCommand === true && toolJSX?.jsx != null\n  const titleIsAnimating =\n    isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand\n  // Title animation state lives in <AnimatedTerminalTitle> so the 960ms tick\n  // doesn't re-render REPL. titleDisabled/terminalTitle are still computed\n  // here because onQueryImpl reads them (background session description,\n  // haiku title extraction gate).\n\n  // Prevent macOS from sleeping while Claude is working\n  useEffect(() => {\n    if (isLoading && !isWaitingForApproval && !isShowingLocalJSXCommand) {\n      startPreventSleep()\n      return () => stopPreventSleep()\n    }\n  }, [isLoading, isWaitingForApproval, isShowingLocalJSXCommand])\n\n  const sessionStatus: TabStatusKind =\n    isWaitingForApproval || isShowingLocalJSXCommand\n      ? 'waiting'\n      : isLoading\n        ? 'busy'\n        : 'idle'\n\n  const waitingFor =\n    sessionStatus !== 'waiting'\n      ? undefined\n      : toolUseConfirmQueue.length > 0\n        ? `approve ${toolUseConfirmQueue[0]!.tool.name}`\n        : pendingWorkerRequest\n          ? 'worker request'\n          : pendingSandboxRequest\n            ? 'sandbox request'\n            : isShowingLocalJSXCommand\n              ? 'dialog open'\n              : 'input needed'\n\n  // Push status to the PID file for `claude ps`. Fire-and-forget; ps falls\n  // back to transcript-tail derivation when this is missing/stale.\n  useEffect(() => {\n    if (feature('BG_SESSIONS')) {\n      void updateSessionActivity({ status: sessionStatus, waitingFor })\n    }\n  }, [sessionStatus, waitingFor])\n\n  // 3P default: off — OSC 21337 is ant-only while the spec stabilizes.\n  // Gated so we can roll back if the sidebar indicator conflicts with\n  // the title spinner in terminals that render both. When the flag is\n  // on, the user-facing config setting controls whether it's active.\n  const tabStatusGateEnabled = getFeatureValue_CACHED_MAY_BE_STALE(\n    'tengu_terminal_sidebar',\n    false,\n  )\n  const showStatusInTerminalTab =\n    tabStatusGateEnabled && (getGlobalConfig().showStatusInTerminalTab ?? false)\n  useTabStatus(titleDisabled || !showStatusInTerminalTab ? null : sessionStatus)\n\n  // Register the leader's setToolUseConfirmQueue for in-process teammates\n  useEffect(() => {\n    registerLeaderToolUseConfirmQueue(setToolUseConfirmQueue)\n    return () => unregisterLeaderToolUseConfirmQueue()\n  }, [setToolUseConfirmQueue])\n\n  const [messages, rawSetMessages] = useState<MessageType[]>(\n    initialMessages ?? [],\n  )\n  const messagesRef = useRef(messages)\n  // Stores the willowMode variant that was shown (or false if no hint shown).\n  // Captured at hint_shown time so hint_converted telemetry reports the same\n  // variant — the GrowthBook value shouldn't change mid-session, but reading\n  // it once guarantees consistency between the paired events.\n  const idleHintShownRef = useRef<string | false>(false)\n  // Wrap setMessages so messagesRef is always current the instant the\n  // call returns — not when React later processes the batch.  Apply the\n  // updater eagerly against the ref, then hand React the computed value\n  // (not the function).  rawSetMessages batching becomes last-write-wins,\n  // and the last write is correct because each call composes against the\n  // already-updated ref.  This is the Zustand pattern: ref is source of\n  // truth, React state is the render projection.  Without this, paths\n  // that queue functional updaters then synchronously read the ref\n  // (e.g. handleSpeculationAccept → onQuery) see stale data.\n  const setMessages = useCallback(\n    (action: React.SetStateAction<MessageType[]>) => {\n      const prev = messagesRef.current\n      const next =\n        typeof action === 'function' ? action(messagesRef.current) : action\n      messagesRef.current = next\n      if (next.length < userInputBaselineRef.current) {\n        // Shrank (compact/rewind/clear) — clamp so placeholderText's length\n        // check can't go stale.\n        userInputBaselineRef.current = 0\n      } else if (next.length > prev.length && userMessagePendingRef.current) {\n        // Grew while the submitted user message hasn't landed yet. If the\n        // added messages don't include it (bridge status, hook results,\n        // scheduled tasks landing async during processUserInputBase), bump\n        // baseline so the placeholder stays visible. Once the user message\n        // lands, stop tracking — later additions (assistant stream) should\n        // not re-show the placeholder.\n        const delta = next.length - prev.length\n        const added =\n          prev.length === 0 || next[0] === prev[0]\n            ? next.slice(-delta)\n            : next.slice(0, delta)\n        if (added.some(isHumanTurn)) {\n          userMessagePendingRef.current = false\n        } else {\n          userInputBaselineRef.current = next.length\n        }\n      }\n      rawSetMessages(next)\n    },\n    [],\n  )\n  // Capture the baseline message count alongside the placeholder text so\n  // the render can hide it once displayedMessages grows past the baseline.\n  const setUserInputOnProcessing = useCallback((input: string | undefined) => {\n    if (input !== undefined) {\n      userInputBaselineRef.current = messagesRef.current.length\n      userMessagePendingRef.current = true\n    } else {\n      userMessagePendingRef.current = false\n    }\n    setUserInputOnProcessingRaw(input)\n  }, [])\n  // Fullscreen: track the unseen-divider position. dividerIndex changes\n  // only ~twice/scroll-session (first scroll-away + repin). pillVisible\n  // and stickyPrompt now live in FullscreenLayout — they subscribe to\n  // ScrollBox directly so per-frame scroll never re-renders REPL.\n  const {\n    dividerIndex,\n    dividerYRef,\n    onScrollAway,\n    onRepin,\n    jumpToNew,\n    shiftDivider,\n  } = useUnseenDivider(messages.length)\n  if (feature('AWAY_SUMMARY')) {\n    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n    useAwaySummary(messages, setMessages, isLoading)\n  }\n  const [cursor, setCursor] = useState<MessageActionsState | null>(null)\n  const cursorNavRef = useRef<MessageActionsNav | null>(null)\n  // Memoized so Messages' React.memo holds.\n  const unseenDivider = useMemo(\n    () => computeUnseenDivider(messages, dividerIndex),\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- length change covers appends; useUnseenDivider's count-drop guard clears dividerIndex on replace/rewind\n    [dividerIndex, messages.length],\n  )\n  // Re-pin scroll to bottom and clear the unseen-messages baseline. Called\n  // on any user-driven return-to-live action (submit, type-into-empty,\n  // overlay appear/dismiss).\n  const repinScroll = useCallback(() => {\n    scrollRef.current?.scrollToBottom()\n    onRepin()\n    setCursor(null)\n  }, [onRepin, setCursor])\n  // Backstop for the submit-handler repin at onSubmit. If a buffered stdin\n  // event (wheel/drag) races between handler-fire and state-commit, the\n  // handler's scrollToBottom can be undone. This effect fires on the render\n  // where the user's message actually lands — tied to React's commit cycle,\n  // so it can't race with stdin. Keyed on lastMsg identity (not messages.length)\n  // so useAssistantHistory's prepends don't spuriously repin.\n  const lastMsg = messages.at(-1)\n  const lastMsgIsHuman = lastMsg != null && isHumanTurn(lastMsg)\n  useEffect(() => {\n    if (lastMsgIsHuman) {\n      repinScroll()\n    }\n  }, [lastMsgIsHuman, lastMsg, repinScroll])\n  // Assistant-chat: lazy-load remote history on scroll-up. No-op unless\n  // KAIROS build + config.viewerOnly. feature() is build-time constant so\n  // the branch is dead-code-eliminated in non-KAIROS builds (same pattern\n  // as useUnseenDivider above).\n  const { maybeLoadOlder } = feature('KAIROS')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useAssistantHistory({\n        config: remoteSessionConfig,\n        setMessages,\n        scrollRef,\n        onPrepend: shiftDivider,\n      })\n    : HISTORY_STUB\n  // Compose useUnseenDivider's callbacks with the lazy-load trigger.\n  const composedOnScroll = useCallback(\n    (sticky: boolean, handle: ScrollBoxHandle) => {\n      lastUserScrollTsRef.current = Date.now()\n      if (sticky) {\n        onRepin()\n      } else {\n        onScrollAway(handle)\n        if (feature('KAIROS')) maybeLoadOlder(handle)\n        // Dismiss the companion bubble on scroll — it's absolute-positioned\n        // at bottom-right and covers transcript content. Scrolling = user is\n        // trying to read something under it.\n        if (feature('BUDDY')) {\n          setAppState(prev =>\n            prev.companionReaction === undefined\n              ? prev\n              : { ...prev, companionReaction: undefined },\n          )\n        }\n      }\n    },\n    [onRepin, onScrollAway, maybeLoadOlder, setAppState],\n  )\n  // Deferred SessionStart hook messages — REPL renders immediately and\n  // hook messages are injected when they resolve. awaitPendingHooks()\n  // must be called before the first API call so the model sees hook context.\n  const awaitPendingHooks = useDeferredHookMessages(\n    pendingHookMessages,\n    setMessages,\n  )\n\n  // Deferred messages for the Messages component — renders at transition\n  // priority so the reconciler yields every 5ms, keeping input responsive\n  // while the expensive message processing pipeline runs.\n  const deferredMessages = useDeferredValue(messages)\n  const deferredBehind = messages.length - deferredMessages.length\n  if (deferredBehind > 0) {\n    logForDebugging(\n      `[useDeferredValue] Messages deferred by ${deferredBehind} (${deferredMessages.length}→${messages.length})`,\n    )\n  }\n\n  // Frozen state for transcript mode - stores lengths instead of cloning arrays for memory efficiency\n  const [frozenTranscriptState, setFrozenTranscriptState] = useState<{\n    messagesLength: number\n    streamingToolUsesLength: number\n  } | null>(null)\n  // Initialize input with any early input that was captured before REPL was ready.\n  // Using lazy initialization ensures cursor offset is set correctly in PromptInput.\n  const [inputValue, setInputValueRaw] = useState(() => consumeEarlyInput())\n  const inputValueRef = useRef(inputValue)\n  inputValueRef.current = inputValue\n  const insertTextRef = useRef<{\n    insert: (text: string) => void\n    setInputWithCursor: (value: string, cursor: number) => void\n    cursorOffset: number\n  } | null>(null)\n\n  // Wrap setInputValue to co-locate suppression state updates.\n  // Both setState calls happen in the same synchronous context so React\n  // batches them into a single render, eliminating the extra render that\n  // the previous useEffect → setState pattern caused.\n  const setInputValue = useCallback(\n    (value: string) => {\n      if (trySuggestBgPRIntercept(inputValueRef.current, value)) return\n      // In fullscreen mode, typing into an empty prompt re-pins scroll to\n      // bottom. Only fires on empty→non-empty so scrolling up to reference\n      // something while composing a message doesn't yank the view back on\n      // every keystroke. Restores the pre-fullscreen muscle memory of\n      // typing to snap back to the end of the conversation.\n      // Skipped if the user scrolled within the last 3s — they're actively\n      // reading, not lost. lastUserScrollTsRef starts at 0 so the first-\n      // ever keypress (no scroll yet) always repins.\n      if (\n        inputValueRef.current === '' &&\n        value !== '' &&\n        Date.now() - lastUserScrollTsRef.current >=\n          RECENT_SCROLL_REPIN_WINDOW_MS\n      ) {\n        repinScroll()\n      }\n      // Sync ref immediately (like setMessages) so callers that read\n      // inputValueRef before React commits — e.g. the auto-restore finally\n      // block's `=== ''` guard — see the fresh value, not the stale render.\n      inputValueRef.current = value\n      setInputValueRaw(value)\n      setIsPromptInputActive(value.trim().length > 0)\n    },\n    [setIsPromptInputActive, repinScroll, trySuggestBgPRIntercept],\n  )\n\n  // Schedule a timeout to stop suppressing dialogs after the user stops typing.\n  // Only manages the timeout — the immediate activation is handled by setInputValue above.\n  useEffect(() => {\n    if (inputValue.trim().length === 0) return\n    const timer = setTimeout(\n      setIsPromptInputActive,\n      PROMPT_SUPPRESSION_MS,\n      false,\n    )\n    return () => clearTimeout(timer)\n  }, [inputValue])\n\n  const [inputMode, setInputMode] = useState<PromptInputMode>('prompt')\n  const [stashedPrompt, setStashedPrompt] = useState<\n    | {\n        text: string\n        cursorOffset: number\n        pastedContents: Record<number, PastedContent>\n      }\n    | undefined\n  >()\n\n  // Callback to filter commands based on CCR's available slash commands\n  const handleRemoteInit = useCallback(\n    (remoteSlashCommands: string[]) => {\n      const remoteCommandSet = new Set(remoteSlashCommands)\n      // Keep commands that CCR lists OR that are in the local-safe set\n      setLocalCommands(prev =>\n        prev.filter(\n          cmd =>\n            remoteCommandSet.has(cmd.name) || REMOTE_SAFE_COMMANDS.has(cmd),\n        ),\n      )\n    },\n    [setLocalCommands],\n  )\n\n  const [inProgressToolUseIDs, setInProgressToolUseIDs] = useState<Set<string>>(\n    new Set(),\n  )\n  const hasInterruptibleToolInProgressRef = useRef(false)\n\n  // Remote session hook - manages WebSocket connection and message handling for --remote mode\n  const remoteSession = useRemoteSession({\n    config: remoteSessionConfig,\n    setMessages,\n    setIsLoading: setIsExternalLoading,\n    onInit: handleRemoteInit,\n    setToolUseConfirmQueue,\n    tools: combinedInitialTools,\n    setStreamingToolUses,\n    setStreamMode,\n    setInProgressToolUseIDs,\n  })\n\n  // Direct connect hook - manages WebSocket to a claude server for `claude connect` mode\n  const directConnect = useDirectConnect({\n    config: directConnectConfig,\n    setMessages,\n    setIsLoading: setIsExternalLoading,\n    setToolUseConfirmQueue,\n    tools: combinedInitialTools,\n  })\n\n  // SSH session hook - manages ssh child process for `claude ssh` mode.\n  // Same callback shape as useDirectConnect; only the transport under the\n  // hood differs (ChildProcess stdin/stdout vs WebSocket).\n  const sshRemote = useSSHSession({\n    session: sshSession,\n    setMessages,\n    setIsLoading: setIsExternalLoading,\n    setToolUseConfirmQueue,\n    tools: combinedInitialTools,\n  })\n\n  // Use whichever remote mode is active\n  const activeRemote = sshRemote.isRemoteMode\n    ? sshRemote\n    : directConnect.isRemoteMode\n      ? directConnect\n      : remoteSession\n\n  const [pastedContents, setPastedContents] = useState<\n    Record<number, PastedContent>\n  >({})\n  const [submitCount, setSubmitCount] = useState(0)\n  // Ref instead of state to avoid triggering React re-renders on every\n  // streaming text_delta. The spinner reads this via its animation timer.\n  const responseLengthRef = useRef(0)\n  // API performance metrics ref for ant-only spinner display (TTFT/OTPS).\n  // Accumulates metrics from all API requests in a turn for P50 aggregation.\n  const apiMetricsRef = useRef<\n    Array<{\n      ttftMs: number\n      firstTokenTime: number\n      lastTokenTime: number\n      responseLengthBaseline: number\n      // Tracks responseLengthRef at the time of the last content addition.\n      // Updated by both streaming deltas and subagent message content.\n      // lastTokenTime is also updated at the same time, so the OTPS\n      // denominator correctly includes subagent processing time.\n      endResponseLength: number\n    }>\n  >([])\n  const setResponseLength = useCallback((f: (prev: number) => number) => {\n    const prev = responseLengthRef.current\n    responseLengthRef.current = f(prev)\n    // When content is added (not a compaction reset), update the latest\n    // metrics entry so OTPS reflects all content generation activity.\n    // Updating lastTokenTime here ensures the denominator includes both\n    // streaming time AND subagent execution time, preventing inflation.\n    if (responseLengthRef.current > prev) {\n      const entries = apiMetricsRef.current\n      if (entries.length > 0) {\n        const lastEntry = entries.at(-1)!\n        lastEntry.lastTokenTime = Date.now()\n        lastEntry.endResponseLength = responseLengthRef.current\n      }\n    }\n  }, [])\n\n  // Streaming text display: set state directly per delta (Ink's 16ms render\n  // throttle batches rapid updates). Cleared on message arrival (messages.ts)\n  // so displayedMessages switches from deferredMessages to messages atomically.\n  const [streamingText, setStreamingText] = useState<string | null>(null)\n  const reducedMotion =\n    useAppState(s => s.settings.prefersReducedMotion) ?? false\n  const showStreamingText = !reducedMotion && !hasCursorUpViewportYankBug()\n  const onStreamingText = useCallback(\n    (f: (current: string | null) => string | null) => {\n      if (!showStreamingText) return\n      setStreamingText(f)\n    },\n    [showStreamingText],\n  )\n\n  // Hide the in-progress source line so text streams line-by-line, not\n  // char-by-char. lastIndexOf returns -1 when no newline, giving '' → null.\n  // Guard on showStreamingText so toggling reducedMotion mid-stream\n  // immediately hides the streaming preview.\n  const visibleStreamingText =\n    streamingText && showStreamingText\n      ? streamingText.substring(0, streamingText.lastIndexOf('\\n') + 1) || null\n      : null\n\n  const [lastQueryCompletionTime, setLastQueryCompletionTime] = useState(0)\n  const [spinnerMessage, setSpinnerMessage] = useState<string | null>(null)\n  const [spinnerColor, setSpinnerColor] = useState<keyof Theme | null>(null)\n  const [spinnerShimmerColor, setSpinnerShimmerColor] = useState<\n    keyof Theme | null\n  >(null)\n  const [isMessageSelectorVisible, setIsMessageSelectorVisible] =\n    useState(false)\n  const [messageSelectorPreselect, setMessageSelectorPreselect] = useState<\n    UserMessage | undefined\n  >(undefined)\n  const [showCostDialog, setShowCostDialog] = useState(false)\n  const [conversationId, setConversationId] = useState(randomUUID())\n\n  // Idle-return dialog: shown when user submits after a long idle gap\n  const [idleReturnPending, setIdleReturnPending] = useState<{\n    input: string\n    idleMinutes: number\n  } | null>(null)\n  const skipIdleCheckRef = useRef(false)\n  const lastQueryCompletionTimeRef = useRef(lastQueryCompletionTime)\n  lastQueryCompletionTimeRef.current = lastQueryCompletionTime\n\n  // Aggregate tool result budget: per-conversation decision tracking.\n  // When the GrowthBook flag is on, query.ts enforces the budget; when\n  // off (undefined), enforcement is skipped entirely. Stale entries after\n  // /clear, rewind, or compact are harmless (tool_use_ids are UUIDs, stale\n  // keys are never looked up). Memory is bounded by total replacement count\n  // × ~2KB preview over the REPL lifetime — negligible.\n  //\n  // Lazy init via useState initializer — useRef(expr) evaluates expr on every\n  // render (React ignores it after first, but the computation still runs).\n  // For large resumed sessions, reconstruction does O(messages × blocks)\n  // work; we only want that once.\n  const [contentReplacementStateRef] = useState(() => ({\n    current: provisionContentReplacementState(\n      initialMessages,\n      initialContentReplacements,\n    ),\n  }))\n\n  const [haveShownCostDialog, setHaveShownCostDialog] = useState(\n    getGlobalConfig().hasAcknowledgedCostThreshold,\n  )\n  const [vimMode, setVimMode] = useState<VimMode>('INSERT')\n  const [showBashesDialog, setShowBashesDialog] = useState<string | boolean>(\n    false,\n  )\n  const [isSearchingHistory, setIsSearchingHistory] = useState(false)\n  const [isHelpOpen, setIsHelpOpen] = useState(false)\n\n  // showBashesDialog is REPL-level so it survives PromptInput unmounting.\n  // When ultraplan approval fires while the pill dialog is open, PromptInput\n  // unmounts (focusedInputDialog → 'ultraplan-choice') but this stays true;\n  // after accepting, PromptInput remounts into an empty \"No tasks\" dialog\n  // (the completed ultraplan task has been filtered out). Close it here.\n  useEffect(() => {\n    if (ultraplanPendingChoice && showBashesDialog) {\n      setShowBashesDialog(false)\n    }\n  }, [ultraplanPendingChoice, showBashesDialog])\n\n  const isTerminalFocused = useTerminalFocus()\n  const terminalFocusRef = useRef(isTerminalFocused)\n  terminalFocusRef.current = isTerminalFocused\n\n  const [theme] = useTheme()\n\n  // resetLoadingState runs twice per turn (onQueryImpl tail + onQuery finally).\n  // Without this guard, both calls pick a tip → two recordShownTip → two\n  // saveGlobalConfig writes back-to-back. Reset at submit in onSubmit.\n  const tipPickedThisTurnRef = React.useRef(false)\n  const pickNewSpinnerTip = useCallback(() => {\n    if (tipPickedThisTurnRef.current) return\n    tipPickedThisTurnRef.current = true\n    const newMessages = messagesRef.current.slice(bashToolsProcessedIdx.current)\n    for (const tool of extractBashToolsFromMessages(newMessages)) {\n      bashTools.current.add(tool)\n    }\n    bashToolsProcessedIdx.current = messagesRef.current.length\n    void getTipToShowOnSpinner({\n      theme,\n      readFileState: readFileState.current,\n      bashTools: bashTools.current,\n    }).then(async tip => {\n      if (tip) {\n        const content = await tip.content({ theme })\n        setAppState(prev => ({\n          ...prev,\n          spinnerTip: content,\n        }))\n        recordShownTip(tip)\n      } else {\n        setAppState(prev => {\n          if (prev.spinnerTip === undefined) return prev\n          return { ...prev, spinnerTip: undefined }\n        })\n      }\n    })\n  }, [setAppState, theme])\n\n  // Resets UI loading state. Does NOT call onTurnComplete - that should be\n  // called explicitly only when a query turn actually completes.\n  const resetLoadingState = useCallback(() => {\n    // isLoading is now derived from queryGuard — no setter call needed.\n    // queryGuard.end() (onQuery finally) or cancelReservation() (executeUserInput\n    // finally) have already transitioned the guard to idle by the time this runs.\n    // External loading (remote/backgrounding) is reset separately by those hooks.\n    setIsExternalLoading(false)\n    setUserInputOnProcessing(undefined)\n    responseLengthRef.current = 0\n    apiMetricsRef.current = []\n    setStreamingText(null)\n    setStreamingToolUses([])\n    setSpinnerMessage(null)\n    setSpinnerColor(null)\n    setSpinnerShimmerColor(null)\n    pickNewSpinnerTip()\n    endInteractionSpan()\n    // Speculative bash classifier checks are only valid for the current\n    // turn's commands — clear after each turn to avoid accumulating\n    // Promise chains for unconsumed checks (denied/aborted paths).\n    clearSpeculativeChecks()\n  }, [pickNewSpinnerTip])\n\n  // Session backgrounding — hook is below, after getToolUseContext\n\n  const hasRunningTeammates = useMemo(\n    () => getAllInProcessTeammateTasks(tasks).some(t => t.status === 'running'),\n    [tasks],\n  )\n\n  // Show deferred turn duration message once all swarm teammates finish\n  useEffect(() => {\n    if (!hasRunningTeammates && swarmStartTimeRef.current !== null) {\n      const totalMs = Date.now() - swarmStartTimeRef.current\n      const deferredBudget = swarmBudgetInfoRef.current\n      swarmStartTimeRef.current = null\n      swarmBudgetInfoRef.current = undefined\n      setMessages(prev => [\n        ...prev,\n        createTurnDurationMessage(\n          totalMs,\n          deferredBudget,\n          // Count only what recordTranscript will persist — ephemeral\n          // progress ticks and non-ant attachments are filtered by\n          // isLoggableMessage and never reach disk. Using raw prev.length\n          // would make checkResumeConsistency report false delta<0 for\n          // every turn that ran a progress-emitting tool.\n          count(prev, isLoggableMessage),\n        ),\n      ])\n    }\n  }, [hasRunningTeammates, setMessages])\n\n  // Show auto permissions warning when entering auto mode\n  // (either via Shift+Tab toggle or on startup). Debounced to avoid\n  // flashing when the user is cycling through modes quickly.\n  // Only shown 3 times total across sessions.\n  const safeYoloMessageShownRef = useRef(false)\n  useEffect(() => {\n    if (feature('TRANSCRIPT_CLASSIFIER')) {\n      if (toolPermissionContext.mode !== 'auto') {\n        safeYoloMessageShownRef.current = false\n        return\n      }\n      if (safeYoloMessageShownRef.current) return\n      const config = getGlobalConfig()\n      const count = config.autoPermissionsNotificationCount ?? 0\n      if (count >= 3) return\n      const timer = setTimeout(\n        (ref, setMessages) => {\n          ref.current = true\n          saveGlobalConfig(prev => {\n            const prevCount = prev.autoPermissionsNotificationCount ?? 0\n            if (prevCount >= 3) return prev\n            return {\n              ...prev,\n              autoPermissionsNotificationCount: prevCount + 1,\n            }\n          })\n          setMessages(prev => [\n            ...prev,\n            createSystemMessage(AUTO_MODE_DESCRIPTION, 'warning'),\n          ])\n        },\n        800,\n        safeYoloMessageShownRef,\n        setMessages,\n      )\n      return () => clearTimeout(timer)\n    }\n  }, [toolPermissionContext.mode, setMessages])\n\n  // If worktree creation was slow and sparse-checkout isn't configured,\n  // nudge the user toward settings.worktree.sparsePaths.\n  const worktreeTipShownRef = useRef(false)\n  useEffect(() => {\n    if (worktreeTipShownRef.current) return\n    const wt = getCurrentWorktreeSession()\n    if (!wt?.creationDurationMs || wt.usedSparsePaths) return\n    if (wt.creationDurationMs < 15_000) return\n    worktreeTipShownRef.current = true\n    const secs = Math.round(wt.creationDurationMs / 1000)\n    setMessages(prev => [\n      ...prev,\n      createSystemMessage(\n        `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\"]}}\\`.`,\n        'info',\n      ),\n    ])\n  }, [setMessages])\n\n  // Hide spinner when the only in-progress tool is Sleep\n  const onlySleepToolActive = useMemo(() => {\n    const lastAssistant = messages.findLast(m => m.type === 'assistant')\n    if (lastAssistant?.type !== 'assistant') return false\n    const inProgressToolUses = lastAssistant.message.content.filter(\n      b => b.type === 'tool_use' && inProgressToolUseIDs.has(b.id),\n    )\n    return (\n      inProgressToolUses.length > 0 &&\n      inProgressToolUses.every(\n        b => b.type === 'tool_use' && b.name === SLEEP_TOOL_NAME,\n      )\n    )\n  }, [messages, inProgressToolUseIDs])\n\n  const {\n    onBeforeQuery: mrOnBeforeQuery,\n    onTurnComplete: mrOnTurnComplete,\n    render: mrRender,\n  } = useMoreRight({\n    enabled: moreRightEnabled,\n    setMessages,\n    inputValue,\n    setInputValue,\n    setToolJSX,\n  })\n\n  const showSpinner =\n    (!toolJSX || toolJSX.showSpinner === true) &&\n    toolUseConfirmQueue.length === 0 &&\n    promptQueue.length === 0 &&\n    // Show spinner during input processing, API call, while teammates are running,\n    // or while pending task notifications are queued (prevents spinner bounce between consecutive notifications)\n    (isLoading ||\n      userInputOnProcessing ||\n      hasRunningTeammates ||\n      // Keep spinner visible while task notifications are queued for processing.\n      // Without this, the spinner briefly disappears between consecutive notifications\n      // (e.g., multiple background agents completing in rapid succession) because\n      // isLoading goes false momentarily between processing each one.\n      getCommandQueueLength() > 0) &&\n    // Hide spinner when waiting for leader to approve permission request\n    !pendingWorkerRequest &&\n    !onlySleepToolActive &&\n    // Hide spinner when streaming text is visible (the text IS the feedback),\n    // but keep it when isBriefOnly suppresses the streaming text display\n    (!visibleStreamingText || isBriefOnly)\n\n  // Check if any permission or ask question prompt is currently visible\n  // This is used to prevent the survey from opening while prompts are active\n  const hasActivePrompt =\n    toolUseConfirmQueue.length > 0 ||\n    promptQueue.length > 0 ||\n    sandboxPermissionRequestQueue.length > 0 ||\n    elicitation.queue.length > 0 ||\n    workerSandboxPermissions.queue.length > 0\n\n  const feedbackSurveyOriginal = useFeedbackSurvey(\n    messages,\n    isLoading,\n    submitCount,\n    'session',\n    hasActivePrompt,\n  )\n\n  const skillImprovementSurvey = useSkillImprovementSurvey(setMessages)\n\n  const showIssueFlagBanner = useIssueFlagBanner(messages, submitCount)\n\n  // Wrap feedback survey handler to trigger auto-run /issue\n  const feedbackSurvey = useMemo(\n    () => ({\n      ...feedbackSurveyOriginal,\n      handleSelect: (selected: 'dismissed' | 'bad' | 'fine' | 'good') => {\n        // Reset the ref when a new survey response comes in\n        didAutoRunIssueRef.current = false\n        const showedTranscriptPrompt =\n          feedbackSurveyOriginal.handleSelect(selected)\n        // Auto-run /issue for \"bad\" if transcript prompt wasn't shown\n        if (\n          selected === 'bad' &&\n          !showedTranscriptPrompt &&\n          shouldAutoRunIssue('feedback_survey_bad')\n        ) {\n          setAutoRunIssueReason('feedback_survey_bad')\n          didAutoRunIssueRef.current = true\n        }\n      },\n    }),\n    [feedbackSurveyOriginal],\n  )\n\n  // Post-compact survey: shown after compaction if feature gate is enabled\n  const postCompactSurvey = usePostCompactSurvey(\n    messages,\n    isLoading,\n    hasActivePrompt,\n    { enabled: !isRemoteSession },\n  )\n\n  // Memory survey: shown when the assistant mentions memory and a memory file\n  // was read this conversation\n  const memorySurvey = useMemorySurvey(messages, isLoading, hasActivePrompt, {\n    enabled: !isRemoteSession,\n  })\n\n  // Frustration detection: show transcript sharing prompt after detecting frustrated messages\n  const frustrationDetection = useFrustrationDetection(\n    messages,\n    isLoading,\n    hasActivePrompt,\n    feedbackSurvey.state !== 'closed' ||\n      postCompactSurvey.state !== 'closed' ||\n      memorySurvey.state !== 'closed',\n  )\n\n  // Initialize IDE integration\n  useIDEIntegration({\n    autoConnectIdeFlag,\n    ideToInstallExtension,\n    setDynamicMcpConfig,\n    setShowIdeOnboarding,\n    setIDEInstallationState: setIDEInstallationStatus,\n  })\n\n  useFileHistorySnapshotInit(\n    initialFileHistorySnapshots,\n    fileHistory,\n    fileHistoryState =>\n      setAppState(prev => ({\n        ...prev,\n        fileHistory: fileHistoryState,\n      })),\n  )\n\n  const resume = useCallback(\n    async (sessionId: UUID, log: LogOption, entrypoint: ResumeEntrypoint) => {\n      const resumeStart = performance.now()\n      try {\n        // Deserialize messages to properly clean up the conversation\n        // This filters unresolved tool uses and adds a synthetic assistant message if needed\n        const messages = deserializeMessages(log.messages)\n\n        // Match coordinator/normal mode to the resumed session\n        if (feature('COORDINATOR_MODE')) {\n          /* eslint-disable @typescript-eslint/no-require-imports */\n          const coordinatorModule =\n            require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js')\n          /* eslint-enable @typescript-eslint/no-require-imports */\n          const warning = coordinatorModule.matchSessionMode(log.mode)\n          if (warning) {\n            // Re-derive agent definitions after mode switch so built-in agents\n            // reflect the new coordinator/normal mode\n            /* eslint-disable @typescript-eslint/no-require-imports */\n            const {\n              getAgentDefinitionsWithOverrides,\n              getActiveAgentsFromList,\n            } =\n              require('../tools/AgentTool/loadAgentsDir.js') as typeof import('../tools/AgentTool/loadAgentsDir.js')\n            /* eslint-enable @typescript-eslint/no-require-imports */\n            getAgentDefinitionsWithOverrides.cache.clear?.()\n            const freshAgentDefs = await getAgentDefinitionsWithOverrides(\n              getOriginalCwd(),\n            )\n\n            setAppState(prev => ({\n              ...prev,\n              agentDefinitions: {\n                ...freshAgentDefs,\n                allAgents: freshAgentDefs.allAgents,\n                activeAgents: getActiveAgentsFromList(freshAgentDefs.allAgents),\n              },\n            }))\n            messages.push(createSystemMessage(warning, 'warning'))\n          }\n        }\n\n        // Fire SessionEnd hooks for the current session before starting the\n        // resumed one, mirroring the /clear flow in conversation.ts.\n        const sessionEndTimeoutMs = getSessionEndHookTimeoutMs()\n        await executeSessionEndHooks('resume', {\n          getAppState: () => store.getState(),\n          setAppState,\n          signal: AbortSignal.timeout(sessionEndTimeoutMs),\n          timeoutMs: sessionEndTimeoutMs,\n        })\n\n        // Process session start hooks for resume\n        const hookMessages = await processSessionStartHooks('resume', {\n          sessionId,\n          agentType: mainThreadAgentDefinition?.agentType,\n          model: mainLoopModel,\n        })\n\n        // Append hook messages to the conversation\n        messages.push(...hookMessages)\n        // For forks, generate a new plan slug and copy the plan content so the\n        // original and forked sessions don't clobber each other's plan files.\n        // For regular resumes, reuse the original session's plan slug.\n        if (entrypoint === 'fork') {\n          void copyPlanForFork(log, asSessionId(sessionId))\n        } else {\n          void copyPlanForResume(log, asSessionId(sessionId))\n        }\n\n        // Restore file history and attribution state from the resumed conversation\n        restoreSessionStateFromLog(log, setAppState)\n        if (log.fileHistorySnapshots) {\n          void copyFileHistoryForResume(log)\n        }\n\n        // Restore agent setting from the resumed conversation\n        // Always reset to the new session's values (or clear if none),\n        // matching the standaloneAgentContext pattern below\n        const { agentDefinition: restoredAgent } = restoreAgentFromSession(\n          log.agentSetting,\n          initialMainThreadAgentDefinition,\n          agentDefinitions,\n        )\n        setMainThreadAgentDefinition(restoredAgent)\n        setAppState(prev => ({ ...prev, agent: restoredAgent?.agentType }))\n\n        // Restore standalone agent context from the resumed conversation\n        // Always reset to the new session's values (or clear if none)\n        setAppState(prev => ({\n          ...prev,\n          standaloneAgentContext: computeStandaloneAgentContext(\n            log.agentName,\n            log.agentColor,\n          ),\n        }))\n        void updateSessionName(log.agentName)\n\n        // Restore read file state from the message history\n        restoreReadFileState(messages, log.projectPath ?? getOriginalCwd())\n\n        // Clear any active loading state (no queryId since we're not in a query)\n        resetLoadingState()\n        setAbortController(null)\n\n        setConversationId(sessionId)\n\n        // Get target session's costs BEFORE saving current session\n        // (saveCurrentSessionCosts overwrites the config, so we need to read first)\n        const targetSessionCosts = getStoredSessionCosts(sessionId)\n\n        // Save current session's costs before switching to avoid losing accumulated costs\n        saveCurrentSessionCosts()\n\n        // Reset cost state for clean slate before restoring target session\n        resetCostState()\n\n        // Switch session (id + project dir atomically). fullPath may point to\n        // a different project (cross-worktree, /branch); null derives from\n        // current originalCwd.\n        switchSession(\n          asSessionId(sessionId),\n          log.fullPath ? dirname(log.fullPath) : null,\n        )\n        // Rename asciicast recording to match the resumed session ID\n        const { renameRecordingForSession } = await import(\n          '../utils/asciicast.js'\n        )\n        await renameRecordingForSession()\n        await resetSessionFilePointer()\n\n        // Clear then restore session metadata so it's re-appended on exit via\n        // reAppendSessionMetadata. clearSessionMetadata must be called first:\n        // restoreSessionMetadata only sets-if-truthy, so without the clear,\n        // a session without an agent name would inherit the previous session's\n        // cached name and write it to the wrong transcript on first message.\n        clearSessionMetadata()\n        restoreSessionMetadata(log)\n        // Resumed sessions shouldn't re-title from mid-conversation context\n        // (same reasoning as the useRef seed), and the previous session's\n        // Haiku title shouldn't carry over.\n        haikuTitleAttemptedRef.current = true\n        setHaikuTitle(undefined)\n\n        // Exit any worktree a prior /resume entered, then cd into the one\n        // this session was in. Without the exit, resuming from worktree B\n        // to non-worktree C leaves cwd/currentWorktreeSession stale;\n        // resuming B→C where C is also a worktree fails entirely\n        // (getCurrentWorktreeSession guard blocks the switch).\n        //\n        // Skipped for /branch: forkLog doesn't carry worktreeSession, so\n        // this would kick the user out of a worktree they're still working\n        // in. Same fork skip as processResumedConversation for the adopt —\n        // fork materializes its own file via recordTranscript on REPL mount.\n        if (entrypoint !== 'fork') {\n          exitRestoredWorktree()\n          restoreWorktreeForResume(log.worktreeSession)\n          adoptResumedSessionFile()\n          void restoreRemoteAgentTasks({\n            abortController: new AbortController(),\n            getAppState: () => store.getState(),\n            setAppState,\n          })\n        } else {\n          // Fork: same re-persist as /clear (conversation.ts). The clear\n          // above wiped currentSessionWorktree, forkLog doesn't carry it,\n          // and the process is still in the same worktree.\n          const ws = getCurrentWorktreeSession()\n          if (ws) saveWorktreeState(ws)\n        }\n\n        // Persist the current mode so future resumes know what mode this session was in\n        if (feature('COORDINATOR_MODE')) {\n          /* eslint-disable @typescript-eslint/no-require-imports */\n          const { saveMode } = require('../utils/sessionStorage.js')\n          const { isCoordinatorMode } =\n            require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js')\n          /* eslint-enable @typescript-eslint/no-require-imports */\n          saveMode(isCoordinatorMode() ? 'coordinator' : 'normal')\n        }\n\n        // Restore target session's costs from the data we read earlier\n        if (targetSessionCosts) {\n          setCostStateForRestore(targetSessionCosts)\n        }\n\n        // Reconstruct replacement state for the resumed session. Runs after\n        // setSessionId so any NEW replacements post-resume write to the\n        // resumed session's tool-results dir. Gated on ref.current: the\n        // initial mount already read the feature flag, so we don't re-read\n        // it here (mid-session flag flips stay unobservable in both\n        // directions).\n        //\n        // Skipped for in-session /branch: the existing ref is already correct\n        // (branch preserves tool_use_ids), so there's no need to reconstruct.\n        // createFork() does write content-replacement entries to the forked\n        // JSONL with the fork's sessionId, so `claude -r {forkId}` also works.\n        if (contentReplacementStateRef.current && entrypoint !== 'fork') {\n          contentReplacementStateRef.current =\n            reconstructContentReplacementState(\n              messages,\n              log.contentReplacements ?? [],\n            )\n        }\n\n        // Reset messages to the provided initial messages\n        // Use a callback to ensure we're not dependent on stale state\n        setMessages(() => messages)\n\n        // Clear any active tool JSX\n        setToolJSX(null)\n\n        // Clear input to ensure no residual state\n        setInputValue('')\n\n        logEvent('tengu_session_resumed', {\n          entrypoint:\n            entrypoint as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          success: true,\n          resume_duration_ms: Math.round(performance.now() - resumeStart),\n        })\n      } catch (error) {\n        logEvent('tengu_session_resumed', {\n          entrypoint:\n            entrypoint as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          success: false,\n        })\n        throw error\n      }\n    },\n    [resetLoadingState, setAppState],\n  )\n\n  // Lazy init: useRef(createX()) would call createX on every render and\n  // discard the result. LRUCache construction inside FileStateCache is\n  // expensive (~170ms), so we use useState's lazy initializer to create\n  // it exactly once, then feed that stable reference into useRef.\n  const [initialReadFileState] = useState(() =>\n    createFileStateCacheWithSizeLimit(READ_FILE_STATE_CACHE_SIZE),\n  )\n  const readFileState = useRef(initialReadFileState)\n  const bashTools = useRef(new Set<string>())\n  const bashToolsProcessedIdx = useRef(0)\n  // Session-scoped skill discovery tracking (feeds was_discovered on\n  // tengu_skill_tool_invocation). Must persist across getToolUseContext\n  // rebuilds within a session: turn-0 discovery writes via processUserInput\n  // before onQuery builds its own context, and discovery on turn N must\n  // still attribute a SkillTool call on turn N+k. Cleared in clearConversation.\n  const discoveredSkillNamesRef = useRef(new Set<string>())\n  // Session-level dedup for nested_memory CLAUDE.md attachments.\n  // readFileState is a 100-entry LRU; once it evicts a CLAUDE.md path,\n  // the next discovery cycle re-injects it. Cleared in clearConversation.\n  const loadedNestedMemoryPathsRef = useRef(new Set<string>())\n\n  // Helper to restore read file state from messages (used for resume flows)\n  // This allows Claude to edit files that were read in previous sessions\n  const restoreReadFileState = useCallback(\n    (messages: MessageType[], cwd: string) => {\n      const extracted = extractReadFilesFromMessages(\n        messages,\n        cwd,\n        READ_FILE_STATE_CACHE_SIZE,\n      )\n      readFileState.current = mergeFileStateCaches(\n        readFileState.current,\n        extracted,\n      )\n      for (const tool of extractBashToolsFromMessages(messages)) {\n        bashTools.current.add(tool)\n      }\n    },\n    [],\n  )\n\n  // Extract read file state from initialMessages on mount\n  // This handles CLI flag resume (--resume-session) and ResumeConversation screen\n  // where messages are passed as props rather than through the resume callback\n  useEffect(() => {\n    if (initialMessages && initialMessages.length > 0) {\n      restoreReadFileState(initialMessages, getOriginalCwd())\n      void restoreRemoteAgentTasks({\n        abortController: new AbortController(),\n        getAppState: () => store.getState(),\n        setAppState,\n      })\n    }\n    // Only run on mount - initialMessages shouldn't change during component lifetime\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  const { status: apiKeyStatus, reverify } = useApiKeyVerification()\n\n  // Auto-run /issue state\n  const [autoRunIssueReason, setAutoRunIssueReason] =\n    useState<AutoRunIssueReason | null>(null)\n  // Ref to track if autoRunIssue was triggered this survey cycle,\n  // so we can suppress the [1] follow-up prompt even after\n  // autoRunIssueReason is cleared.\n  const didAutoRunIssueRef = useRef(false)\n\n  // State for exit feedback flow\n  const [exitFlow, setExitFlow] = useState<React.ReactNode>(null)\n  const [isExiting, setIsExiting] = useState(false)\n\n  // Calculate if cost dialog should be shown\n  const showingCostDialog = !isLoading && showCostDialog\n\n  // Determine which dialog should have focus (if any)\n  // Permission and interactive dialogs can show even when toolJSX is set,\n  // as long as shouldContinueAnimation is true. This prevents deadlocks when\n  // agents set background hints while waiting for user interaction.\n  function getFocusedInputDialog():\n    | 'message-selector'\n    | 'sandbox-permission'\n    | 'tool-permission'\n    | 'prompt'\n    | 'worker-sandbox-permission'\n    | 'elicitation'\n    | 'cost'\n    | 'idle-return'\n    | 'init-onboarding'\n    | 'ide-onboarding'\n    | 'model-switch'\n    | 'undercover-callout'\n    | 'effort-callout'\n    | 'remote-callout'\n    | 'lsp-recommendation'\n    | 'plugin-hint'\n    | 'desktop-upsell'\n    | 'ultraplan-choice'\n    | 'ultraplan-launch'\n    | undefined {\n    // Exit states always take precedence\n    if (isExiting || exitFlow) return undefined\n\n    // High priority dialogs (always show regardless of typing)\n    if (isMessageSelectorVisible) return 'message-selector'\n\n    // Suppress interrupt dialogs while user is actively typing\n    if (isPromptInputActive) return undefined\n\n    if (sandboxPermissionRequestQueue[0]) return 'sandbox-permission'\n\n    // Permission/interactive dialogs (show unless blocked by toolJSX)\n    const allowDialogsWithAnimation =\n      !toolJSX || toolJSX.shouldContinueAnimation\n\n    if (allowDialogsWithAnimation && toolUseConfirmQueue[0])\n      return 'tool-permission'\n    if (allowDialogsWithAnimation && promptQueue[0]) return 'prompt'\n    // Worker sandbox permission prompts (network access) from swarm workers\n    if (allowDialogsWithAnimation && workerSandboxPermissions.queue[0])\n      return 'worker-sandbox-permission'\n    if (allowDialogsWithAnimation && elicitation.queue[0]) return 'elicitation'\n    if (allowDialogsWithAnimation && showingCostDialog) return 'cost'\n    if (allowDialogsWithAnimation && idleReturnPending) return 'idle-return'\n\n    if (\n      feature('ULTRAPLAN') &&\n      allowDialogsWithAnimation &&\n      !isLoading &&\n      ultraplanPendingChoice\n    )\n      return 'ultraplan-choice'\n\n    if (\n      feature('ULTRAPLAN') &&\n      allowDialogsWithAnimation &&\n      !isLoading &&\n      ultraplanLaunchPending\n    )\n      return 'ultraplan-launch'\n\n    // Onboarding dialogs (special conditions)\n    if (allowDialogsWithAnimation && showIdeOnboarding) return 'ide-onboarding'\n\n    // Model switch callout (ant-only, eliminated from external builds)\n    if (\n      \"external\" === 'ant' &&\n      allowDialogsWithAnimation &&\n      showModelSwitchCallout\n    )\n      return 'model-switch'\n\n    // Undercover auto-enable explainer (ant-only, eliminated from external builds)\n    if (\n      \"external\" === 'ant' &&\n      allowDialogsWithAnimation &&\n      showUndercoverCallout\n    )\n      return 'undercover-callout'\n\n    // Effort callout (shown once for Opus 4.6 users when effort is enabled)\n    if (allowDialogsWithAnimation && showEffortCallout) return 'effort-callout'\n\n    // Remote callout (shown once before first bridge enable)\n    if (allowDialogsWithAnimation && showRemoteCallout) return 'remote-callout'\n\n    // LSP plugin recommendation (lowest priority - non-blocking suggestion)\n    if (allowDialogsWithAnimation && lspRecommendation)\n      return 'lsp-recommendation'\n\n    // Plugin hint from CLI/SDK stderr (same priority band as LSP rec)\n    if (allowDialogsWithAnimation && hintRecommendation) return 'plugin-hint'\n\n    // Desktop app upsell (max 3 launches, lowest priority)\n    if (allowDialogsWithAnimation && showDesktopUpsellStartup)\n      return 'desktop-upsell'\n\n    return undefined\n  }\n\n  const focusedInputDialog = getFocusedInputDialog()\n\n  // True when permission prompts exist but are hidden because the user is typing\n  const hasSuppressedDialogs =\n    isPromptInputActive &&\n    (sandboxPermissionRequestQueue[0] ||\n      toolUseConfirmQueue[0] ||\n      promptQueue[0] ||\n      workerSandboxPermissions.queue[0] ||\n      elicitation.queue[0] ||\n      showingCostDialog)\n\n  // Keep ref in sync so timer callbacks can read the current value\n  focusedInputDialogRef.current = focusedInputDialog\n\n  // Immediately capture pause/resume when focusedInputDialog changes\n  // This ensures accurate timing even under high system load, rather than\n  // relying on the 100ms polling interval to detect state changes\n  useEffect(() => {\n    if (!isLoading) return\n\n    const isPaused = focusedInputDialog === 'tool-permission'\n    const now = Date.now()\n\n    if (isPaused && pauseStartTimeRef.current === null) {\n      // Just entered pause state - record the exact moment\n      pauseStartTimeRef.current = now\n    } else if (!isPaused && pauseStartTimeRef.current !== null) {\n      // Just exited pause state - accumulate paused time immediately\n      totalPausedMsRef.current += now - pauseStartTimeRef.current\n      pauseStartTimeRef.current = null\n    }\n  }, [focusedInputDialog, isLoading])\n\n  // Re-pin scroll to bottom whenever the permission overlay appears or\n  // dismisses. Overlay now renders below messages inside the same\n  // ScrollBox (no remount), so we need an explicit scrollToBottom for:\n  //  - appear: user may have been scrolled up (sticky broken) — the\n  //    dialog is blocking and must be visible\n  //  - dismiss: user may have scrolled up to read context during the\n  //    overlay, and onScroll was suppressed so the pill state is stale\n  // useLayoutEffect so the re-pin commits before the Ink frame renders —\n  // no 1-frame flash of the wrong scroll position.\n  const prevDialogRef = useRef(focusedInputDialog)\n  useLayoutEffect(() => {\n    const was = prevDialogRef.current === 'tool-permission'\n    const now = focusedInputDialog === 'tool-permission'\n    if (was !== now) repinScroll()\n    prevDialogRef.current = focusedInputDialog\n  }, [focusedInputDialog, repinScroll])\n\n  function onCancel() {\n    if (focusedInputDialog === 'elicitation') {\n      // Elicitation dialog handles its own Escape, and closing it shouldn't affect any loading state.\n      return\n    }\n\n    logForDebugging(\n      `[onCancel] focusedInputDialog=${focusedInputDialog} streamMode=${streamMode}`,\n    )\n\n    // Pause proactive mode so the user gets control back.\n    // It will resume when they submit their next input (see onSubmit).\n    if (feature('PROACTIVE') || feature('KAIROS')) {\n      proactiveModule?.pauseProactive()\n    }\n\n    queryGuard.forceEnd()\n    skipIdleCheckRef.current = false\n\n    // Preserve partially-streamed text so the user can read what was\n    // generated before pressing Esc. Pushed before resetLoadingState clears\n    // streamingText, and before query.ts yields the async interrupt marker,\n    // giving final order [user, partial-assistant, [Request interrupted by user]].\n    if (streamingText?.trim()) {\n      setMessages(prev => [\n        ...prev,\n        createAssistantMessage({ content: streamingText }),\n      ])\n    }\n\n    resetLoadingState()\n\n    // Clear any active token budget so the backstop doesn't fire on\n    // a stale budget if the query generator hasn't exited yet.\n    if (feature('TOKEN_BUDGET')) {\n      snapshotOutputTokensForTurn(null)\n    }\n\n    if (focusedInputDialog === 'tool-permission') {\n      // Tool use confirm handles the abort signal itself\n      toolUseConfirmQueue[0]?.onAbort()\n      setToolUseConfirmQueue([])\n    } else if (focusedInputDialog === 'prompt') {\n      // Reject all pending prompts and clear the queue\n      for (const item of promptQueue) {\n        item.reject(new Error('Prompt cancelled by user'))\n      }\n      setPromptQueue([])\n      abortController?.abort('user-cancel')\n    } else if (activeRemote.isRemoteMode) {\n      // Remote mode: send interrupt signal to CCR\n      activeRemote.cancelRequest()\n    } else {\n      abortController?.abort('user-cancel')\n    }\n\n    // Clear the controller so subsequent Escape presses don't see a stale\n    // aborted signal. Without this, canCancelRunningTask is false (signal\n    // defined but .aborted === true), so isActive becomes false if no other\n    // activating conditions hold — leaving the Escape keybinding inactive.\n    setAbortController(null)\n\n    // forceEnd() skips the finally path — fire directly (aborted=true).\n    void mrOnTurnComplete(messagesRef.current, true)\n  }\n\n  // Function to handle queued command when canceling a permission request\n  const handleQueuedCommandOnCancel = useCallback(() => {\n    const result = popAllEditable(inputValue, 0)\n    if (!result) return\n    setInputValue(result.text)\n    setInputMode('prompt')\n\n    // Restore images from queued commands to pastedContents\n    if (result.images.length > 0) {\n      setPastedContents(prev => {\n        const newContents = { ...prev }\n        for (const image of result.images) {\n          newContents[image.id] = image\n        }\n        return newContents\n      })\n    }\n  }, [setInputValue, setInputMode, inputValue, setPastedContents])\n\n  // CancelRequestHandler props - rendered inside KeybindingSetup\n  const cancelRequestProps = {\n    setToolUseConfirmQueue,\n    onCancel,\n    onAgentsKilled: () =>\n      setMessages(prev => [...prev, createAgentsKilledMessage()]),\n    isMessageSelectorVisible: isMessageSelectorVisible || !!showBashesDialog,\n    screen,\n    abortSignal: abortController?.signal,\n    popCommandFromQueue: handleQueuedCommandOnCancel,\n    vimMode,\n    isLocalJSXCommand: toolJSX?.isLocalJSXCommand,\n    isSearchingHistory,\n    isHelpOpen,\n    inputMode,\n    inputValue,\n    streamMode,\n  }\n\n  useEffect(() => {\n    const totalCost = getTotalCost()\n    if (totalCost >= 5 /* $5 */ && !showCostDialog && !haveShownCostDialog) {\n      logEvent('tengu_cost_threshold_reached', {})\n      // Mark as shown even if the dialog won't render (no console billing\n      // access). Otherwise this effect re-fires on every message change for\n      // the rest of the session — 200k+ spurious events observed.\n      setHaveShownCostDialog(true)\n      if (hasConsoleBillingAccess()) {\n        setShowCostDialog(true)\n      }\n    }\n  }, [messages, showCostDialog, haveShownCostDialog])\n\n  const sandboxAskCallback: SandboxAskCallback = useCallback(\n    async (hostPattern: NetworkHostPattern) => {\n      // If running as a swarm worker, forward the request to the leader via mailbox\n      if (isAgentSwarmsEnabled() && isSwarmWorker()) {\n        const requestId = generateSandboxRequestId()\n\n        // Send the request to the leader via mailbox\n        const sent = await sendSandboxPermissionRequestViaMailbox(\n          hostPattern.host,\n          requestId,\n        )\n\n        return new Promise(resolveShouldAllowHost => {\n          if (!sent) {\n            // If we couldn't send via mailbox, fall back to local handling\n            setSandboxPermissionRequestQueue(prev => [\n              ...prev,\n              {\n                hostPattern,\n                resolvePromise: resolveShouldAllowHost,\n              },\n            ])\n            return\n          }\n\n          // Register the callback for when the leader responds\n          registerSandboxPermissionCallback({\n            requestId,\n            host: hostPattern.host,\n            resolve: resolveShouldAllowHost,\n          })\n\n          // Update AppState to show pending indicator\n          setAppState(prev => ({\n            ...prev,\n            pendingSandboxRequest: {\n              requestId,\n              host: hostPattern.host,\n            },\n          }))\n        })\n      }\n\n      // Normal flow for non-workers: show local UI and optionally race\n      // against the REPL bridge (Remote Control) if connected.\n      return new Promise(resolveShouldAllowHost => {\n        let resolved = false\n        function resolveOnce(allow: boolean): void {\n          if (resolved) return\n          resolved = true\n          resolveShouldAllowHost(allow)\n        }\n\n        // Queue the local sandbox permission dialog\n        setSandboxPermissionRequestQueue(prev => [\n          ...prev,\n          {\n            hostPattern,\n            resolvePromise: resolveOnce,\n          },\n        ])\n\n        // When the REPL bridge is connected, also forward the sandbox\n        // permission request as a can_use_tool control_request so the\n        // remote user (e.g. on claude.ai) can approve it too.\n        if (feature('BRIDGE_MODE')) {\n          const bridgeCallbacks = store.getState().replBridgePermissionCallbacks\n          if (bridgeCallbacks) {\n            const bridgeRequestId = randomUUID()\n            bridgeCallbacks.sendRequest(\n              bridgeRequestId,\n              SANDBOX_NETWORK_ACCESS_TOOL_NAME,\n              { host: hostPattern.host },\n              randomUUID(),\n              `Allow network connection to ${hostPattern.host}?`,\n            )\n\n            const unsubscribe = bridgeCallbacks.onResponse(\n              bridgeRequestId,\n              response => {\n                unsubscribe()\n                const allow = response.behavior === 'allow'\n                // Resolve ALL pending requests for the same host, not just\n                // this one — mirrors the local dialog handler pattern.\n                setSandboxPermissionRequestQueue(queue => {\n                  queue\n                    .filter(item => item.hostPattern.host === hostPattern.host)\n                    .forEach(item => item.resolvePromise(allow))\n                  return queue.filter(\n                    item => item.hostPattern.host !== hostPattern.host,\n                  )\n                })\n                // Clean up all sibling bridge subscriptions for this host\n                // (other concurrent same-host requests) before deleting.\n                const siblingCleanups = sandboxBridgeCleanupRef.current.get(\n                  hostPattern.host,\n                )\n                if (siblingCleanups) {\n                  for (const fn of siblingCleanups) {\n                    fn()\n                  }\n                  sandboxBridgeCleanupRef.current.delete(hostPattern.host)\n                }\n              },\n            )\n\n            // Register cleanup so the local dialog handler can cancel\n            // the remote prompt and unsubscribe when the local user\n            // responds first.\n            const cleanup = () => {\n              unsubscribe()\n              bridgeCallbacks.cancelRequest(bridgeRequestId)\n            }\n            const existing =\n              sandboxBridgeCleanupRef.current.get(hostPattern.host) ?? []\n            existing.push(cleanup)\n            sandboxBridgeCleanupRef.current.set(hostPattern.host, existing)\n          }\n        }\n      })\n    },\n    [setAppState, store],\n  )\n\n  // #34044: if user explicitly set sandbox.enabled=true but deps are missing,\n  // isSandboxingEnabled() returns false silently. Surface the reason once at\n  // mount so users know their security config isn't being enforced. Full\n  // reason goes to debug log; notification points to /sandbox for details.\n  // addNotification is stable (useCallback) so the effect fires once.\n  useEffect(() => {\n    const reason = SandboxManager.getSandboxUnavailableReason()\n    if (!reason) return\n    if (SandboxManager.isSandboxRequired()) {\n      process.stderr.write(\n        `\\nError: sandbox required but unavailable: ${reason}\\n` +\n          `  sandbox.failIfUnavailable is set — refusing to start without a working sandbox.\\n\\n`,\n      )\n      gracefulShutdownSync(1, 'other')\n      return\n    }\n    logForDebugging(`sandbox disabled: ${reason}`, { level: 'warn' })\n    addNotification({\n      key: 'sandbox-unavailable',\n      jsx: (\n        <>\n          <Text color=\"warning\">sandbox disabled</Text>\n          <Text dimColor> · /sandbox</Text>\n        </>\n      ),\n      priority: 'medium',\n    })\n  }, [addNotification])\n\n  if (SandboxManager.isSandboxingEnabled()) {\n    // If sandboxing is enabled (setting.sandbox is defined, initialise the manager)\n    SandboxManager.initialize(sandboxAskCallback).catch(err => {\n      // Initialization/validation failed - display error and exit\n      process.stderr.write(`\\n❌ Sandbox Error: ${errorMessage(err)}\\n`)\n      gracefulShutdownSync(1, 'other')\n    })\n  }\n\n  const setToolPermissionContext = useCallback(\n    (context: ToolPermissionContext, options?: { preserveMode?: boolean }) => {\n      setAppState(prev => ({\n        ...prev,\n        toolPermissionContext: {\n          ...context,\n          // Preserve the coordinator's mode only when explicitly requested.\n          // Workers' getAppState() returns a transformed context with mode\n          // 'acceptEdits' that must not leak into the coordinator's actual\n          // state via permission-rule updates — those call sites pass\n          // { preserveMode: true }. User-initiated mode changes (e.g.,\n          // selecting \"allow all edits\") must NOT be overridden.\n          mode: options?.preserveMode\n            ? prev.toolPermissionContext.mode\n            : context.mode,\n        },\n      }))\n\n      // When permission context changes, recheck all queued items\n      // This handles the case where approving item1 with \"don't ask again\"\n      // should auto-approve other queued items that now match the updated rules\n      setImmediate(setToolUseConfirmQueue => {\n        // Use setToolUseConfirmQueue callback to get current queue state\n        // instead of capturing it in the closure, to avoid stale closure issues\n        setToolUseConfirmQueue(currentQueue => {\n          currentQueue.forEach(item => {\n            void item.recheckPermission()\n          })\n          return currentQueue\n        })\n      }, setToolUseConfirmQueue)\n    },\n    [setAppState, setToolUseConfirmQueue],\n  )\n\n  // Register the leader's setToolPermissionContext for in-process teammates\n  useEffect(() => {\n    registerLeaderSetToolPermissionContext(setToolPermissionContext)\n    return () => unregisterLeaderSetToolPermissionContext()\n  }, [setToolPermissionContext])\n\n  const canUseTool = useCanUseTool(\n    setToolUseConfirmQueue,\n    setToolPermissionContext,\n  )\n\n  const requestPrompt = useCallback(\n    (title: string, toolInputSummary?: string | null) =>\n      (request: PromptRequest): Promise<PromptResponse> =>\n        new Promise<PromptResponse>((resolve, reject) => {\n          setPromptQueue(prev => [\n            ...prev,\n            { request, title, toolInputSummary, resolve, reject },\n          ])\n        }),\n    [],\n  )\n\n  const getToolUseContext = useCallback(\n    (\n      messages: MessageType[],\n      newMessages: MessageType[],\n      abortController: AbortController,\n      mainLoopModel: string,\n    ): ProcessUserInputContext => {\n      // Read mutable values fresh from the store rather than closure-capturing\n      // useAppState() snapshots. Same values today (closure is refreshed by the\n      // render between turns); decouples freshness from React's render cycle for\n      // a future headless conversation loop. Same pattern refreshTools() uses.\n      const s = store.getState()\n\n      // Compute tools fresh from store.getState() rather than the closure-\n      // captured `tools`. useManageMCPConnections populates appState.mcp\n      // async as servers connect — the store may have newer MCP state than\n      // the closure captured at render time. Also doubles as refreshTools()\n      // for mid-query tool list updates.\n      const computeTools = () => {\n        const state = store.getState()\n        const assembled = assembleToolPool(\n          state.toolPermissionContext,\n          state.mcp.tools,\n        )\n        const merged = mergeAndFilterTools(\n          combinedInitialTools,\n          assembled,\n          state.toolPermissionContext.mode,\n        )\n        if (!mainThreadAgentDefinition) return merged\n        return resolveAgentTools(mainThreadAgentDefinition, merged, false, true)\n          .resolvedTools\n      }\n\n      return {\n        abortController,\n        options: {\n          commands,\n          tools: computeTools(),\n          debug,\n          verbose: s.verbose,\n          mainLoopModel,\n          thinkingConfig:\n            s.thinkingEnabled !== false ? thinkingConfig : { type: 'disabled' },\n          // Merge fresh from store rather than closing over useMergedClients'\n          // memoized output. initialMcpClients is a prop (session-constant).\n          mcpClients: mergeClients(initialMcpClients, s.mcp.clients),\n          mcpResources: s.mcp.resources,\n          ideInstallationStatus: ideInstallationStatus,\n          isNonInteractiveSession: false,\n          dynamicMcpConfig,\n          theme,\n          agentDefinitions: allowedAgentTypes\n            ? { ...s.agentDefinitions, allowedAgentTypes }\n            : s.agentDefinitions,\n          customSystemPrompt,\n          appendSystemPrompt,\n          refreshTools: computeTools,\n        },\n        getAppState: () => store.getState(),\n        setAppState,\n        messages,\n        setMessages,\n        updateFileHistoryState(\n          updater: (prev: FileHistoryState) => FileHistoryState,\n        ) {\n          // Perf: skip the setState when the updater returns the same reference\n          // (e.g. fileHistoryTrackEdit returns `state` when the file is already\n          // tracked). Otherwise every no-op call would notify all store listeners.\n          setAppState(prev => {\n            const updated = updater(prev.fileHistory)\n            if (updated === prev.fileHistory) return prev\n            return { ...prev, fileHistory: updated }\n          })\n        },\n        updateAttributionState(\n          updater: (prev: AttributionState) => AttributionState,\n        ) {\n          setAppState(prev => {\n            const updated = updater(prev.attribution)\n            if (updated === prev.attribution) return prev\n            return { ...prev, attribution: updated }\n          })\n        },\n        openMessageSelector: () => {\n          if (!disabled) {\n            setIsMessageSelectorVisible(true)\n          }\n        },\n        onChangeAPIKey: reverify,\n        readFileState: readFileState.current,\n        setToolJSX,\n        addNotification,\n        appendSystemMessage: msg => setMessages(prev => [...prev, msg]),\n        sendOSNotification: opts => {\n          void sendNotification(opts, terminal)\n        },\n        onChangeDynamicMcpConfig,\n        onInstallIDEExtension: setIDEToInstallExtension,\n        nestedMemoryAttachmentTriggers: new Set<string>(),\n        loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,\n        dynamicSkillDirTriggers: new Set<string>(),\n        discoveredSkillNames: discoveredSkillNamesRef.current,\n        setResponseLength,\n        pushApiMetricsEntry:\n          \"external\" === 'ant'\n            ? (ttftMs: number) => {\n                const now = Date.now()\n                const baseline = responseLengthRef.current\n                apiMetricsRef.current.push({\n                  ttftMs,\n                  firstTokenTime: now,\n                  lastTokenTime: now,\n                  responseLengthBaseline: baseline,\n                  endResponseLength: baseline,\n                })\n              }\n            : undefined,\n        setStreamMode,\n        onCompactProgress: event => {\n          switch (event.type) {\n            case 'hooks_start':\n              setSpinnerColor('claudeBlue_FOR_SYSTEM_SPINNER')\n              setSpinnerShimmerColor('claudeBlueShimmer_FOR_SYSTEM_SPINNER')\n              setSpinnerMessage(\n                event.hookType === 'pre_compact'\n                  ? 'Running PreCompact hooks\\u2026'\n                  : event.hookType === 'post_compact'\n                    ? 'Running PostCompact hooks\\u2026'\n                    : 'Running SessionStart hooks\\u2026',\n              )\n              break\n            case 'compact_start':\n              setSpinnerMessage('Compacting conversation')\n              break\n            case 'compact_end':\n              setSpinnerMessage(null)\n              setSpinnerColor(null)\n              setSpinnerShimmerColor(null)\n              break\n          }\n        },\n        setInProgressToolUseIDs,\n        setHasInterruptibleToolInProgress: (v: boolean) => {\n          hasInterruptibleToolInProgressRef.current = v\n        },\n        resume,\n        setConversationId,\n        requestPrompt: feature('HOOK_PROMPTS') ? requestPrompt : undefined,\n        contentReplacementState: contentReplacementStateRef.current,\n      }\n    },\n    [\n      commands,\n      combinedInitialTools,\n      mainThreadAgentDefinition,\n      debug,\n      initialMcpClients,\n      ideInstallationStatus,\n      dynamicMcpConfig,\n      theme,\n      allowedAgentTypes,\n      store,\n      setAppState,\n      reverify,\n      addNotification,\n      setMessages,\n      onChangeDynamicMcpConfig,\n      resume,\n      requestPrompt,\n      disabled,\n      customSystemPrompt,\n      appendSystemPrompt,\n      setConversationId,\n    ],\n  )\n\n  // Session backgrounding (Ctrl+B to background/foreground)\n  const handleBackgroundQuery = useCallback(() => {\n    // Stop the foreground query so the background one takes over\n    abortController?.abort('background')\n    // Aborting subagents may produce task-completed notifications.\n    // Clear task notifications so the queue processor doesn't immediately\n    // start a new foreground query; forward them to the background session.\n    const removedNotifications = removeByFilter(\n      cmd => cmd.mode === 'task-notification',\n    )\n\n    void (async () => {\n      const toolUseContext = getToolUseContext(\n        messagesRef.current,\n        [],\n        new AbortController(),\n        mainLoopModel,\n      )\n\n      const [defaultSystemPrompt, userContext, systemContext] =\n        await Promise.all([\n          getSystemPrompt(\n            toolUseContext.options.tools,\n            mainLoopModel,\n            Array.from(\n              toolPermissionContext.additionalWorkingDirectories.keys(),\n            ),\n            toolUseContext.options.mcpClients,\n          ),\n          getUserContext(),\n          getSystemContext(),\n        ])\n\n      const systemPrompt = buildEffectiveSystemPrompt({\n        mainThreadAgentDefinition,\n        toolUseContext,\n        customSystemPrompt,\n        defaultSystemPrompt,\n        appendSystemPrompt,\n      })\n      toolUseContext.renderedSystemPrompt = systemPrompt\n\n      const notificationAttachments = await getQueuedCommandAttachments(\n        removedNotifications,\n      ).catch(() => [])\n      const notificationMessages = notificationAttachments.map(\n        createAttachmentMessage,\n      )\n\n      // Deduplicate: if the query loop already yielded a notification into\n      // messagesRef before we removed it from the queue, skip duplicates.\n      // We use prompt text for dedup because source_uuid is not set on\n      // task-notification QueuedCommands (enqueuePendingNotification callers\n      // don't pass uuid), so it would always be undefined.\n      const existingPrompts = new Set<string>()\n      for (const m of messagesRef.current) {\n        if (\n          m.type === 'attachment' &&\n          m.attachment.type === 'queued_command' &&\n          m.attachment.commandMode === 'task-notification' &&\n          typeof m.attachment.prompt === 'string'\n        ) {\n          existingPrompts.add(m.attachment.prompt)\n        }\n      }\n      const uniqueNotifications = notificationMessages.filter(\n        m =>\n          m.attachment.type === 'queued_command' &&\n          (typeof m.attachment.prompt !== 'string' ||\n            !existingPrompts.has(m.attachment.prompt)),\n      )\n\n      startBackgroundSession({\n        messages: [...messagesRef.current, ...uniqueNotifications],\n        queryParams: {\n          systemPrompt,\n          userContext,\n          systemContext,\n          canUseTool,\n          toolUseContext,\n          querySource: getQuerySourceForREPL(),\n        },\n        description: terminalTitle,\n        setAppState,\n        agentDefinition: mainThreadAgentDefinition,\n      })\n    })()\n  }, [\n    abortController,\n    mainLoopModel,\n    toolPermissionContext,\n    mainThreadAgentDefinition,\n    getToolUseContext,\n    customSystemPrompt,\n    appendSystemPrompt,\n    canUseTool,\n    setAppState,\n  ])\n\n  const { handleBackgroundSession } = useSessionBackgrounding({\n    setMessages,\n    setIsLoading: setIsExternalLoading,\n    resetLoadingState,\n    setAbortController,\n    onBackgroundQuery: handleBackgroundQuery,\n  })\n\n  const onQueryEvent = useCallback(\n    (event: Parameters<typeof handleMessageFromStream>[0]) => {\n      handleMessageFromStream(\n        event,\n        newMessage => {\n          if (isCompactBoundaryMessage(newMessage)) {\n            // Fullscreen: keep pre-compact messages for scrollback. query.ts\n            // slices at the boundary for API calls, Messages.tsx skips the\n            // boundary filter in fullscreen, and useLogMessages treats this\n            // as an incremental append (first uuid unchanged). Cap at one\n            // compact-interval of scrollback — normalizeMessages/applyGrouping\n            // are O(n) per render, so drop everything before the previous\n            // boundary to keep n bounded across multi-day sessions.\n            if (isFullscreenEnvEnabled()) {\n              setMessages(old => [\n                ...getMessagesAfterCompactBoundary(old, {\n                  includeSnipped: true,\n                }),\n                newMessage,\n              ])\n            } else {\n              setMessages(() => [newMessage])\n            }\n            // Bump conversationId so Messages.tsx row keys change and\n            // stale memoized rows remount with post-compact content.\n            setConversationId(randomUUID())\n            // Compaction succeeded — clear the context-blocked flag so ticks resume\n            if (feature('PROACTIVE') || feature('KAIROS')) {\n              proactiveModule?.setContextBlocked(false)\n            }\n          } else if (\n            newMessage.type === 'progress' &&\n            isEphemeralToolProgress(newMessage.data.type)\n          ) {\n            // Replace the previous ephemeral progress tick for the same tool\n            // call instead of appending. Sleep/Bash emit a tick per second and\n            // only the last one is rendered; appending blows up the messages\n            // array (13k+ observed) and the transcript (120MB of sleep_progress\n            // lines). useLogMessages tracks length, so same-length replacement\n            // also skips the transcript write.\n            // agent_progress / hook_progress / skill_progress are NOT ephemeral\n            // — each carries distinct state the UI needs (e.g. subagent tool\n            // history). Replacing those leaves the AgentTool UI stuck at\n            // \"Initializing…\" because it renders the full progress trail.\n            setMessages(oldMessages => {\n              const last = oldMessages.at(-1)\n              if (\n                last?.type === 'progress' &&\n                last.parentToolUseID === newMessage.parentToolUseID &&\n                last.data.type === newMessage.data.type\n              ) {\n                const copy = oldMessages.slice()\n                copy[copy.length - 1] = newMessage\n                return copy\n              }\n              return [...oldMessages, newMessage]\n            })\n          } else {\n            setMessages(oldMessages => [...oldMessages, newMessage])\n          }\n          // Block ticks on API errors to prevent tick → error → tick\n          // runaway loops (e.g., auth failure, rate limit, blocking limit).\n          // Cleared on compact boundary (above) or successful response (below).\n          if (feature('PROACTIVE') || feature('KAIROS')) {\n            if (\n              newMessage.type === 'assistant' &&\n              'isApiErrorMessage' in newMessage &&\n              newMessage.isApiErrorMessage\n            ) {\n              proactiveModule?.setContextBlocked(true)\n            } else if (newMessage.type === 'assistant') {\n              proactiveModule?.setContextBlocked(false)\n            }\n          }\n        },\n        newContent => {\n          // setResponseLength handles updating both responseLengthRef (for\n          // spinner animation) and apiMetricsRef (endResponseLength/lastTokenTime\n          // for OTPS). No separate metrics update needed here.\n          setResponseLength(length => length + newContent.length)\n        },\n        setStreamMode,\n        setStreamingToolUses,\n        tombstonedMessage => {\n          setMessages(oldMessages =>\n            oldMessages.filter(m => m !== tombstonedMessage),\n          )\n          void removeTranscriptMessage(tombstonedMessage.uuid)\n        },\n        setStreamingThinking,\n        metrics => {\n          const now = Date.now()\n          const baseline = responseLengthRef.current\n          apiMetricsRef.current.push({\n            ...metrics,\n            firstTokenTime: now,\n            lastTokenTime: now,\n            responseLengthBaseline: baseline,\n            endResponseLength: baseline,\n          })\n        },\n        onStreamingText,\n      )\n    },\n    [\n      setMessages,\n      setResponseLength,\n      setStreamMode,\n      setStreamingToolUses,\n      setStreamingThinking,\n      onStreamingText,\n    ],\n  )\n\n  const onQueryImpl = useCallback(\n    async (\n      messagesIncludingNewMessages: MessageType[],\n      newMessages: MessageType[],\n      abortController: AbortController,\n      shouldQuery: boolean,\n      additionalAllowedTools: string[],\n      mainLoopModelParam: string,\n      effort?: EffortValue,\n    ) => {\n      // Prepare IDE integration for new prompt. Read mcpClients fresh from\n      // store — useManageMCPConnections may have populated it since the\n      // render that captured this closure (same pattern as computeTools).\n      if (shouldQuery) {\n        const freshClients = mergeClients(\n          initialMcpClients,\n          store.getState().mcp.clients,\n        )\n        void diagnosticTracker.handleQueryStart(freshClients)\n        const ideClient = getConnectedIdeClient(freshClients)\n        if (ideClient) {\n          void closeOpenDiffs(ideClient)\n        }\n      }\n\n      // Mark onboarding as complete when any user message is sent to Claude\n      void maybeMarkProjectOnboardingComplete()\n\n      // Extract a session title from the first real user message. One-shot\n      // via ref (was tengu_birch_mist experiment: first-message-only to save\n      // Haiku calls). The ref replaces the old `messages.length <= 1` check,\n      // which was broken by SessionStart hook messages (prepended via\n      // useDeferredHookMessages) and attachment messages (appended by\n      // processTextPrompt) — both pushed length past 1 on turn one, so the\n      // title silently fell through to the \"Claude Code\" default.\n      if (\n        !titleDisabled &&\n        !sessionTitle &&\n        !agentTitle &&\n        !haikuTitleAttemptedRef.current\n      ) {\n        const firstUserMessage = newMessages.find(\n          m => m.type === 'user' && !m.isMeta,\n        )\n        const text =\n          firstUserMessage?.type === 'user'\n            ? getContentText(firstUserMessage.message.content)\n            : null\n        // Skip synthetic breadcrumbs — slash-command output, prompt-skill\n        // expansions (/commit → <command-message>), local-command headers\n        // (/help → <command-name>), and bash-mode (!cmd → <bash-input>).\n        // None of these are the user's topic; wait for real prose.\n        if (\n          text &&\n          !text.startsWith(`<${LOCAL_COMMAND_STDOUT_TAG}>`) &&\n          !text.startsWith(`<${COMMAND_MESSAGE_TAG}>`) &&\n          !text.startsWith(`<${COMMAND_NAME_TAG}>`) &&\n          !text.startsWith(`<${BASH_INPUT_TAG}>`)\n        ) {\n          haikuTitleAttemptedRef.current = true\n          void generateSessionTitle(text, new AbortController().signal).then(\n            title => {\n              if (title) setHaikuTitle(title)\n              else haikuTitleAttemptedRef.current = false\n            },\n            () => {\n              haikuTitleAttemptedRef.current = false\n            },\n          )\n        }\n      }\n\n      // Apply slash-command-scoped allowedTools (from skill frontmatter) to the\n      // store once per turn. This also covers the reset: the next non-skill turn\n      // passes [] and clears it. Must run before the !shouldQuery gate: forked\n      // commands (executeForkedSlashCommand) return shouldQuery=false, and\n      // createGetAppStateWithAllowedTools in forkedAgent.ts reads this field, so\n      // stale skill tools would otherwise leak into forked agent permissions.\n      // Previously this write was hidden inside getToolUseContext's getAppState\n      // (~85 calls/turn); hoisting it here makes getAppState a pure read and stops\n      // ephemeral contexts (permission dialog, BackgroundTasksDialog) from\n      // accidentally clearing it mid-turn.\n      store.setState(prev => {\n        const cur = prev.toolPermissionContext.alwaysAllowRules.command\n        if (\n          cur === additionalAllowedTools ||\n          (cur?.length === additionalAllowedTools.length &&\n            cur.every((v, i) => v === additionalAllowedTools[i]))\n        ) {\n          return prev\n        }\n        return {\n          ...prev,\n          toolPermissionContext: {\n            ...prev.toolPermissionContext,\n            alwaysAllowRules: {\n              ...prev.toolPermissionContext.alwaysAllowRules,\n              command: additionalAllowedTools,\n            },\n          },\n        }\n      })\n\n      // The last message is an assistant message if the user input was a bash command,\n      // or if the user input was an invalid slash command.\n      if (!shouldQuery) {\n        // Manual /compact sets messages directly (shouldQuery=false) bypassing\n        // handleMessageFromStream. Clear context-blocked if a compact boundary\n        // is present so proactive ticks resume after compaction.\n        if (newMessages.some(isCompactBoundaryMessage)) {\n          // Bump conversationId so Messages.tsx row keys change and\n          // stale memoized rows remount with post-compact content.\n          setConversationId(randomUUID())\n          if (feature('PROACTIVE') || feature('KAIROS')) {\n            proactiveModule?.setContextBlocked(false)\n          }\n        }\n        resetLoadingState()\n        setAbortController(null)\n        return\n      }\n\n      const toolUseContext = getToolUseContext(\n        messagesIncludingNewMessages,\n        newMessages,\n        abortController,\n        mainLoopModelParam,\n      )\n      // getToolUseContext reads tools/mcpClients fresh from store.getState()\n      // (via computeTools/mergeClients). Use those rather than the closure-\n      // captured `tools`/`mcpClients` — useManageMCPConnections may have\n      // flushed new MCP state between the render that captured this closure\n      // and now. Turn 1 via processInitialMessage is the main beneficiary.\n      const { tools: freshTools, mcpClients: freshMcpClients } =\n        toolUseContext.options\n\n      // Scope the skill's effort override to this turn's context only —\n      // wrapping getAppState keeps the override out of the global store so\n      // background agents and UI subscribers (Spinner, LogoV2) never see it.\n      if (effort !== undefined) {\n        const previousGetAppState = toolUseContext.getAppState\n        toolUseContext.getAppState = () => ({\n          ...previousGetAppState(),\n          effortValue: effort,\n        })\n      }\n\n      queryCheckpoint('query_context_loading_start')\n      const [, , defaultSystemPrompt, baseUserContext, systemContext] =\n        await Promise.all([\n          // IMPORTANT: do this after setMessages() above, to avoid UI jank\n          checkAndDisableBypassPermissionsIfNeeded(\n            toolPermissionContext,\n            setAppState,\n          ),\n          // Gated on TRANSCRIPT_CLASSIFIER so GrowthBook kill switch runs wherever auto mode is built in\n          feature('TRANSCRIPT_CLASSIFIER')\n            ? checkAndDisableAutoModeIfNeeded(\n                toolPermissionContext,\n                setAppState,\n                store.getState().fastMode,\n              )\n            : undefined,\n          getSystemPrompt(\n            freshTools,\n            mainLoopModelParam,\n            Array.from(\n              toolPermissionContext.additionalWorkingDirectories.keys(),\n            ),\n            freshMcpClients,\n          ),\n          getUserContext(),\n          getSystemContext(),\n        ])\n      const userContext = {\n        ...baseUserContext,\n        ...getCoordinatorUserContext(\n          freshMcpClients,\n          isScratchpadEnabled() ? getScratchpadDir() : undefined,\n        ),\n        ...((feature('PROACTIVE') || feature('KAIROS')) &&\n        proactiveModule?.isProactiveActive() &&\n        !terminalFocusRef.current\n          ? {\n              terminalFocus:\n                'The terminal is unfocused \\u2014 the user is not actively watching.',\n            }\n          : {}),\n      }\n      queryCheckpoint('query_context_loading_end')\n\n      const systemPrompt = buildEffectiveSystemPrompt({\n        mainThreadAgentDefinition,\n        toolUseContext,\n        customSystemPrompt,\n        defaultSystemPrompt,\n        appendSystemPrompt,\n      })\n      toolUseContext.renderedSystemPrompt = systemPrompt\n\n      queryCheckpoint('query_query_start')\n      resetTurnHookDuration()\n      resetTurnToolDuration()\n      resetTurnClassifierDuration()\n\n      for await (const event of query({\n        messages: messagesIncludingNewMessages,\n        systemPrompt,\n        userContext,\n        systemContext,\n        canUseTool,\n        toolUseContext,\n        querySource: getQuerySourceForREPL(),\n      })) {\n        onQueryEvent(event)\n      }\n\n\n      if (feature('BUDDY')) {\n        void fireCompanionObserver(messagesRef.current, reaction =>\n          setAppState(prev =>\n            prev.companionReaction === reaction\n              ? prev\n              : { ...prev, companionReaction: reaction },\n          ),\n        )\n      }\n\n      queryCheckpoint('query_end')\n\n      // Capture ant-only API metrics before resetLoadingState clears the ref.\n      // For multi-request turns (tool use loops), compute P50 across all requests.\n      if (\"external\" === 'ant' && apiMetricsRef.current.length > 0) {\n        const entries = apiMetricsRef.current\n\n        const ttfts = entries.map(e => e.ttftMs)\n        // Compute per-request OTPS using only active streaming time and\n        // streaming-only content. endResponseLength tracks content added by\n        // streaming deltas only, excluding subagent/compaction inflation.\n        const otpsValues = entries.map(e => {\n          const delta = Math.round(\n            (e.endResponseLength - e.responseLengthBaseline) / 4,\n          )\n          const samplingMs = e.lastTokenTime - e.firstTokenTime\n          return samplingMs > 0 ? Math.round(delta / (samplingMs / 1000)) : 0\n        })\n\n        const isMultiRequest = entries.length > 1\n        const hookMs = getTurnHookDurationMs()\n        const hookCount = getTurnHookCount()\n        const toolMs = getTurnToolDurationMs()\n        const toolCount = getTurnToolCount()\n        const classifierMs = getTurnClassifierDurationMs()\n        const classifierCount = getTurnClassifierCount()\n        const turnMs = Date.now() - loadingStartTimeRef.current\n        setMessages(prev => [\n          ...prev,\n          createApiMetricsMessage({\n            ttftMs: isMultiRequest ? median(ttfts) : ttfts[0]!,\n            otps: isMultiRequest ? median(otpsValues) : otpsValues[0]!,\n            isP50: isMultiRequest,\n            hookDurationMs: hookMs > 0 ? hookMs : undefined,\n            hookCount: hookCount > 0 ? hookCount : undefined,\n            turnDurationMs: turnMs > 0 ? turnMs : undefined,\n            toolDurationMs: toolMs > 0 ? toolMs : undefined,\n            toolCount: toolCount > 0 ? toolCount : undefined,\n            classifierDurationMs: classifierMs > 0 ? classifierMs : undefined,\n            classifierCount: classifierCount > 0 ? classifierCount : undefined,\n            configWriteCount: getGlobalConfigWriteCount(),\n          }),\n        ])\n      }\n\n      resetLoadingState()\n\n      // Log query profiling report if enabled\n      logQueryProfileReport()\n\n      // Signal that a query turn has completed successfully\n      await onTurnComplete?.(messagesRef.current)\n    },\n    [\n      initialMcpClients,\n      resetLoadingState,\n      getToolUseContext,\n      toolPermissionContext,\n      setAppState,\n      customSystemPrompt,\n      onTurnComplete,\n      appendSystemPrompt,\n      canUseTool,\n      mainThreadAgentDefinition,\n      onQueryEvent,\n      sessionTitle,\n      titleDisabled,\n    ],\n  )\n\n  const onQuery = useCallback(\n    async (\n      newMessages: MessageType[],\n      abortController: AbortController,\n      shouldQuery: boolean,\n      additionalAllowedTools: string[],\n      mainLoopModelParam: string,\n      onBeforeQueryCallback?: (\n        input: string,\n        newMessages: MessageType[],\n      ) => Promise<boolean>,\n      input?: string,\n      effort?: EffortValue,\n    ): Promise<void> => {\n      // If this is a teammate, mark them as active when starting a turn\n      if (isAgentSwarmsEnabled()) {\n        const teamName = getTeamName()\n        const agentName = getAgentName()\n        if (teamName && agentName) {\n          // Fire and forget - turn starts immediately, write happens in background\n          void setMemberActive(teamName, agentName, true)\n        }\n      }\n\n      // Concurrent guard via state machine. tryStart() atomically checks\n      // and transitions idle→running, returning the generation number.\n      // Returns null if already running — no separate check-then-set.\n      const thisGeneration = queryGuard.tryStart()\n      if (thisGeneration === null) {\n        logEvent('tengu_concurrent_onquery_detected', {})\n\n        // Extract and enqueue user message text, skipping meta messages\n        // (e.g. expanded skill content, tick prompts) that should not be\n        // replayed as user-visible text.\n        newMessages\n          .filter((m): m is UserMessage => m.type === 'user' && !m.isMeta)\n          .map(_ => getContentText(_.message.content))\n          .filter(_ => _ !== null)\n          .forEach((msg, i) => {\n            enqueue({ value: msg, mode: 'prompt' })\n            if (i === 0) {\n              logEvent('tengu_concurrent_onquery_enqueued', {})\n            }\n          })\n        return\n      }\n\n      try {\n        // isLoading is derived from queryGuard — tryStart() above already\n        // transitioned dispatching→running, so no setter call needed here.\n        resetTimingRefs()\n        setMessages(oldMessages => [...oldMessages, ...newMessages])\n        responseLengthRef.current = 0\n        if (feature('TOKEN_BUDGET')) {\n          const parsedBudget = input ? parseTokenBudget(input) : null\n          snapshotOutputTokensForTurn(\n            parsedBudget ?? getCurrentTurnTokenBudget(),\n          )\n        }\n        apiMetricsRef.current = []\n        setStreamingToolUses([])\n        setStreamingText(null)\n\n        // messagesRef is updated synchronously by the setMessages wrapper\n        // above, so it already includes newMessages from the append at the\n        // top of this try block.  No reconstruction needed, no waiting for\n        // React's scheduler (previously cost 20-56ms per prompt; the 56ms\n        // case was a GC pause caught during the await).\n        const latestMessages = messagesRef.current\n\n        if (input) {\n          await mrOnBeforeQuery(input, latestMessages, newMessages.length)\n        }\n\n        // Pass full conversation history to callback\n        if (onBeforeQueryCallback && input) {\n          const shouldProceed = await onBeforeQueryCallback(\n            input,\n            latestMessages,\n          )\n          if (!shouldProceed) {\n            return\n          }\n        }\n\n        await onQueryImpl(\n          latestMessages,\n          newMessages,\n          abortController,\n          shouldQuery,\n          additionalAllowedTools,\n          mainLoopModelParam,\n          effort,\n        )\n      } finally {\n        // queryGuard.end() atomically checks generation and transitions\n        // running→idle. Returns false if a newer query owns the guard\n        // (cancel+resubmit race where the stale finally fires as a microtask).\n        if (queryGuard.end(thisGeneration)) {\n          setLastQueryCompletionTime(Date.now())\n          skipIdleCheckRef.current = false\n          // Always reset loading state in finally - this ensures cleanup even\n          // if onQueryImpl throws. onTurnComplete is called separately in\n          // onQueryImpl only on successful completion.\n          resetLoadingState()\n\n          await mrOnTurnComplete(\n            messagesRef.current,\n            abortController.signal.aborted,\n          )\n\n          // Notify bridge clients that the turn is complete so mobile apps\n          // can stop the spark animation and show post-turn UI.\n          sendBridgeResultRef.current()\n\n          // Auto-hide tungsten panel content at turn end (ant-only), but keep\n          // tungstenActiveSession set so the pill stays in the footer and the user\n          // can reopen the panel. Background tmux tasks (e.g. /hunter) run for\n          // minutes — wiping the session made the pill disappear entirely, forcing\n          // the user to re-invoke Tmux just to peek. Skip on abort so the panel\n          // stays open for inspection (matches the turn-duration guard below).\n          if (\n            \"external\" === 'ant' &&\n            !abortController.signal.aborted\n          ) {\n            setAppState(prev => {\n              if (prev.tungstenActiveSession === undefined) return prev\n              if (prev.tungstenPanelAutoHidden === true) return prev\n              return { ...prev, tungstenPanelAutoHidden: true }\n            })\n          }\n\n          // Capture budget info before clearing (ant-only)\n          let budgetInfo:\n            | { tokens: number; limit: number; nudges: number }\n            | undefined\n          if (feature('TOKEN_BUDGET')) {\n            if (\n              getCurrentTurnTokenBudget() !== null &&\n              getCurrentTurnTokenBudget()! > 0 &&\n              !abortController.signal.aborted\n            ) {\n              budgetInfo = {\n                tokens: getTurnOutputTokens(),\n                limit: getCurrentTurnTokenBudget()!,\n                nudges: getBudgetContinuationCount(),\n              }\n            }\n            snapshotOutputTokensForTurn(null)\n          }\n\n          // Add turn duration message for turns longer than 30s or with a budget\n          // Skip if user aborted or if in loop mode (too noisy between ticks)\n          // Defer if swarm teammates are still running (show when they finish)\n          const turnDurationMs =\n            Date.now() - loadingStartTimeRef.current - totalPausedMsRef.current\n          if (\n            (turnDurationMs > 30000 || budgetInfo !== undefined) &&\n            !abortController.signal.aborted &&\n            !proactiveActive\n          ) {\n            const hasRunningSwarmAgents = getAllInProcessTeammateTasks(\n              store.getState().tasks,\n            ).some(t => t.status === 'running')\n            if (hasRunningSwarmAgents) {\n              // Only record start time on the first deferred turn\n              if (swarmStartTimeRef.current === null) {\n                swarmStartTimeRef.current = loadingStartTimeRef.current\n              }\n              // Always update budget — later turns may carry the actual budget\n              if (budgetInfo) {\n                swarmBudgetInfoRef.current = budgetInfo\n              }\n            } else {\n              setMessages(prev => [\n                ...prev,\n                createTurnDurationMessage(\n                  turnDurationMs,\n                  budgetInfo,\n                  count(prev, isLoggableMessage),\n                ),\n              ])\n            }\n          }\n          // Clear the controller so CancelRequestHandler's canCancelRunningTask\n          // reads false at the idle prompt. Without this, the stale non-aborted\n          // controller makes ctrl+c fire onCancel() (aborting nothing) instead of\n          // propagating to the double-press exit flow.\n          setAbortController(null)\n        }\n\n        // Auto-restore: if the user interrupted before any meaningful response\n        // arrived, rewind the conversation and restore their prompt — same as\n        // opening the message selector and picking the last message.\n        // This runs OUTSIDE the queryGuard.end() check because onCancel calls\n        // forceEnd(), which bumps the generation so end() returns false above.\n        // Guards: reason === 'user-cancel' (onCancel/Esc; programmatic aborts\n        // use 'background'/'interrupt' and must not rewind — note abort() with\n        // no args sets reason to a DOMException, not undefined), !isActive (no\n        // newer query started — cancel+resubmit race), empty input (don't\n        // clobber text typed during loading), no queued commands (user queued\n        // B while A was loading → they've moved on, don't restore A; also\n        // avoids removeLastFromHistory removing B's entry instead of A's),\n        // not viewing a teammate (messagesRef is the main conversation — the\n        // old Up-arrow quick-restore had this guard, preserve it).\n        if (\n          abortController.signal.reason === 'user-cancel' &&\n          !queryGuard.isActive &&\n          inputValueRef.current === '' &&\n          getCommandQueueLength() === 0 &&\n          !store.getState().viewingAgentTaskId\n        ) {\n          const msgs = messagesRef.current\n          const lastUserMsg = msgs.findLast(selectableUserMessagesFilter)\n          if (lastUserMsg) {\n            const idx = msgs.lastIndexOf(lastUserMsg)\n            if (messagesAfterAreOnlySynthetic(msgs, idx)) {\n              // The submit is being undone — undo its history entry too,\n              // otherwise Up-arrow shows the restored text twice.\n              removeLastFromHistory()\n              restoreMessageSyncRef.current(lastUserMsg)\n            }\n          }\n        }\n      }\n    },\n    [\n      onQueryImpl,\n      setAppState,\n      resetLoadingState,\n      queryGuard,\n      mrOnBeforeQuery,\n      mrOnTurnComplete,\n    ],\n  )\n\n  // Handle initial message (from CLI args or plan mode exit with context clear)\n  // This effect runs when isLoading becomes false and there's a pending message\n  const initialMessageRef = useRef(false)\n  useEffect(() => {\n    const pending = initialMessage\n    if (!pending || isLoading || initialMessageRef.current) return\n\n    // Mark as processing to prevent re-entry\n    initialMessageRef.current = true\n\n    async function processInitialMessage(\n      initialMsg: NonNullable<typeof pending>,\n    ) {\n      // Clear context if requested (plan mode exit)\n      if (initialMsg.clearContext) {\n        // Preserve the plan slug before clearing context, so the new session\n        // can access the same plan file after regenerateSessionId()\n        const oldPlanSlug = initialMsg.message.planContent\n          ? getPlanSlug()\n          : undefined\n\n        const { clearConversation } = await import(\n          '../commands/clear/conversation.js'\n        )\n        await clearConversation({\n          setMessages,\n          readFileState: readFileState.current,\n          discoveredSkillNames: discoveredSkillNamesRef.current,\n          loadedNestedMemoryPaths: loadedNestedMemoryPathsRef.current,\n          getAppState: () => store.getState(),\n          setAppState,\n          setConversationId,\n        })\n        haikuTitleAttemptedRef.current = false\n        setHaikuTitle(undefined)\n        bashTools.current.clear()\n        bashToolsProcessedIdx.current = 0\n\n        // Restore the plan slug for the new session so getPlan() finds the file\n        if (oldPlanSlug) {\n          setPlanSlug(getSessionId(), oldPlanSlug)\n        }\n      }\n\n      // Atomically: clear initial message, set permission mode and rules, and store plan for verification\n      const shouldStorePlanForVerification =\n        initialMsg.message.planContent &&\n        \"external\" === 'ant' &&\n        isEnvTruthy(undefined)\n\n      setAppState(prev => {\n        // Build and apply permission updates (mode + allowedPrompts rules)\n        let updatedToolPermissionContext = initialMsg.mode\n          ? applyPermissionUpdates(\n              prev.toolPermissionContext,\n              buildPermissionUpdates(\n                initialMsg.mode,\n                initialMsg.allowedPrompts,\n              ),\n            )\n          : prev.toolPermissionContext\n        // For auto, override the mode (buildPermissionUpdates maps\n        // it to 'default' via toExternalPermissionMode) and strip dangerous rules\n        if (feature('TRANSCRIPT_CLASSIFIER') && initialMsg.mode === 'auto') {\n          updatedToolPermissionContext = stripDangerousPermissionsForAutoMode({\n            ...updatedToolPermissionContext,\n            mode: 'auto',\n            prePlanMode: undefined,\n          })\n        }\n\n        return {\n          ...prev,\n          initialMessage: null,\n          toolPermissionContext: updatedToolPermissionContext,\n          ...(shouldStorePlanForVerification && {\n            pendingPlanVerification: {\n              plan: initialMsg.message.planContent!,\n              verificationStarted: false,\n              verificationCompleted: false,\n            },\n          }),\n        }\n      })\n\n      // Create file history snapshot for code rewind\n      if (fileHistoryEnabled()) {\n        void fileHistoryMakeSnapshot(\n          (updater: (prev: FileHistoryState) => FileHistoryState) => {\n            setAppState(prev => ({\n              ...prev,\n              fileHistory: updater(prev.fileHistory),\n            }))\n          },\n          initialMsg.message.uuid,\n        )\n      }\n\n      // Ensure SessionStart hook context is available before the first API\n      // call. onSubmit calls this internally but the onQuery path below\n      // bypasses onSubmit — hoist here so both paths see hook messages.\n      await awaitPendingHooks()\n\n      // Route all initial prompts through onSubmit to ensure UserPromptSubmit hooks fire\n      // TODO: Simplify by always routing through onSubmit once it supports\n      // ContentBlockParam arrays (images) as input\n      const content = initialMsg.message.message.content\n\n      // Route all string content through onSubmit to ensure hooks fire\n      // For complex content (images, etc.), fall back to direct onQuery\n      // Plan messages bypass onSubmit to preserve planContent metadata for rendering\n      if (typeof content === 'string' && !initialMsg.message.planContent) {\n        // Route through onSubmit for proper processing including UserPromptSubmit hooks\n        void onSubmit(content, {\n          setCursorOffset: () => {},\n          clearBuffer: () => {},\n          resetHistory: () => {},\n        })\n      } else {\n        // Plan messages or complex content (images, etc.) - send directly to model\n        // Plan messages use onQuery to preserve planContent metadata for rendering\n        // TODO: Once onSubmit supports ContentBlockParam arrays, remove this branch\n        const newAbortController = createAbortController()\n        setAbortController(newAbortController)\n\n        void onQuery(\n          [initialMsg.message],\n          newAbortController,\n          true, // shouldQuery\n          [], // additionalAllowedTools\n          mainLoopModel,\n        )\n      }\n\n      // Reset ref after a delay to allow new initial messages\n      setTimeout(\n        ref => {\n          ref.current = false\n        },\n        100,\n        initialMessageRef,\n      )\n    }\n\n    void processInitialMessage(pending)\n  }, [\n    initialMessage,\n    isLoading,\n    setMessages,\n    setAppState,\n    onQuery,\n    mainLoopModel,\n    tools,\n  ])\n\n  const onSubmit = useCallback(\n    async (\n      input: string,\n      helpers: PromptInputHelpers,\n      speculationAccept?: {\n        state: ActiveSpeculationState\n        speculationSessionTimeSavedMs: number\n        setAppState: SetAppState\n      },\n      options?: { fromKeybinding?: boolean },\n    ) => {\n      // Re-pin scroll to bottom on submit so the user always sees the new\n      // exchange (matches OpenCode's auto-scroll behavior).\n      repinScroll()\n\n      // Resume loop mode if paused\n      if (feature('PROACTIVE') || feature('KAIROS')) {\n        proactiveModule?.resumeProactive()\n      }\n\n      // Handle immediate commands - these bypass the queue and execute right away\n      // even while Claude is processing. Commands opt-in via `immediate: true`.\n      // Commands triggered via keybindings are always treated as immediate.\n      if (!speculationAccept && input.trim().startsWith('/')) {\n        // Expand [Pasted text #N] refs so immediate commands (e.g. /btw) receive\n        // the pasted content, not the placeholder. The non-immediate path gets\n        // this expansion later in handlePromptSubmit.\n        const trimmedInput = expandPastedTextRefs(input, pastedContents).trim()\n        const spaceIndex = trimmedInput.indexOf(' ')\n        const commandName =\n          spaceIndex === -1\n            ? trimmedInput.slice(1)\n            : trimmedInput.slice(1, spaceIndex)\n        const commandArgs =\n          spaceIndex === -1 ? '' : trimmedInput.slice(spaceIndex + 1).trim()\n\n        // Find matching command - treat as immediate if:\n        // 1. Command has `immediate: true`, OR\n        // 2. Command was triggered via keybinding (fromKeybinding option)\n        const matchingCommand = commands.find(\n          cmd =>\n            isCommandEnabled(cmd) &&\n            (cmd.name === commandName ||\n              cmd.aliases?.includes(commandName) ||\n              getCommandName(cmd) === commandName),\n        )\n        if (matchingCommand?.name === 'clear' && idleHintShownRef.current) {\n          logEvent('tengu_idle_return_action', {\n            action:\n              'hint_converted' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            variant:\n              idleHintShownRef.current as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            idleMinutes: Math.round(\n              (Date.now() - lastQueryCompletionTimeRef.current) / 60_000,\n            ),\n            messageCount: messagesRef.current.length,\n            totalInputTokens: getTotalInputTokens(),\n          })\n          idleHintShownRef.current = false\n        }\n\n        const shouldTreatAsImmediate =\n          queryGuard.isActive &&\n          (matchingCommand?.immediate || options?.fromKeybinding)\n\n        if (\n          matchingCommand &&\n          shouldTreatAsImmediate &&\n          matchingCommand.type === 'local-jsx'\n        ) {\n          // Only clear input if the submitted text matches what's in the prompt.\n          // When a command keybinding fires, input is \"/<command>\" but the actual\n          // input value is the user's existing text - don't clear it in that case.\n          if (input.trim() === inputValueRef.current.trim()) {\n            setInputValue('')\n            helpers.setCursorOffset(0)\n            helpers.clearBuffer()\n            setPastedContents({})\n          }\n\n          const pastedTextRefs = parseReferences(input).filter(\n            r => pastedContents[r.id]?.type === 'text',\n          )\n          const pastedTextCount = pastedTextRefs.length\n          const pastedTextBytes = pastedTextRefs.reduce(\n            (sum, r) => sum + (pastedContents[r.id]?.content.length ?? 0),\n            0,\n          )\n          logEvent('tengu_paste_text', { pastedTextCount, pastedTextBytes })\n          logEvent('tengu_immediate_command_executed', {\n            commandName:\n              matchingCommand.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            fromKeybinding: options?.fromKeybinding ?? false,\n          })\n\n          // Execute the command directly\n          const executeImmediateCommand = async (): Promise<void> => {\n            let doneWasCalled = false\n            const onDone = (\n              result?: string,\n              doneOptions?: {\n                display?: CommandResultDisplay\n                metaMessages?: string[]\n              },\n            ): void => {\n              doneWasCalled = true\n              setToolJSX({\n                jsx: null,\n                shouldHidePromptInput: false,\n                clearLocalJSX: true,\n              })\n              const newMessages: MessageType[] = []\n              if (result && doneOptions?.display !== 'skip') {\n                addNotification({\n                  key: `immediate-${matchingCommand.name}`,\n                  text: result,\n                  priority: 'immediate',\n                })\n                // In fullscreen the command just showed as a centered modal\n                // pane — the notification above is enough feedback. Adding\n                // \"❯ /config\" + \"⎿ dismissed\" to the transcript is clutter\n                // (those messages are type:system subtype:local_command —\n                // user-visible but NOT sent to the model, so skipping them\n                // doesn't change model context). Outside fullscreen the\n                // transcript entry stays so scrollback shows what ran.\n                if (!isFullscreenEnvEnabled()) {\n                  newMessages.push(\n                    createCommandInputMessage(\n                      formatCommandInputTags(\n                        getCommandName(matchingCommand),\n                        commandArgs,\n                      ),\n                    ),\n                    createCommandInputMessage(\n                      `<${LOCAL_COMMAND_STDOUT_TAG}>${escapeXml(result)}</${LOCAL_COMMAND_STDOUT_TAG}>`,\n                    ),\n                  )\n                }\n              }\n              // Inject meta messages (model-visible, user-hidden) into the transcript\n              if (doneOptions?.metaMessages?.length) {\n                newMessages.push(\n                  ...doneOptions.metaMessages.map(content =>\n                    createUserMessage({ content, isMeta: true }),\n                  ),\n                )\n              }\n              if (newMessages.length) {\n                setMessages(prev => [...prev, ...newMessages])\n              }\n              // Restore stashed prompt after local-jsx command completes.\n              // The normal stash restoration path (below) is skipped because\n              // local-jsx commands return early from onSubmit.\n              if (stashedPrompt !== undefined) {\n                setInputValue(stashedPrompt.text)\n                helpers.setCursorOffset(stashedPrompt.cursorOffset)\n                setPastedContents(stashedPrompt.pastedContents)\n                setStashedPrompt(undefined)\n              }\n            }\n\n            // Build context for the command (reuses existing getToolUseContext).\n            // Read messages via ref to keep onSubmit stable across message\n            // updates — matches the pattern at L2384/L2400/L2662 and avoids\n            // pinning stale REPL render scopes in downstream closures.\n            const context = getToolUseContext(\n              messagesRef.current,\n              [],\n              createAbortController(),\n              mainLoopModel,\n            )\n\n            const mod = await matchingCommand.load()\n            const jsx = await mod.call(onDone, context, commandArgs)\n\n            // Skip if onDone already fired — prevents stuck isLocalJSXCommand\n            // (see processSlashCommand.tsx local-jsx case for full mechanism).\n            if (jsx && !doneWasCalled) {\n              // shouldHidePromptInput: false keeps Notifications mounted\n              // so the onDone result isn't lost\n              setToolJSX({\n                jsx,\n                shouldHidePromptInput: false,\n                isLocalJSXCommand: true,\n              })\n            }\n          }\n          void executeImmediateCommand()\n          return // Always return early - don't add to history or queue\n        }\n      }\n\n      // Remote mode: skip empty input early before any state mutations\n      if (activeRemote.isRemoteMode && !input.trim()) {\n        return\n      }\n\n      // Idle-return: prompt returning users to start fresh when the\n      // conversation is large and the cache is cold. tengu_willow_mode\n      // controls treatment: \"dialog\" (blocking), \"hint\" (notification), \"off\".\n      {\n        const willowMode = getFeatureValue_CACHED_MAY_BE_STALE(\n          'tengu_willow_mode',\n          'off',\n        )\n        const idleThresholdMin = Number(\n          process.env.CLAUDE_CODE_IDLE_THRESHOLD_MINUTES ?? 75,\n        )\n        const tokenThreshold = Number(\n          process.env.CLAUDE_CODE_IDLE_TOKEN_THRESHOLD ?? 100_000,\n        )\n        if (\n          willowMode !== 'off' &&\n          !getGlobalConfig().idleReturnDismissed &&\n          !skipIdleCheckRef.current &&\n          !speculationAccept &&\n          !input.trim().startsWith('/') &&\n          lastQueryCompletionTimeRef.current > 0 &&\n          getTotalInputTokens() >= tokenThreshold\n        ) {\n          const idleMs = Date.now() - lastQueryCompletionTimeRef.current\n          const idleMinutes = idleMs / 60_000\n          if (idleMinutes >= idleThresholdMin && willowMode === 'dialog') {\n            setIdleReturnPending({ input, idleMinutes })\n            setInputValue('')\n            helpers.setCursorOffset(0)\n            helpers.clearBuffer()\n            return\n          }\n        }\n      }\n\n      // Add to history for direct user submissions.\n      // Queued command processing (executeQueuedInput) doesn't call onSubmit,\n      // so notifications and already-queued user input won't be added to history here.\n      // Skip history for keybinding-triggered commands (user didn't type the command).\n      if (!options?.fromKeybinding) {\n        addToHistory({\n          display: speculationAccept\n            ? input\n            : prependModeCharacterToInput(input, inputMode),\n          pastedContents: speculationAccept ? {} : pastedContents,\n        })\n        // Add the just-submitted command to the front of the ghost-text\n        // cache so it's suggested immediately (not after the 60s TTL).\n        if (inputMode === 'bash') {\n          prependToShellHistoryCache(input.trim())\n        }\n      }\n\n      // Restore stash if present, but NOT for slash commands or when loading.\n      // - Slash commands (especially interactive ones like /model, /context) hide\n      //   the prompt and show a picker UI. Restoring the stash during a command would\n      //   place the text in a hidden input, and the user would lose it by typing the\n      //   next command. Instead, preserve the stash so it survives across command runs.\n      // - When loading, the submitted input will be queued and handlePromptSubmit\n      //   will clear the input field (onInputChange('')), which would clobber the\n      //   restored stash. Defer restoration to after handlePromptSubmit (below).\n      //   Remote mode is exempt: it sends via WebSocket and returns early without\n      //   calling handlePromptSubmit, so there's no clobbering risk — restore eagerly.\n      // In both deferred cases, the stash is restored after await handlePromptSubmit.\n      const isSlashCommand = !speculationAccept && input.trim().startsWith('/')\n      // Submit runs \"now\" (not queued) when not already loading, or when\n      // accepting speculation, or in remote mode (which sends via WS and\n      // returns early without calling handlePromptSubmit).\n      const submitsNow =\n        !isLoading || speculationAccept || activeRemote.isRemoteMode\n      if (stashedPrompt !== undefined && !isSlashCommand && submitsNow) {\n        setInputValue(stashedPrompt.text)\n        helpers.setCursorOffset(stashedPrompt.cursorOffset)\n        setPastedContents(stashedPrompt.pastedContents)\n        setStashedPrompt(undefined)\n      } else if (submitsNow) {\n        if (!options?.fromKeybinding) {\n          // Clear input when not loading or accepting speculation.\n          // Preserve input for keybinding-triggered commands.\n          setInputValue('')\n          helpers.setCursorOffset(0)\n        }\n        setPastedContents({})\n      }\n\n      if (submitsNow) {\n        setInputMode('prompt')\n        setIDESelection(undefined)\n        setSubmitCount(_ => _ + 1)\n        helpers.clearBuffer()\n        tipPickedThisTurnRef.current = false\n\n        // Show the placeholder in the same React batch as setInputValue('').\n        // Skip for slash/bash (they have their own echo), speculation and remote\n        // mode (both setMessages directly with no gap to bridge).\n        if (\n          !isSlashCommand &&\n          inputMode === 'prompt' &&\n          !speculationAccept &&\n          !activeRemote.isRemoteMode\n        ) {\n          setUserInputOnProcessing(input)\n          // showSpinner includes userInputOnProcessing, so the spinner appears\n          // on this render. Reset timing refs now (before queryGuard.reserve()\n          // would) so elapsed time doesn't read as Date.now() - 0. The\n          // isQueryActive transition above does the same reset — idempotent.\n          resetTimingRefs()\n        }\n\n        // Increment prompt count for attribution tracking and save snapshot\n        // The snapshot persists promptCount so it survives compaction\n        if (feature('COMMIT_ATTRIBUTION')) {\n          setAppState(prev => ({\n            ...prev,\n            attribution: incrementPromptCount(prev.attribution, snapshot => {\n              void recordAttributionSnapshot(snapshot).catch(error => {\n                logForDebugging(\n                  `Attribution: Failed to save snapshot: ${error}`,\n                )\n              })\n            }),\n          }))\n        }\n      }\n\n      // Handle speculation acceptance\n      if (speculationAccept) {\n        const { queryRequired } = await handleSpeculationAccept(\n          speculationAccept.state,\n          speculationAccept.speculationSessionTimeSavedMs,\n          speculationAccept.setAppState,\n          input,\n          {\n            setMessages,\n            readFileState,\n            cwd: getOriginalCwd(),\n          },\n        )\n        if (queryRequired) {\n          const newAbortController = createAbortController()\n          setAbortController(newAbortController)\n          void onQuery([], newAbortController, true, [], mainLoopModel)\n        }\n        return\n      }\n\n      // Remote mode: send input via stream-json instead of local query.\n      // Permission requests from the remote are bridged into toolUseConfirmQueue\n      // and rendered using the standard PermissionRequest component.\n      //\n      // local-jsx slash commands (e.g. /agents, /config) render UI in THIS\n      // process — they have no remote equivalent. Let those fall through to\n      // handlePromptSubmit so they execute locally. Prompt commands and\n      // plain text go to the remote.\n      if (\n        activeRemote.isRemoteMode &&\n        !(\n          isSlashCommand &&\n          commands.find(c => {\n            const name = input.trim().slice(1).split(/\\s/)[0]\n            return (\n              isCommandEnabled(c) &&\n              (c.name === name ||\n                c.aliases?.includes(name!) ||\n                getCommandName(c) === name)\n            )\n          })?.type === 'local-jsx'\n        )\n      ) {\n        // Build content blocks when there are pasted attachments (images)\n        const pastedValues = Object.values(pastedContents)\n        const imageContents = pastedValues.filter(c => c.type === 'image')\n        const imagePasteIds =\n          imageContents.length > 0 ? imageContents.map(c => c.id) : undefined\n\n        let messageContent: string | ContentBlockParam[] = input.trim()\n        let remoteContent: RemoteMessageContent = input.trim()\n        if (pastedValues.length > 0) {\n          const contentBlocks: ContentBlockParam[] = []\n          const remoteBlocks: Array<{ type: string; [key: string]: unknown }> =\n            []\n\n          const trimmedInput = input.trim()\n          if (trimmedInput) {\n            contentBlocks.push({ type: 'text', text: trimmedInput })\n            remoteBlocks.push({ type: 'text', text: trimmedInput })\n          }\n\n          for (const pasted of pastedValues) {\n            if (pasted.type === 'image') {\n              const source = {\n                type: 'base64' as const,\n                media_type: (pasted.mediaType ?? 'image/png') as\n                  | 'image/jpeg'\n                  | 'image/png'\n                  | 'image/gif'\n                  | 'image/webp',\n                data: pasted.content,\n              }\n              contentBlocks.push({ type: 'image', source })\n              remoteBlocks.push({ type: 'image', source })\n            } else {\n              contentBlocks.push({ type: 'text', text: pasted.content })\n              remoteBlocks.push({ type: 'text', text: pasted.content })\n            }\n          }\n\n          messageContent = contentBlocks\n          remoteContent = remoteBlocks\n        }\n\n        // Create and add user message to UI\n        // Note: empty input already handled by early return above\n        const userMessage = createUserMessage({\n          content: messageContent,\n          imagePasteIds,\n        })\n        setMessages(prev => [...prev, userMessage])\n\n        // Send to remote session\n        await activeRemote.sendMessage(remoteContent, {\n          uuid: userMessage.uuid,\n        })\n        return\n      }\n\n      // Ensure SessionStart hook context is available before the first API call.\n      await awaitPendingHooks()\n\n      await handlePromptSubmit({\n        input,\n        helpers,\n        queryGuard,\n        isExternalLoading,\n        mode: inputMode,\n        commands,\n        onInputChange: setInputValue,\n        setPastedContents,\n        setToolJSX,\n        getToolUseContext,\n        messages: messagesRef.current,\n        mainLoopModel,\n        pastedContents,\n        ideSelection,\n        setUserInputOnProcessing,\n        setAbortController,\n        abortController,\n        onQuery,\n        setAppState,\n        querySource: getQuerySourceForREPL(),\n        onBeforeQuery,\n        canUseTool,\n        addNotification,\n        setMessages,\n        // Read via ref so streamMode can be dropped from onSubmit deps —\n        // handlePromptSubmit only uses it for debug log + telemetry event.\n        streamMode: streamModeRef.current,\n        hasInterruptibleToolInProgress:\n          hasInterruptibleToolInProgressRef.current,\n      })\n\n      // Restore stash that was deferred above. Two cases:\n      // - Slash command: handlePromptSubmit awaited the full command execution\n      //   (including interactive pickers). Restoring now places the stash back in\n      //   the visible input.\n      // - Loading (queued): handlePromptSubmit enqueued + cleared input, then\n      //   returned quickly. Restoring now places the stash back after the clear.\n      if ((isSlashCommand || isLoading) && stashedPrompt !== undefined) {\n        setInputValue(stashedPrompt.text)\n        helpers.setCursorOffset(stashedPrompt.cursorOffset)\n        setPastedContents(stashedPrompt.pastedContents)\n        setStashedPrompt(undefined)\n      }\n    },\n    [\n      queryGuard,\n      // isLoading is read at the !isLoading checks above for input-clearing\n      // and submitCount gating. It's derived from isQueryActive || isExternalLoading,\n      // so including it here ensures the closure captures the fresh value.\n      isLoading,\n      isExternalLoading,\n      inputMode,\n      commands,\n      setInputValue,\n      setInputMode,\n      setPastedContents,\n      setSubmitCount,\n      setIDESelection,\n      setToolJSX,\n      getToolUseContext,\n      // messages is read via messagesRef.current inside the callback to\n      // keep onSubmit stable across message updates (see L2384/L2400/L2662).\n      // Without this, each setMessages call (~30× per turn) recreates\n      // onSubmit, pinning the REPL render scope (1776B) + that render's\n      // messages array in downstream closures (PromptInput, handleAutoRunIssue).\n      // Heap analysis showed ~9 REPL scopes and ~15 messages array versions\n      // accumulating after #20174/#20175, all traced to this dep.\n      mainLoopModel,\n      pastedContents,\n      ideSelection,\n      setUserInputOnProcessing,\n      setAbortController,\n      addNotification,\n      onQuery,\n      stashedPrompt,\n      setStashedPrompt,\n      setAppState,\n      onBeforeQuery,\n      canUseTool,\n      remoteSession,\n      setMessages,\n      awaitPendingHooks,\n      repinScroll,\n    ],\n  )\n\n  // Callback for when user submits input while viewing a teammate's transcript\n  const onAgentSubmit = useCallback(\n    async (\n      input: string,\n      task: InProcessTeammateTaskState | LocalAgentTaskState,\n      helpers: PromptInputHelpers,\n    ) => {\n      if (isLocalAgentTask(task)) {\n        appendMessageToLocalAgent(\n          task.id,\n          createUserMessage({ content: input }),\n          setAppState,\n        )\n        if (task.status === 'running') {\n          queuePendingMessage(task.id, input, setAppState)\n        } else {\n          void resumeAgentBackground({\n            agentId: task.id,\n            prompt: input,\n            toolUseContext: getToolUseContext(\n              messagesRef.current,\n              [],\n              new AbortController(),\n              mainLoopModel,\n            ),\n            canUseTool,\n          }).catch(err => {\n            logForDebugging(\n              `resumeAgentBackground failed: ${errorMessage(err)}`,\n            )\n            addNotification({\n              key: `resume-agent-failed-${task.id}`,\n              jsx: (\n                <Text color=\"error\">\n                  Failed to resume agent: {errorMessage(err)}\n                </Text>\n              ),\n              priority: 'low',\n            })\n          })\n        }\n      } else {\n        injectUserMessageToTeammate(task.id, input, setAppState)\n      }\n      setInputValue('')\n      helpers.setCursorOffset(0)\n      helpers.clearBuffer()\n    },\n    [\n      setAppState,\n      setInputValue,\n      getToolUseContext,\n      canUseTool,\n      mainLoopModel,\n      addNotification,\n    ],\n  )\n\n  // Handlers for auto-run /issue or /good-claude (defined after onSubmit)\n  const handleAutoRunIssue = useCallback(() => {\n    const command = autoRunIssueReason\n      ? getAutoRunCommand(autoRunIssueReason)\n      : '/issue'\n    setAutoRunIssueReason(null) // Clear the state\n    onSubmit(command, {\n      setCursorOffset: () => {},\n      clearBuffer: () => {},\n      resetHistory: () => {},\n    }).catch(err => {\n      logForDebugging(`Auto-run ${command} failed: ${errorMessage(err)}`)\n    })\n  }, [onSubmit, autoRunIssueReason])\n\n  const handleCancelAutoRunIssue = useCallback(() => {\n    setAutoRunIssueReason(null)\n  }, [])\n\n  // Handler for when user presses 1 on survey thanks screen to share details\n  const handleSurveyRequestFeedback = useCallback(() => {\n    const command = \"external\" === 'ant' ? '/issue' : '/feedback'\n    onSubmit(command, {\n      setCursorOffset: () => {},\n      clearBuffer: () => {},\n      resetHistory: () => {},\n    }).catch(err => {\n      logForDebugging(\n        `Survey feedback request failed: ${err instanceof Error ? err.message : String(err)}`,\n      )\n    })\n  }, [onSubmit])\n\n  // onSubmit is unstable (deps include `messages` which changes every turn).\n  // `handleOpenRateLimitOptions` is prop-drilled to every MessageRow, and each\n  // MessageRow fiber pins the closure (and transitively the entire REPL render\n  // scope, ~1.8KB) at mount time. Using a ref keeps this callback stable so\n  // old REPL scopes can be GC'd — saves ~35MB over a 1000-turn session.\n  const onSubmitRef = useRef(onSubmit)\n  onSubmitRef.current = onSubmit\n  const handleOpenRateLimitOptions = useCallback(() => {\n    void onSubmitRef.current('/rate-limit-options', {\n      setCursorOffset: () => {},\n      clearBuffer: () => {},\n      resetHistory: () => {},\n    })\n  }, [])\n\n  const handleExit = useCallback(async () => {\n    setIsExiting(true)\n    // In bg sessions, always detach instead of kill — even when a worktree is\n    // active. Without this guard, the worktree branch below short-circuits into\n    // ExitFlow (which calls gracefulShutdown) before exit.tsx is ever loaded.\n    if (feature('BG_SESSIONS') && isBgSession()) {\n      spawnSync('tmux', ['detach-client'], { stdio: 'ignore' })\n      setIsExiting(false)\n      return\n    }\n    const showWorktree = getCurrentWorktreeSession() !== null\n    if (showWorktree) {\n      setExitFlow(\n        <ExitFlow\n          showWorktree\n          onDone={() => {}}\n          onCancel={() => {\n            setExitFlow(null)\n            setIsExiting(false)\n          }}\n        />,\n      )\n      return\n    }\n    const exitMod = await exit.load()\n    const exitFlowResult = await exitMod.call(() => {})\n    setExitFlow(exitFlowResult)\n    // If call() returned without killing the process (bg session detach),\n    // clear isExiting so the UI is usable on reattach. No-op on the normal\n    // path — gracefulShutdown's process.exit() means we never get here.\n    if (exitFlowResult === null) {\n      setIsExiting(false)\n    }\n  }, [])\n\n  const handleShowMessageSelector = useCallback(() => {\n    setIsMessageSelectorVisible(prev => !prev)\n  }, [])\n\n  // Rewind conversation state to just before `message`: slice messages,\n  // reset conversation ID, microcompact state, permission mode, prompt suggestion.\n  // Does NOT touch the prompt input. Index is computed from messagesRef (always\n  // fresh via the setMessages wrapper) so callers don't need to worry about\n  // stale closures.\n  const rewindConversationTo = useCallback(\n    (message: UserMessage) => {\n      const prev = messagesRef.current\n      const messageIndex = prev.lastIndexOf(message)\n      if (messageIndex === -1) return\n\n      logEvent('tengu_conversation_rewind', {\n        preRewindMessageCount: prev.length,\n        postRewindMessageCount: messageIndex,\n        messagesRemoved: prev.length - messageIndex,\n        rewindToMessageIndex: messageIndex,\n      })\n      setMessages(prev.slice(0, messageIndex))\n      // Careful, this has to happen after setMessages\n      setConversationId(randomUUID())\n      // Reset cached microcompact state so stale pinned cache edits\n      // don't reference tool_use_ids from truncated messages\n      resetMicrocompactState()\n      if (feature('CONTEXT_COLLAPSE')) {\n        // Rewind truncates the REPL array. Commits whose archived span\n        // was past the rewind point can't be projected anymore\n        // (projectView silently skips them) but the staged queue and ID\n        // maps reference stale uuids. Simplest safe reset: drop\n        // everything. The ctx-agent will re-stage on the next\n        // threshold crossing.\n        /* eslint-disable @typescript-eslint/no-require-imports */\n        ;(\n          require('../services/contextCollapse/index.js') as typeof import('../services/contextCollapse/index.js')\n        ).resetContextCollapse()\n        /* eslint-enable @typescript-eslint/no-require-imports */\n      }\n\n      // Restore state from the message we're rewinding to\n      setAppState(prev => ({\n        ...prev,\n        // Restore permission mode from the message\n        toolPermissionContext:\n          message.permissionMode &&\n          prev.toolPermissionContext.mode !== message.permissionMode\n            ? {\n                ...prev.toolPermissionContext,\n                mode: message.permissionMode,\n              }\n            : prev.toolPermissionContext,\n        // Clear stale prompt suggestion from previous conversation state\n        promptSuggestion: {\n          text: null,\n          promptId: null,\n          shownAt: 0,\n          acceptedAt: 0,\n          generationRequestId: null,\n        },\n      }))\n    },\n    [setMessages, setAppState],\n  )\n\n  // Synchronous rewind + input population. Used directly by auto-restore on\n  // interrupt (so React batches with the abort's setMessages → single render,\n  // no flicker). MessageSelector wraps this in setImmediate via handleRestoreMessage.\n  const restoreMessageSync = useCallback(\n    (message: UserMessage) => {\n      rewindConversationTo(message)\n\n      const r = textForResubmit(message)\n      if (r) {\n        setInputValue(r.text)\n        setInputMode(r.mode)\n      }\n\n      // Restore pasted images\n      if (\n        Array.isArray(message.message.content) &&\n        message.message.content.some(block => block.type === 'image')\n      ) {\n        const imageBlocks: Array<ImageBlockParam> =\n          message.message.content.filter(block => block.type === 'image')\n        if (imageBlocks.length > 0) {\n          const newPastedContents: Record<number, PastedContent> = {}\n          imageBlocks.forEach((block, index) => {\n            if (block.source.type === 'base64') {\n              const id = message.imagePasteIds?.[index] ?? index + 1\n              newPastedContents[id] = {\n                id,\n                type: 'image',\n                content: block.source.data,\n                mediaType: block.source.media_type,\n              }\n            }\n          })\n          setPastedContents(newPastedContents)\n        }\n      }\n    },\n    [rewindConversationTo, setInputValue],\n  )\n  restoreMessageSyncRef.current = restoreMessageSync\n\n  // MessageSelector path: defer via setImmediate so the \"Interrupted\" message\n  // renders to static output before rewind — otherwise it remains vestigial\n  // at the top of the screen.\n  const handleRestoreMessage = useCallback(\n    async (message: UserMessage) => {\n      setImmediate(\n        (restore, message) => restore(message),\n        restoreMessageSync,\n        message,\n      )\n    },\n    [restoreMessageSync],\n  )\n\n  // Not memoized — hook stores caps via ref, reads latest closure at dispatch.\n  // 24-char prefix: deriveUUID preserves first 24, renderable uuid prefix-matches raw source.\n  const findRawIndex = (uuid: string) => {\n    const prefix = uuid.slice(0, 24)\n    return messages.findIndex(m => m.uuid.slice(0, 24) === prefix)\n  }\n  const messageActionCaps: MessageActionCaps = {\n    copy: text =>\n      // setClipboard RETURNS OSC 52 — caller must stdout.write (tmux side-effects load-buffer, but that's tmux-only).\n      void setClipboard(text).then(raw => {\n        if (raw) process.stdout.write(raw)\n        addNotification({\n          // Same key as text-selection copy — repeated copies replace toast, don't queue.\n          key: 'selection-copied',\n          text: 'copied',\n          color: 'success',\n          priority: 'immediate',\n          timeoutMs: 2000,\n        })\n      }),\n    edit: async msg => {\n      // Same skip-confirm check as /rewind: lossless → direct, else confirm dialog.\n      const rawIdx = findRawIndex(msg.uuid)\n      const raw = rawIdx >= 0 ? messages[rawIdx] : undefined\n      if (!raw || !selectableUserMessagesFilter(raw)) return\n      const noFileChanges = !(await fileHistoryHasAnyChanges(\n        fileHistory,\n        raw.uuid,\n      ))\n      const onlySynthetic = messagesAfterAreOnlySynthetic(messages, rawIdx)\n      if (noFileChanges && onlySynthetic) {\n        // rewindConversationTo's setMessages races stream appends — cancel first (idempotent).\n        onCancel()\n        // handleRestoreMessage also restores pasted images.\n        void handleRestoreMessage(raw)\n      } else {\n        // Dialog path: onPreRestore (= onCancel) fires when user CONFIRMS, not on nevermind.\n        setMessageSelectorPreselect(raw)\n        setIsMessageSelectorVisible(true)\n      }\n    },\n  }\n  const { enter: enterMessageActions, handlers: messageActionHandlers } =\n    useMessageActions(cursor, setCursor, cursorNavRef, messageActionCaps)\n\n  async function onInit() {\n    // Always verify API key on startup, so we can show the user an error in the\n    // bottom right corner of the screen if the API key is invalid.\n    void reverify()\n\n    // Populate readFileState with CLAUDE.md files at startup\n    const memoryFiles = await getMemoryFiles()\n    if (memoryFiles.length > 0) {\n      const fileList = memoryFiles\n        .map(\n          f =>\n            `  [${f.type}] ${f.path} (${f.content.length} chars)${f.parent ? ` (included by ${f.parent})` : ''}`,\n        )\n        .join('\\n')\n      logForDebugging(\n        `Loaded ${memoryFiles.length} CLAUDE.md/rules files:\\n${fileList}`,\n      )\n    } else {\n      logForDebugging('No CLAUDE.md/rules files found')\n    }\n    for (const file of memoryFiles) {\n      // When the injected content doesn't match disk (stripped HTML comments,\n      // stripped frontmatter, MEMORY.md truncation), cache the RAW disk bytes\n      // with isPartialView so Edit/Write require a real Read first while\n      // getChangedFiles + nested_memory dedup still work.\n      readFileState.current.set(file.path, {\n        content: file.contentDiffersFromDisk\n          ? (file.rawContent ?? file.content)\n          : file.content,\n        timestamp: Date.now(),\n        offset: undefined,\n        limit: undefined,\n        isPartialView: file.contentDiffersFromDisk,\n      })\n    }\n\n    // Initial message handling is done via the initialMessage effect\n  }\n\n  // Register cost summary tracker\n  useCostSummary(useFpsMetrics())\n\n  // Record transcripts locally, for debugging and conversation recovery\n  // Don't record conversation if we only have initial messages; optimizes\n  // the case where user resumes a conversation then quites before doing\n  // anything else\n  useLogMessages(messages, messages.length === initialMessages?.length)\n\n  // REPL Bridge: replicate user/assistant messages to the bridge session\n  // for remote access via claude.ai. No-op in external builds or when not enabled.\n  const { sendBridgeResult } = useReplBridge(\n    messages,\n    setMessages,\n    abortControllerRef,\n    commands,\n    mainLoopModel,\n  )\n  sendBridgeResultRef.current = sendBridgeResult\n\n  useAfterFirstRender()\n\n  // Track prompt queue usage for analytics. Fire once per transition from\n  // empty to non-empty, not on every length change -- otherwise a render loop\n  // (concurrent onQuery thrashing, etc.) spams saveGlobalConfig, which hits\n  // ELOCKED under concurrent sessions and falls back to unlocked writes.\n  // That write storm is the primary trigger for ~/.claude.json corruption\n  // (GH #3117).\n  const hasCountedQueueUseRef = useRef(false)\n  useEffect(() => {\n    if (queuedCommands.length < 1) {\n      hasCountedQueueUseRef.current = false\n      return\n    }\n    if (hasCountedQueueUseRef.current) return\n    hasCountedQueueUseRef.current = true\n    saveGlobalConfig(current => ({\n      ...current,\n      promptQueueUseCount: (current.promptQueueUseCount ?? 0) + 1,\n    }))\n  }, [queuedCommands.length])\n\n  // Process queued commands when query completes and queue has items\n\n  const executeQueuedInput = useCallback(\n    async (queuedCommands: QueuedCommand[]) => {\n      await handlePromptSubmit({\n        helpers: {\n          setCursorOffset: () => {},\n          clearBuffer: () => {},\n          resetHistory: () => {},\n        },\n        queryGuard,\n        commands,\n        onInputChange: () => {},\n        setPastedContents: () => {},\n        setToolJSX,\n        getToolUseContext,\n        messages,\n        mainLoopModel,\n        ideSelection,\n        setUserInputOnProcessing,\n        setAbortController,\n        onQuery,\n        setAppState,\n        querySource: getQuerySourceForREPL(),\n        onBeforeQuery,\n        canUseTool,\n        addNotification,\n        setMessages,\n        queuedCommands,\n      })\n    },\n    [\n      queryGuard,\n      commands,\n      setToolJSX,\n      getToolUseContext,\n      messages,\n      mainLoopModel,\n      ideSelection,\n      setUserInputOnProcessing,\n      canUseTool,\n      setAbortController,\n      onQuery,\n      addNotification,\n      setAppState,\n      onBeforeQuery,\n    ],\n  )\n\n  useQueueProcessor({\n    executeQueuedInput,\n    hasActiveLocalJsxUI: isShowingLocalJSXCommand,\n    queryGuard,\n  })\n\n  // We'll use the global lastInteractionTime from state.ts\n\n  // Update last interaction time when input changes.\n  // Must be immediate because useEffect runs after the Ink render cycle flush.\n  useEffect(() => {\n    activityManager.recordUserActivity()\n    updateLastInteractionTime(true)\n  }, [inputValue, submitCount])\n\n  useEffect(() => {\n    if (submitCount === 1) {\n      startBackgroundHousekeeping()\n    }\n  }, [submitCount])\n\n  // Show notification when Claude is done responding and user is idle\n  useEffect(() => {\n    // Don't set up notification if Claude is busy\n    if (isLoading) return\n\n    // Only enable notifications after the first new interaction in this session\n    if (submitCount === 0) return\n\n    // No query has completed yet\n    if (lastQueryCompletionTime === 0) return\n\n    // Set timeout to check idle state\n    const timer = setTimeout(\n      (\n        lastQueryCompletionTime,\n        isLoading,\n        toolJSX,\n        focusedInputDialogRef,\n        terminal,\n      ) => {\n        // Check if user has interacted since the response ended\n        const lastUserInteraction = getLastInteractionTime()\n\n        if (lastUserInteraction > lastQueryCompletionTime) {\n          // User has interacted since Claude finished - they're not idle, don't notify\n          return\n        }\n\n        // User hasn't interacted since response ended, check other conditions\n        const idleTimeSinceResponse = Date.now() - lastQueryCompletionTime\n        if (\n          !isLoading &&\n          !toolJSX &&\n          // Use ref to get current dialog state, avoiding stale closure\n          focusedInputDialogRef.current === undefined &&\n          idleTimeSinceResponse >= getGlobalConfig().messageIdleNotifThresholdMs\n        ) {\n          void sendNotification(\n            {\n              message: 'Claude is waiting for your input',\n              notificationType: 'idle_prompt',\n            },\n            terminal,\n          )\n        }\n      },\n      getGlobalConfig().messageIdleNotifThresholdMs,\n      lastQueryCompletionTime,\n      isLoading,\n      toolJSX,\n      focusedInputDialogRef,\n      terminal,\n    )\n\n    return () => clearTimeout(timer)\n  }, [isLoading, toolJSX, submitCount, lastQueryCompletionTime, terminal])\n\n  // Idle-return hint: show notification when idle threshold is exceeded.\n  // Timer fires after the configured idle period; notification persists until\n  // dismissed or the user submits.\n  useEffect(() => {\n    if (lastQueryCompletionTime === 0) return\n    if (isLoading) return\n    const willowMode: string = getFeatureValue_CACHED_MAY_BE_STALE(\n      'tengu_willow_mode',\n      'off',\n    )\n    if (willowMode !== 'hint' && willowMode !== 'hint_v2') return\n    if (getGlobalConfig().idleReturnDismissed) return\n\n    const tokenThreshold = Number(\n      process.env.CLAUDE_CODE_IDLE_TOKEN_THRESHOLD ?? 100_000,\n    )\n    if (getTotalInputTokens() < tokenThreshold) return\n\n    const idleThresholdMs =\n      Number(process.env.CLAUDE_CODE_IDLE_THRESHOLD_MINUTES ?? 75) * 60_000\n    const elapsed = Date.now() - lastQueryCompletionTime\n    const remaining = idleThresholdMs - elapsed\n\n    const timer = setTimeout(\n      (lqct, addNotif, msgsRef, mode, hintRef) => {\n        if (msgsRef.current.length === 0) return\n        const totalTokens = getTotalInputTokens()\n        const formattedTokens = formatTokens(totalTokens)\n        const idleMinutes = (Date.now() - lqct) / 60_000\n        addNotif({\n          key: 'idle-return-hint',\n          jsx:\n            mode === 'hint_v2' ? (\n              <>\n                <Text dimColor>new task? </Text>\n                <Text color=\"suggestion\">/clear</Text>\n                <Text dimColor> to save </Text>\n                <Text color=\"suggestion\">{formattedTokens} tokens</Text>\n              </>\n            ) : (\n              <Text color=\"warning\">\n                new task? /clear to save {formattedTokens} tokens\n              </Text>\n            ),\n          priority: 'medium',\n          // Persist until submit — the hint fires at T+75min idle, user may\n          // not return for hours. removeNotification in useEffect cleanup\n          // handles dismissal. 0x7FFFFFFF = setTimeout max (~24.8 days).\n          timeoutMs: 0x7fffffff,\n        })\n        hintRef.current = mode\n        logEvent('tengu_idle_return_action', {\n          action:\n            'hint_shown' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          variant:\n            mode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          idleMinutes: Math.round(idleMinutes),\n          messageCount: msgsRef.current.length,\n          totalInputTokens: totalTokens,\n        })\n      },\n      Math.max(0, remaining),\n      lastQueryCompletionTime,\n      addNotification,\n      messagesRef,\n      willowMode,\n      idleHintShownRef,\n    )\n\n    return () => {\n      clearTimeout(timer)\n      removeNotification('idle-return-hint')\n      idleHintShownRef.current = false\n    }\n  }, [lastQueryCompletionTime, isLoading, addNotification, removeNotification])\n\n  // Submits incoming prompts from teammate messages or tasks mode as new turns\n  // Returns true if submission succeeded, false if a query is already running\n  const handleIncomingPrompt = useCallback(\n    (content: string, options?: { isMeta?: boolean }): boolean => {\n      if (queryGuard.isActive) return false\n\n      // Defer to user-queued commands — user input always takes priority\n      // over system messages (teammate messages, task list items, etc.)\n      // Read from the module-level store at call time (not the render-time\n      // snapshot) to avoid a stale closure — this callback's deps don't\n      // include the queue.\n      if (\n        getCommandQueue().some(\n          cmd => cmd.mode === 'prompt' || cmd.mode === 'bash',\n        )\n      ) {\n        return false\n      }\n\n      const newAbortController = createAbortController()\n      setAbortController(newAbortController)\n\n      // Create a user message with the formatted content (includes XML wrapper)\n      const userMessage = createUserMessage({\n        content,\n        isMeta: options?.isMeta ? true : undefined,\n      })\n\n      void onQuery([userMessage], newAbortController, true, [], mainLoopModel)\n      return true\n    },\n    [onQuery, mainLoopModel, store],\n  )\n\n  // Voice input integration (VOICE_MODE builds only)\n  const voice = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceIntegration({ setInputValueRaw, inputValueRef, insertTextRef })\n    : {\n        stripTrailing: () => 0,\n        handleKeyEvent: () => {},\n        resetAnchor: () => {},\n        interimRange: null,\n      }\n\n  useInboxPoller({\n    enabled: isAgentSwarmsEnabled(),\n    isLoading,\n    focusedInputDialog,\n    onSubmitMessage: handleIncomingPrompt,\n  })\n\n  useMailboxBridge({ isLoading, onSubmitMessage: handleIncomingPrompt })\n\n  // Scheduled tasks from .claude/scheduled_tasks.json (CronCreate/Delete/List)\n  if (feature('AGENT_TRIGGERS')) {\n    // Assistant mode bypasses the isLoading gate (the proactive tick →\n    // Sleep → tick loop would otherwise starve the scheduler).\n    // kairosEnabled is set once in initialState (main.tsx) and never mutated — no\n    // subscription needed. The tengu_kairos_cron runtime gate is checked inside\n    // useScheduledTasks's effect (not here) since wrapping a hook call in a dynamic\n    // condition would break rules-of-hooks.\n    const assistantMode = store.getState().kairosEnabled\n    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n    useScheduledTasks!({ isLoading, assistantMode, setMessages })\n  }\n\n  // Note: Permission polling is now handled by useInboxPoller\n  // - Workers receive permission responses via mailbox messages\n  // - Leaders receive permission requests via mailbox messages\n\n  if (\"external\" === 'ant') {\n    // Tasks mode: watch for tasks and auto-process them\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds\n    useTaskListWatcher({\n      taskListId,\n      isLoading,\n      onSubmitTask: handleIncomingPrompt,\n    })\n\n    // Loop mode: auto-tick when enabled (via /job command)\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    // biome-ignore lint/correctness/useHookAtTopLevel: conditional for dead code elimination in external builds\n    useProactive?.({\n      // Suppress ticks while an initial message is pending — the initial\n      // message will be processed asynchronously and a premature tick would\n      // race with it, causing concurrent-query enqueue of expanded skill text.\n      isLoading: isLoading || initialMessage !== null,\n      queuedCommandsLength: queuedCommands.length,\n      hasActiveLocalJsxUI: isShowingLocalJSXCommand,\n      isInPlanMode: toolPermissionContext.mode === 'plan',\n      onSubmitTick: (prompt: string) =>\n        handleIncomingPrompt(prompt, { isMeta: true }),\n      onQueueTick: (prompt: string) =>\n        enqueue({ mode: 'prompt', value: prompt, isMeta: true }),\n    })\n  }\n\n  // Abort the current operation when a 'now' priority message arrives\n  // (e.g. from a chat UI client via UDS).\n  useEffect(() => {\n    if (queuedCommands.some(cmd => cmd.priority === 'now')) {\n      abortControllerRef.current?.abort('interrupt')\n    }\n  }, [queuedCommands])\n\n  // Initial load\n  useEffect(() => {\n    void onInit()\n\n    // Cleanup on unmount\n    return () => {\n      void diagnosticTracker.shutdown()\n    }\n    // TODO: fix this\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  // Listen for suspend/resume events\n  const { internal_eventEmitter } = useStdin()\n  const [remountKey, setRemountKey] = useState(0)\n  useEffect(() => {\n    const handleSuspend = () => {\n      // Print suspension instructions\n      process.stdout.write(\n        `\\nClaude Code has been suspended. Run \\`fg\\` to bring Claude Code back.\\nNote: ctrl + z now suspends Claude Code, ctrl + _ undoes input.\\n`,\n      )\n    }\n\n    const handleResume = () => {\n      // Force complete component tree replacement instead of terminal clear\n      // Ink now handles line count reset internally on SIGCONT\n      setRemountKey(prev => prev + 1)\n    }\n\n    internal_eventEmitter?.on('suspend', handleSuspend)\n    internal_eventEmitter?.on('resume', handleResume)\n    return () => {\n      internal_eventEmitter?.off('suspend', handleSuspend)\n      internal_eventEmitter?.off('resume', handleResume)\n    }\n  }, [internal_eventEmitter])\n\n  // Derive stop hook spinner suffix from messages state\n  const stopHookSpinnerSuffix = useMemo(() => {\n    if (!isLoading) return null\n\n    // Find stop hook progress messages\n    const progressMsgs = messages.filter(\n      (m): m is ProgressMessage<HookProgress> =>\n        m.type === 'progress' &&\n        m.data.type === 'hook_progress' &&\n        (m.data.hookEvent === 'Stop' || m.data.hookEvent === 'SubagentStop'),\n    )\n    if (progressMsgs.length === 0) return null\n\n    // Get the most recent stop hook execution\n    const currentToolUseID = progressMsgs.at(-1)?.toolUseID\n    if (!currentToolUseID) return null\n\n    // Check if there's already a summary message for this execution (hooks completed)\n    const hasSummaryForCurrentExecution = messages.some(\n      m =>\n        m.type === 'system' &&\n        m.subtype === 'stop_hook_summary' &&\n        m.toolUseID === currentToolUseID,\n    )\n    if (hasSummaryForCurrentExecution) return null\n\n    const currentHooks = progressMsgs.filter(\n      p => p.toolUseID === currentToolUseID,\n    )\n    const total = currentHooks.length\n\n    // Count completed hooks\n    const completedCount = count(messages, m => {\n      if (m.type !== 'attachment') return false\n      const attachment = m.attachment\n      return (\n        'hookEvent' in attachment &&\n        (attachment.hookEvent === 'Stop' ||\n          attachment.hookEvent === 'SubagentStop') &&\n        'toolUseID' in attachment &&\n        attachment.toolUseID === currentToolUseID\n      )\n    })\n\n    // Check if any hook has a custom status message\n    const customMessage = currentHooks.find(p => p.data.statusMessage)?.data\n      .statusMessage\n\n    if (customMessage) {\n      // Use custom message with progress counter if multiple hooks\n      return total === 1\n        ? `${customMessage}…`\n        : `${customMessage}… ${completedCount}/${total}`\n    }\n\n    // Fall back to default behavior\n    const hookType =\n      currentHooks[0]?.data.hookEvent === 'SubagentStop'\n        ? 'subagent stop'\n        : 'stop'\n\n    if (\"external\" === 'ant') {\n      const cmd = currentHooks[completedCount]?.data.command\n      const label = cmd ? ` '${truncateToWidth(cmd, 40)}'` : ''\n      return total === 1\n        ? `running ${hookType} hook${label}`\n        : `running ${hookType} hook${label}\\u2026 ${completedCount}/${total}`\n    }\n\n    return total === 1\n      ? `running ${hookType} hook`\n      : `running stop hooks… ${completedCount}/${total}`\n  }, [messages, isLoading])\n\n  // Callback to capture frozen state when entering transcript mode\n  const handleEnterTranscript = useCallback(() => {\n    setFrozenTranscriptState({\n      messagesLength: messages.length,\n      streamingToolUsesLength: streamingToolUses.length,\n    })\n  }, [messages.length, streamingToolUses.length])\n\n  // Callback to clear frozen state when exiting transcript mode\n  const handleExitTranscript = useCallback(() => {\n    setFrozenTranscriptState(null)\n  }, [])\n\n  // Props for GlobalKeybindingHandlers component (rendered inside KeybindingSetup)\n  const virtualScrollActive = isFullscreenEnvEnabled() && !disableVirtualScroll\n\n  // Transcript search state. Hooks must be unconditional so they live here\n  // (not inside the `if (screen === 'transcript')` branch below); isActive\n  // gates the useInput. Query persists across bar open/close so n/N keep\n  // working after Enter dismisses the bar (less semantics).\n  const jumpRef = useRef<JumpHandle | null>(null)\n  const [searchOpen, setSearchOpen] = useState(false)\n  const [searchQuery, setSearchQuery] = useState('')\n  const [searchCount, setSearchCount] = useState(0)\n  const [searchCurrent, setSearchCurrent] = useState(0)\n  const onSearchMatchesChange = useCallback(\n    (count: number, current: number) => {\n      setSearchCount(count)\n      setSearchCurrent(current)\n    },\n    [],\n  )\n\n  useInput(\n    (input, key, event) => {\n      if (key.ctrl || key.meta) return\n      // No Esc handling here — less has no navigating mode. Search state\n      // (highlights, n/N) is just state. Esc/q/ctrl+c → transcript:exit\n      // (ungated). Highlights clear on exit via the screen-change effect.\n      if (input === '/') {\n        // Capture scrollTop NOW — typing is a preview, 0-matches snaps\n        // back here. Synchronous ref write, fires before the bar's\n        // mount-effect calls setSearchQuery.\n        jumpRef.current?.setAnchor()\n        setSearchOpen(true)\n        event.stopImmediatePropagation()\n        return\n      }\n      // Held-key batching: tokenizer coalesces to 'nnn'. Same uniform-batch\n      // pattern as modalPagerAction in ScrollKeybindingHandler.tsx. Each\n      // repeat is a step (n isn't idempotent like g).\n      const c = input[0]\n      if (\n        (c === 'n' || c === 'N') &&\n        input === c.repeat(input.length) &&\n        searchCount > 0\n      ) {\n        const fn =\n          c === 'n' ? jumpRef.current?.nextMatch : jumpRef.current?.prevMatch\n        if (fn) for (let i = 0; i < input.length; i++) fn()\n        event.stopImmediatePropagation()\n      }\n    },\n    // Search needs virtual scroll (jumpRef drives VirtualMessageList). [\n    // kills it, so !dumpMode — after [ there's nothing to jump in.\n    {\n      isActive:\n        screen === 'transcript' &&\n        virtualScrollActive &&\n        !searchOpen &&\n        !dumpMode,\n    },\n  )\n  const {\n    setQuery: setHighlight,\n    scanElement,\n    setPositions,\n  } = useSearchHighlight()\n\n  // Resize → abort search. Positions are (msg, query, WIDTH)-keyed —\n  // cached positions are stale after a width change (new layout, new\n  // wrapping). Clearing searchQuery triggers VML's setSearchQuery('')\n  // which clears positionsCache + setPositions(null). Bar closes.\n  // User hits / again → fresh everything.\n  const transcriptCols = useTerminalSize().columns\n  const prevColsRef = React.useRef(transcriptCols)\n  React.useEffect(() => {\n    if (prevColsRef.current !== transcriptCols) {\n      prevColsRef.current = transcriptCols\n      if (searchQuery || searchOpen) {\n        setSearchOpen(false)\n        setSearchQuery('')\n        setSearchCount(0)\n        setSearchCurrent(0)\n        jumpRef.current?.disarmSearch()\n        setHighlight('')\n      }\n    }\n  }, [transcriptCols, searchQuery, searchOpen, setHighlight])\n\n  // Transcript escape hatches. Bare letters in modal context (no prompt\n  // competing for input) — same class as g/G/j/k in ScrollKeybindingHandler.\n  useInput(\n    (input, key, event) => {\n      if (key.ctrl || key.meta) return\n      if (input === 'q') {\n        // less: q quits the pager. ctrl+o toggles; q is the lineage exit.\n        handleExitTranscript()\n        event.stopImmediatePropagation()\n        return\n      }\n      if (input === '[' && !dumpMode) {\n        // Force dump-to-scrollback. Also expand + uncap — no point dumping\n        // a subset. Terminal/tmux cmd-F can now find anything. Guard here\n        // (not in isActive) so v still works post-[ — dump-mode footer at\n        // ~4898 wires editorStatus, confirming v is meant to stay live.\n        setDumpMode(true)\n        setShowAllInTranscript(true)\n        event.stopImmediatePropagation()\n      } else if (input === 'v') {\n        // less-style: v opens the file in $VISUAL/$EDITOR. Render the full\n        // transcript (same path /export uses), write to tmp, hand off.\n        // openFileInExternalEditor handles alt-screen suspend/resume for\n        // terminal editors; GUI editors spawn detached.\n        event.stopImmediatePropagation()\n        // Drop double-taps: the render is async and a second press before it\n        // completes would run a second parallel render (double memory, two\n        // tempfiles, two editor spawns). editorGenRef only guards\n        // transcript-exit staleness, not same-session concurrency.\n        if (editorRenderingRef.current) return\n        editorRenderingRef.current = true\n        // Capture generation + make a staleness-aware setter. Each write\n        // checks gen (transcript exit bumps it → late writes from the\n        // async render go silent).\n        const gen = editorGenRef.current\n        const setStatus = (s: string): void => {\n          if (gen !== editorGenRef.current) return\n          clearTimeout(editorTimerRef.current)\n          setEditorStatus(s)\n        }\n        setStatus(`rendering ${deferredMessages.length} messages…`)\n        void (async () => {\n          try {\n            // Width = terminal minus vim's line-number gutter (4 digits +\n            // space + slack). Floor at 80. PassThrough has no .columns so\n            // without this Ink defaults to 80. Trailing-space strip: right-\n            // aligned timestamps still leave a flexbox spacer run at EOL.\n            // eslint-disable-next-line custom-rules/prefer-use-terminal-size -- one-shot at keypress time, not a reactive render dep\n            const w = Math.max(80, (process.stdout.columns ?? 80) - 6)\n            const raw = await renderMessagesToPlainText(\n              deferredMessages,\n              tools,\n              w,\n            )\n            const text = raw.replace(/[ \\t]+$/gm, '')\n            const path = join(tmpdir(), `cc-transcript-${Date.now()}.txt`)\n            await writeFile(path, text)\n            const opened = openFileInExternalEditor(path)\n            setStatus(\n              opened\n                ? `opening ${path}`\n                : `wrote ${path} · no $VISUAL/$EDITOR set`,\n            )\n          } catch (e) {\n            setStatus(\n              `render failed: ${e instanceof Error ? e.message : String(e)}`,\n            )\n          }\n          editorRenderingRef.current = false\n          if (gen !== editorGenRef.current) return\n          editorTimerRef.current = setTimeout(s => s(''), 4000, setEditorStatus)\n        })()\n      }\n    },\n    // !searchOpen: typing 'v' or '[' in the search bar is search input, not\n    // a command. No !dumpMode here — v should work after [ (the [ handler\n    // guards itself inline).\n    { isActive: screen === 'transcript' && virtualScrollActive && !searchOpen },\n  )\n\n  // Fresh `less` per transcript entry. Prevents stale highlights matching\n  // unrelated normal-mode text (overlay is alt-screen-global) and avoids\n  // surprise n/N on re-entry. Same exit resets [ dump mode — each ctrl+o\n  // entry is a fresh instance.\n  const inTranscript = screen === 'transcript' && virtualScrollActive\n  useEffect(() => {\n    if (!inTranscript) {\n      setSearchQuery('')\n      setSearchCount(0)\n      setSearchCurrent(0)\n      setSearchOpen(false)\n      editorGenRef.current++\n      clearTimeout(editorTimerRef.current)\n      setDumpMode(false)\n      setEditorStatus('')\n    }\n  }, [inTranscript])\n  useEffect(() => {\n    setHighlight(inTranscript ? searchQuery : '')\n    // Clear the position-based CURRENT (yellow) overlay too. setHighlight\n    // only clears the scan-based inverse. Without this, the yellow box\n    // persists at its last screen coords after ctrl-c exits transcript.\n    if (!inTranscript) setPositions(null)\n  }, [inTranscript, searchQuery, setHighlight, setPositions])\n\n  const globalKeybindingProps = {\n    screen,\n    setScreen,\n    showAllInTranscript,\n    setShowAllInTranscript,\n    messageCount: messages.length,\n    onEnterTranscript: handleEnterTranscript,\n    onExitTranscript: handleExitTranscript,\n    virtualScrollActive,\n    // Bar-open is a mode (owns keystrokes — j/k type, Esc cancels).\n    // Navigating (query set, bar closed) is NOT — Esc exits transcript,\n    // same as less q with highlights still visible. useSearchInput\n    // doesn't stopPropagation, so without this gate transcript:exit\n    // would fire on the same Esc that cancels the bar (child registers\n    // first, fires first, bubbles).\n    searchBarOpen: searchOpen,\n  }\n\n  // Use frozen lengths to slice arrays, avoiding memory overhead of cloning\n  const transcriptMessages = frozenTranscriptState\n    ? deferredMessages.slice(0, frozenTranscriptState.messagesLength)\n    : deferredMessages\n  const transcriptStreamingToolUses = frozenTranscriptState\n    ? streamingToolUses.slice(0, frozenTranscriptState.streamingToolUsesLength)\n    : streamingToolUses\n\n  // Handle shift+down for teammate navigation and background task management.\n  // Guard onOpenBackgroundTasks when a local-jsx dialog (e.g. /mcp) is open —\n  // otherwise Shift+Down stacks BackgroundTasksDialog on top and deadlocks input.\n  useBackgroundTaskNavigation({\n    onOpenBackgroundTasks: isShowingLocalJSXCommand\n      ? undefined\n      : () => setShowBashesDialog(true),\n  })\n  // Auto-exit viewing mode when teammate completes or errors\n  useTeammateViewAutoExit()\n\n  if (screen === 'transcript') {\n    // Virtual scroll replaces the 30-message cap: everything is scrollable\n    // and memory is bounded by the viewport. Without it, wrapping transcript\n    // in a ScrollBox would mount all messages (~250 MB on long sessions —\n    // the exact problem), so the kill switch and non-fullscreen paths must\n    // fall through to the legacy render: no alt screen, dump to terminal\n    // scrollback, 30-cap + Ctrl+E. Reusing scrollRef is safe — normal-mode\n    // and transcript-mode are mutually exclusive (this early return), so\n    // only one ScrollBox is ever mounted at a time.\n    const transcriptScrollRef =\n      isFullscreenEnvEnabled() && !disableVirtualScroll && !dumpMode\n        ? scrollRef\n        : undefined\n    const transcriptMessagesElement = (\n      <Messages\n        messages={transcriptMessages}\n        tools={tools}\n        commands={commands}\n        verbose={true}\n        toolJSX={null}\n        toolUseConfirmQueue={[]}\n        inProgressToolUseIDs={inProgressToolUseIDs}\n        isMessageSelectorVisible={false}\n        conversationId={conversationId}\n        screen={screen}\n        agentDefinitions={agentDefinitions}\n        streamingToolUses={transcriptStreamingToolUses}\n        showAllInTranscript={showAllInTranscript}\n        onOpenRateLimitOptions={handleOpenRateLimitOptions}\n        isLoading={isLoading}\n        hidePastThinking={true}\n        streamingThinking={streamingThinking}\n        scrollRef={transcriptScrollRef}\n        jumpRef={jumpRef}\n        onSearchMatchesChange={onSearchMatchesChange}\n        scanElement={scanElement}\n        setPositions={setPositions}\n        disableRenderCap={dumpMode}\n      />\n    )\n    const transcriptToolJSX = toolJSX && (\n      <Box flexDirection=\"column\" width=\"100%\">\n        {toolJSX.jsx}\n      </Box>\n    )\n    const transcriptReturn = (\n      <KeybindingSetup>\n        <AnimatedTerminalTitle\n          isAnimating={titleIsAnimating}\n          title={terminalTitle}\n          disabled={titleDisabled}\n          noPrefix={showStatusInTerminalTab}\n        />\n        <GlobalKeybindingHandlers {...globalKeybindingProps} />\n        {feature('VOICE_MODE') ? (\n          <VoiceKeybindingHandler\n            voiceHandleKeyEvent={voice.handleKeyEvent}\n            stripTrailing={voice.stripTrailing}\n            resetAnchor={voice.resetAnchor}\n            isActive={!toolJSX?.isLocalJSXCommand}\n          />\n        ) : null}\n        <CommandKeybindingHandlers\n          onSubmit={onSubmit}\n          isActive={!toolJSX?.isLocalJSXCommand}\n        />\n        {transcriptScrollRef ? (\n          // ScrollKeybindingHandler must mount before CancelRequestHandler so\n          // ctrl+c-with-selection copies instead of cancelling the active task.\n          // Its raw useInput handler only stops propagation when a selection\n          // exists — without one, ctrl+c falls through to CancelRequestHandler.\n          <ScrollKeybindingHandler\n            scrollRef={scrollRef}\n            // Yield wheel/ctrl+u/d to UltraplanChoiceDialog's own scroll\n            // handler while the modal is showing.\n            isActive={focusedInputDialog !== 'ultraplan-choice'}\n            // g/G/j/k/ctrl+u/ctrl+d would eat keystrokes the search bar\n            // wants. Off while searching.\n            isModal={!searchOpen}\n            // Manual scroll exits the search context — clear the yellow\n            // current-match marker. Positions are (msg, rowOffset)-keyed;\n            // j/k changes scrollTop so rowOffset is stale → wrong row\n            // gets yellow. Next n/N re-establishes via step()→jump().\n            onScroll={() => jumpRef.current?.disarmSearch()}\n          />\n        ) : null}\n        <CancelRequestHandler {...cancelRequestProps} />\n        {transcriptScrollRef ? (\n          <FullscreenLayout\n            scrollRef={scrollRef}\n            scrollable={\n              <>\n                {transcriptMessagesElement}\n                {transcriptToolJSX}\n                <SandboxViolationExpandedView />\n              </>\n            }\n            bottom={\n              searchOpen ? (\n                <TranscriptSearchBar\n                  jumpRef={jumpRef}\n                  // Seed was tried (c01578c8) — broke /hello muscle\n                  // memory (cursor lands after 'foo', /hello → foohello).\n                  // Cancel-restore handles the 'don't lose prior search'\n                  // concern differently (onCancel re-applies searchQuery).\n                  initialQuery=\"\"\n                  count={searchCount}\n                  current={searchCurrent}\n                  onClose={q => {\n                    // Enter — commit. 0-match guard: junk query shouldn't\n                    // persist (badge hidden, n/N dead anyway).\n                    setSearchQuery(searchCount > 0 ? q : '')\n                    setSearchOpen(false)\n                    // onCancel path: bar unmounts before its useEffect([query])\n                    // can fire with ''. Without this, searchCount stays stale\n                    // (n guard at :4956 passes) and VML's matches[] too\n                    // (nextMatch walks the old array). Phantom nav, no\n                    // highlight. onExit (Enter, q non-empty) still commits.\n                    if (!q) {\n                      setSearchCount(0)\n                      setSearchCurrent(0)\n                      jumpRef.current?.setSearchQuery('')\n                    }\n                  }}\n                  onCancel={() => {\n                    // Esc/ctrl+c/ctrl+g — undo. Bar's effect last fired\n                    // with whatever was typed. searchQuery (REPL state)\n                    // is unchanged since / (onClose = commit, didn't run).\n                    // Two VML calls: '' restores anchor (0-match else-\n                    // branch), then searchQuery re-scans from anchor's\n                    // nearest. Both synchronous — one React batch.\n                    // setHighlight explicit: REPL's sync-effect dep is\n                    // searchQuery (unchanged), wouldn't re-fire.\n                    setSearchOpen(false)\n                    jumpRef.current?.setSearchQuery('')\n                    jumpRef.current?.setSearchQuery(searchQuery)\n                    setHighlight(searchQuery)\n                  }}\n                  setHighlight={setHighlight}\n                />\n              ) : (\n                <TranscriptModeFooter\n                  showAllInTranscript={showAllInTranscript}\n                  virtualScroll={true}\n                  status={editorStatus || undefined}\n                  searchBadge={\n                    searchQuery && searchCount > 0\n                      ? { current: searchCurrent, count: searchCount }\n                      : undefined\n                  }\n                />\n              )\n            }\n          />\n        ) : (\n          <>\n            {transcriptMessagesElement}\n            {transcriptToolJSX}\n            <SandboxViolationExpandedView />\n            <TranscriptModeFooter\n              showAllInTranscript={showAllInTranscript}\n              virtualScroll={false}\n              suppressShowAll={dumpMode}\n              status={editorStatus || undefined}\n            />\n          </>\n        )}\n      </KeybindingSetup>\n    )\n    // The virtual-scroll branch (FullscreenLayout above) needs\n    // <AlternateScreen>'s <Box height={rows}> constraint — without it,\n    // ScrollBox's flexGrow has no ceiling, viewport = content height,\n    // scrollTop pins at 0, and Ink's screen buffer sizes to the full\n    // spacer (200×5k+ rows on long sessions). Same root type + props as\n    // normal mode's wrap below so React reconciles and the alt buffer\n    // stays entered across toggle. The 30-cap dump branch stays\n    // unwrapped — it wants native terminal scrollback.\n    if (transcriptScrollRef) {\n      return (\n        <AlternateScreen mouseTracking={isMouseTrackingEnabled()}>\n          {transcriptReturn}\n        </AlternateScreen>\n      )\n    }\n    return transcriptReturn\n  }\n\n  // Get viewed agent task (inlined from selectors for explicit data flow).\n  // viewedAgentTask: teammate OR local_agent — drives the boolean checks\n  // below. viewedTeammateTask: teammate-only narrowed, for teammate-specific\n  // field access (inProgressToolUseIDs).\n  const viewedTask = viewingAgentTaskId ? tasks[viewingAgentTaskId] : undefined\n  const viewedTeammateTask =\n    viewedTask && isInProcessTeammateTask(viewedTask) ? viewedTask : undefined\n  const viewedAgentTask =\n    viewedTeammateTask ??\n    (viewedTask && isLocalAgentTask(viewedTask) ? viewedTask : undefined)\n\n  // Bypass useDeferredValue when streaming text is showing so Messages renders\n  // the final message in the same frame streaming text clears. Also bypass when\n  // not loading — deferredMessages only matters during streaming (keeps input\n  // responsive); after the turn ends, showing messages immediately prevents a\n  // jitter gap where the spinner is gone but the answer hasn't appeared yet.\n  // Only reducedMotion users keep the deferred path during loading.\n  const usesSyncMessages = showStreamingText || !isLoading\n  // When viewing an agent, never fall through to leader — empty until\n  // bootstrap/stream fills. Closes the see-leader-type-agent footgun.\n  const displayedMessages = viewedAgentTask\n    ? (viewedAgentTask.messages ?? [])\n    : usesSyncMessages\n      ? messages\n      : deferredMessages\n  // Show the placeholder until the real user message appears in\n  // displayedMessages. userInputOnProcessing stays set for the whole turn\n  // (cleared in resetLoadingState); this length check hides it once\n  // displayedMessages grows past the baseline captured at submit time.\n  // Covers both gaps: before setMessages is called (processUserInput), and\n  // while deferredMessages lags behind messages. Suppressed when viewing an\n  // agent — displayedMessages is a different array there, and onAgentSubmit\n  // doesn't use the placeholder anyway.\n  const placeholderText =\n    userInputOnProcessing &&\n    !viewedAgentTask &&\n    displayedMessages.length <= userInputBaselineRef.current\n      ? userInputOnProcessing\n      : undefined\n\n  const toolPermissionOverlay =\n    focusedInputDialog === 'tool-permission' ? (\n      <PermissionRequest\n        key={toolUseConfirmQueue[0]?.toolUseID}\n        onDone={() => setToolUseConfirmQueue(([_, ...tail]) => tail)}\n        onReject={handleQueuedCommandOnCancel}\n        toolUseConfirm={toolUseConfirmQueue[0]!}\n        toolUseContext={getToolUseContext(\n          messages,\n          messages,\n          abortController ?? createAbortController(),\n          mainLoopModel,\n        )}\n        verbose={verbose}\n        workerBadge={toolUseConfirmQueue[0]?.workerBadge}\n        setStickyFooter={\n          isFullscreenEnvEnabled() ? setPermissionStickyFooter : undefined\n        }\n      />\n    ) : null\n\n  // Narrow terminals: companion collapses to a one-liner that REPL stacks\n  // on its own row (above input in fullscreen, below in scrollback) instead\n  // of row-beside. Wide terminals keep the row layout with sprite on the right.\n  const companionNarrow = transcriptCols < MIN_COLS_FOR_FULL_SPRITE\n  // Hide the sprite when PromptInput early-returns BackgroundTasksDialog.\n  // The sprite sits as a row sibling of PromptInput, so the dialog's Pane\n  // divider draws at useTerminalSize() width but only gets terminalWidth -\n  // spriteWidth — divider stops short and dialog text wraps early. Don't\n  // check footerSelection: pill FOCUS (arrow-down to tasks pill) must keep\n  // the sprite visible so arrow-right can navigate to it.\n  const companionVisible =\n    !toolJSX?.shouldHidePromptInput && !focusedInputDialog && !showBashesDialog\n\n  // In fullscreen, ALL local-jsx slash commands float in the modal slot —\n  // FullscreenLayout wraps them in an absolute-positioned bottom-anchored\n  // pane (▔ divider, ModalContext). Pane/Dialog inside detect the context\n  // and skip their own top-level frame. Non-fullscreen keeps the inline\n  // render paths below. Commands that used to route through bottom\n  // (immediate: /model, /mcp, /btw, ...) and scrollable (non-immediate:\n  // /config, /theme, /diff, ...) both go here now.\n  const toolJsxCentered =\n    isFullscreenEnvEnabled() && toolJSX?.isLocalJSXCommand === true\n  const centeredModal: React.ReactNode = toolJsxCentered ? toolJSX!.jsx : null\n\n  // <AlternateScreen> at the root: everything below is inside its\n  // <Box height={rows}>. Handlers/contexts are zero-height so ScrollBox's\n  // flexGrow in FullscreenLayout resolves against this Box. The transcript\n  // early return above wraps its virtual-scroll branch the same way; only\n  // the 30-cap dump branch stays unwrapped for native terminal scrollback.\n  const mainReturn = (\n    <KeybindingSetup>\n      <AnimatedTerminalTitle\n        isAnimating={titleIsAnimating}\n        title={terminalTitle}\n        disabled={titleDisabled}\n        noPrefix={showStatusInTerminalTab}\n      />\n      <GlobalKeybindingHandlers {...globalKeybindingProps} />\n      {feature('VOICE_MODE') ? (\n        <VoiceKeybindingHandler\n          voiceHandleKeyEvent={voice.handleKeyEvent}\n          stripTrailing={voice.stripTrailing}\n          resetAnchor={voice.resetAnchor}\n          isActive={!toolJSX?.isLocalJSXCommand}\n        />\n      ) : null}\n      <CommandKeybindingHandlers\n        onSubmit={onSubmit}\n        isActive={!toolJSX?.isLocalJSXCommand}\n      />\n      {/* ScrollKeybindingHandler must mount before CancelRequestHandler so\n          ctrl+c-with-selection copies instead of cancelling the active task.\n          Its raw useInput handler only stops propagation when a selection\n          exists — without one, ctrl+c falls through to CancelRequestHandler.\n          PgUp/PgDn/wheel always scroll the transcript behind the modal —\n          the modal's inner ScrollBox is not keyboard-driven. onScroll\n          stays suppressed while a modal is showing so scroll doesn't\n          stamp divider/pill state. */}\n      <ScrollKeybindingHandler\n        scrollRef={scrollRef}\n        isActive={\n          isFullscreenEnvEnabled() &&\n          (centeredModal != null ||\n            !focusedInputDialog ||\n            focusedInputDialog === 'tool-permission')\n        }\n        onScroll={\n          centeredModal || toolPermissionOverlay || viewedAgentTask\n            ? undefined\n            : composedOnScroll\n        }\n      />\n      {feature('MESSAGE_ACTIONS') &&\n      isFullscreenEnvEnabled() &&\n      !disableMessageActions ? (\n        <MessageActionsKeybindings\n          handlers={messageActionHandlers}\n          isActive={cursor !== null}\n        />\n      ) : null}\n      <CancelRequestHandler {...cancelRequestProps} />\n      <MCPConnectionManager\n        key={remountKey}\n        dynamicMcpConfig={dynamicMcpConfig}\n        isStrictMcpConfig={strictMcpConfig}\n      >\n        <FullscreenLayout\n          scrollRef={scrollRef}\n          overlay={toolPermissionOverlay}\n          bottomFloat={\n            feature('BUDDY') && companionVisible && !companionNarrow ? (\n              <CompanionFloatingBubble />\n            ) : undefined\n          }\n          modal={centeredModal}\n          modalScrollRef={modalScrollRef}\n          dividerYRef={dividerYRef}\n          hidePill={!!viewedAgentTask}\n          hideSticky={!!viewedTeammateTask}\n          newMessageCount={unseenDivider?.count ?? 0}\n          onPillClick={() => {\n            setCursor(null)\n            jumpToNew(scrollRef.current)\n          }}\n          scrollable={\n            <>\n              <TeammateViewHeader />\n              <Messages\n                messages={displayedMessages}\n                tools={tools}\n                commands={commands}\n                verbose={verbose}\n                toolJSX={toolJSX}\n                toolUseConfirmQueue={toolUseConfirmQueue}\n                inProgressToolUseIDs={\n                  viewedTeammateTask\n                    ? (viewedTeammateTask.inProgressToolUseIDs ?? new Set())\n                    : inProgressToolUseIDs\n                }\n                isMessageSelectorVisible={isMessageSelectorVisible}\n                conversationId={conversationId}\n                screen={screen}\n                streamingToolUses={streamingToolUses}\n                showAllInTranscript={showAllInTranscript}\n                agentDefinitions={agentDefinitions}\n                onOpenRateLimitOptions={handleOpenRateLimitOptions}\n                isLoading={isLoading}\n                streamingText={\n                  isLoading && !viewedAgentTask ? visibleStreamingText : null\n                }\n                isBriefOnly={viewedAgentTask ? false : isBriefOnly}\n                unseenDivider={viewedAgentTask ? undefined : unseenDivider}\n                scrollRef={isFullscreenEnvEnabled() ? scrollRef : undefined}\n                trackStickyPrompt={isFullscreenEnvEnabled() ? true : undefined}\n                cursor={cursor}\n                setCursor={setCursor}\n                cursorNavRef={cursorNavRef}\n              />\n              <AwsAuthStatusBox />\n              {/* Hide the processing placeholder while a modal is showing —\n                  it would sit at the last visible transcript row right above\n                  the ▔ divider, showing \"❯ /config\" as redundant clutter\n                  (the modal IS the /config UI). Outside modals it stays so\n                  the user sees their input echoed while Claude processes. */}\n              {!disabled && placeholderText && !centeredModal && (\n                <UserTextMessage\n                  param={{ text: placeholderText, type: 'text' }}\n                  addMargin={true}\n                  verbose={verbose}\n                />\n              )}\n              {toolJSX &&\n                !(toolJSX.isLocalJSXCommand && toolJSX.isImmediate) &&\n                !toolJsxCentered && (\n                  <Box flexDirection=\"column\" width=\"100%\">\n                    {toolJSX.jsx}\n                  </Box>\n                )}\n              {\"external\" === 'ant' && <TungstenLiveMonitor />}\n              {feature('WEB_BROWSER_TOOL')\n                ? WebBrowserPanelModule && (\n                    <WebBrowserPanelModule.WebBrowserPanel />\n                  )\n                : null}\n              <Box flexGrow={1} />\n              {showSpinner && (\n                <SpinnerWithVerb\n                  mode={streamMode}\n                  spinnerTip={spinnerTip}\n                  responseLengthRef={responseLengthRef}\n                  apiMetricsRef={apiMetricsRef}\n                  overrideMessage={spinnerMessage}\n                  spinnerSuffix={stopHookSpinnerSuffix}\n                  verbose={verbose}\n                  loadingStartTimeRef={loadingStartTimeRef}\n                  totalPausedMsRef={totalPausedMsRef}\n                  pauseStartTimeRef={pauseStartTimeRef}\n                  overrideColor={spinnerColor}\n                  overrideShimmerColor={spinnerShimmerColor}\n                  hasActiveTools={inProgressToolUseIDs.size > 0}\n                  leaderIsIdle={!isLoading}\n                />\n              )}\n              {!showSpinner &&\n                !isLoading &&\n                !userInputOnProcessing &&\n                !hasRunningTeammates &&\n                isBriefOnly &&\n                !viewedAgentTask && <BriefIdleStatus />}\n              {isFullscreenEnvEnabled() && <PromptInputQueuedCommands />}\n            </>\n          }\n          bottom={\n            <Box\n              flexDirection={\n                feature('BUDDY') && companionNarrow ? 'column' : 'row'\n              }\n              width=\"100%\"\n              alignItems={\n                feature('BUDDY') && companionNarrow ? undefined : 'flex-end'\n              }\n            >\n              {feature('BUDDY') &&\n              companionNarrow &&\n              isFullscreenEnvEnabled() &&\n              companionVisible ? (\n                <CompanionSprite />\n              ) : null}\n              <Box flexDirection=\"column\" flexGrow={1}>\n                {permissionStickyFooter}\n                {/* Immediate local-jsx commands (/btw, /sandbox, /assistant,\n                  /issue) render here, NOT inside scrollable. They stay mounted\n                  while the main conversation streams behind them, so ScrollBox\n                  relayouts on each new message would drag them around. bottom\n                  is flexShrink={0} outside the ScrollBox — it never moves.\n                  Non-immediate local-jsx (/diff, /status, /theme, ~40 others)\n                  stays in scrollable: the main loop is paused so no jiggle,\n                  and their tall content (DiffDetailView renders up to 400\n                  lines with no internal scroll) needs the outer ScrollBox. */}\n                {toolJSX?.isLocalJSXCommand &&\n                  toolJSX.isImmediate &&\n                  !toolJsxCentered && (\n                    <Box flexDirection=\"column\" width=\"100%\">\n                      {toolJSX.jsx}\n                    </Box>\n                  )}\n                {!showSpinner &&\n                  !toolJSX?.isLocalJSXCommand &&\n                  showExpandedTodos &&\n                  tasksV2 &&\n                  tasksV2.length > 0 && (\n                    <Box width=\"100%\" flexDirection=\"column\">\n                      <TaskListV2 tasks={tasksV2} isStandalone={true} />\n                    </Box>\n                  )}\n                {focusedInputDialog === 'sandbox-permission' && (\n                  <SandboxPermissionRequest\n                    key={sandboxPermissionRequestQueue[0]!.hostPattern.host}\n                    hostPattern={sandboxPermissionRequestQueue[0]!.hostPattern}\n                    onUserResponse={(response: {\n                      allow: boolean\n                      persistToSettings: boolean\n                    }) => {\n                      const { allow, persistToSettings } = response\n                      const currentRequest = sandboxPermissionRequestQueue[0]\n                      if (!currentRequest) return\n\n                      const approvedHost = currentRequest.hostPattern.host\n\n                      if (persistToSettings) {\n                        const update = {\n                          type: 'addRules' as const,\n                          rules: [\n                            {\n                              toolName: WEB_FETCH_TOOL_NAME,\n                              ruleContent: `domain:${approvedHost}`,\n                            },\n                          ],\n                          behavior: (allow ? 'allow' : 'deny') as\n                            | 'allow'\n                            | 'deny',\n                          destination: 'localSettings' as const,\n                        }\n\n                        setAppState(prev => ({\n                          ...prev,\n                          toolPermissionContext: applyPermissionUpdate(\n                            prev.toolPermissionContext,\n                            update,\n                          ),\n                        }))\n\n                        persistPermissionUpdate(update)\n\n                        // Immediately update sandbox in-memory config to prevent race conditions\n                        // where pending requests slip through before settings change is detected\n                        SandboxManager.refreshConfig()\n                      }\n\n                      // Resolve ALL pending requests for the same host (not just the first one)\n                      // This handles the case where multiple parallel requests came in for the same domain\n                      setSandboxPermissionRequestQueue(queue => {\n                        queue\n                          .filter(\n                            item => item.hostPattern.host === approvedHost,\n                          )\n                          .forEach(item => item.resolvePromise(allow))\n                        return queue.filter(\n                          item => item.hostPattern.host !== approvedHost,\n                        )\n                      })\n\n                      // Clean up bridge subscriptions and cancel remote prompts\n                      // for this host since the local user already responded.\n                      const cleanups =\n                        sandboxBridgeCleanupRef.current.get(approvedHost)\n                      if (cleanups) {\n                        for (const fn of cleanups) {\n                          fn()\n                        }\n                        sandboxBridgeCleanupRef.current.delete(approvedHost)\n                      }\n                    }}\n                  />\n                )}\n                {focusedInputDialog === 'prompt' && (\n                  <PromptDialog\n                    key={promptQueue[0]!.request.prompt}\n                    title={promptQueue[0]!.title}\n                    toolInputSummary={promptQueue[0]!.toolInputSummary}\n                    request={promptQueue[0]!.request}\n                    onRespond={selectedKey => {\n                      const item = promptQueue[0]\n                      if (!item) return\n                      item.resolve({\n                        prompt_response: item.request.prompt,\n                        selected: selectedKey,\n                      })\n                      setPromptQueue(([, ...tail]) => tail)\n                    }}\n                    onAbort={() => {\n                      const item = promptQueue[0]\n                      if (!item) return\n                      item.reject(new Error('Prompt cancelled by user'))\n                      setPromptQueue(([, ...tail]) => tail)\n                    }}\n                  />\n                )}\n                {/* Show pending indicator on worker while waiting for leader approval */}\n                {pendingWorkerRequest && (\n                  <WorkerPendingPermission\n                    toolName={pendingWorkerRequest.toolName}\n                    description={pendingWorkerRequest.description}\n                  />\n                )}\n                {/* Show pending indicator for sandbox permission on worker side */}\n                {pendingSandboxRequest && (\n                  <WorkerPendingPermission\n                    toolName=\"Network Access\"\n                    description={`Waiting for leader to approve network access to ${pendingSandboxRequest.host}`}\n                  />\n                )}\n                {/* Worker sandbox permission requests from swarm workers */}\n                {focusedInputDialog === 'worker-sandbox-permission' && (\n                  <SandboxPermissionRequest\n                    key={workerSandboxPermissions.queue[0]!.requestId}\n                    hostPattern={\n                      {\n                        host: workerSandboxPermissions.queue[0]!.host,\n                        port: undefined,\n                      } as NetworkHostPattern\n                    }\n                    onUserResponse={(response: {\n                      allow: boolean\n                      persistToSettings: boolean\n                    }) => {\n                      const { allow, persistToSettings } = response\n                      const currentRequest = workerSandboxPermissions.queue[0]\n                      if (!currentRequest) return\n\n                      const approvedHost = currentRequest.host\n\n                      // Send response via mailbox to the worker\n                      void sendSandboxPermissionResponseViaMailbox(\n                        currentRequest.workerName,\n                        currentRequest.requestId,\n                        approvedHost,\n                        allow,\n                        teamContext?.teamName,\n                      )\n\n                      if (persistToSettings && allow) {\n                        const update = {\n                          type: 'addRules' as const,\n                          rules: [\n                            {\n                              toolName: WEB_FETCH_TOOL_NAME,\n                              ruleContent: `domain:${approvedHost}`,\n                            },\n                          ],\n                          behavior: 'allow' as const,\n                          destination: 'localSettings' as const,\n                        }\n\n                        setAppState(prev => ({\n                          ...prev,\n                          toolPermissionContext: applyPermissionUpdate(\n                            prev.toolPermissionContext,\n                            update,\n                          ),\n                        }))\n\n                        persistPermissionUpdate(update)\n                        SandboxManager.refreshConfig()\n                      }\n\n                      // Remove from queue\n                      setAppState(prev => ({\n                        ...prev,\n                        workerSandboxPermissions: {\n                          ...prev.workerSandboxPermissions,\n                          queue: prev.workerSandboxPermissions.queue.slice(1),\n                        },\n                      }))\n                    }}\n                  />\n                )}\n                {focusedInputDialog === 'elicitation' && (\n                  <ElicitationDialog\n                    key={\n                      elicitation.queue[0]!.serverName +\n                      ':' +\n                      String(elicitation.queue[0]!.requestId)\n                    }\n                    event={elicitation.queue[0]!}\n                    onResponse={(action, content) => {\n                      const currentRequest = elicitation.queue[0]\n                      if (!currentRequest) return\n                      // Call respond callback to resolve Promise\n                      currentRequest.respond({ action, content })\n                      // For URL accept, keep in queue for phase 2\n                      const isUrlAccept =\n                        currentRequest.params.mode === 'url' &&\n                        action === 'accept'\n                      if (!isUrlAccept) {\n                        setAppState(prev => ({\n                          ...prev,\n                          elicitation: {\n                            queue: prev.elicitation.queue.slice(1),\n                          },\n                        }))\n                      }\n                    }}\n                    onWaitingDismiss={action => {\n                      const currentRequest = elicitation.queue[0]\n                      // Remove from queue\n                      setAppState(prev => ({\n                        ...prev,\n                        elicitation: {\n                          queue: prev.elicitation.queue.slice(1),\n                        },\n                      }))\n                      currentRequest?.onWaitingDismiss?.(action)\n                    }}\n                  />\n                )}\n                {focusedInputDialog === 'cost' && (\n                  <CostThresholdDialog\n                    onDone={() => {\n                      setShowCostDialog(false)\n                      setHaveShownCostDialog(true)\n                      saveGlobalConfig(current => ({\n                        ...current,\n                        hasAcknowledgedCostThreshold: true,\n                      }))\n                      logEvent('tengu_cost_threshold_acknowledged', {})\n                    }}\n                  />\n                )}\n                {focusedInputDialog === 'idle-return' && idleReturnPending && (\n                  <IdleReturnDialog\n                    idleMinutes={idleReturnPending.idleMinutes}\n                    totalInputTokens={getTotalInputTokens()}\n                    onDone={async action => {\n                      const pending = idleReturnPending\n                      setIdleReturnPending(null)\n                      logEvent('tengu_idle_return_action', {\n                        action:\n                          action as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                        idleMinutes: Math.round(pending.idleMinutes),\n                        messageCount: messagesRef.current.length,\n                        totalInputTokens: getTotalInputTokens(),\n                      })\n                      if (action === 'dismiss') {\n                        setInputValue(pending.input)\n                        return\n                      }\n                      if (action === 'never') {\n                        saveGlobalConfig(current => {\n                          if (current.idleReturnDismissed) return current\n                          return { ...current, idleReturnDismissed: true }\n                        })\n                      }\n                      if (action === 'clear') {\n                        const { clearConversation } = await import(\n                          '../commands/clear/conversation.js'\n                        )\n                        await clearConversation({\n                          setMessages,\n                          readFileState: readFileState.current,\n                          discoveredSkillNames: discoveredSkillNamesRef.current,\n                          loadedNestedMemoryPaths:\n                            loadedNestedMemoryPathsRef.current,\n                          getAppState: () => store.getState(),\n                          setAppState,\n                          setConversationId,\n                        })\n                        haikuTitleAttemptedRef.current = false\n                        setHaikuTitle(undefined)\n                        bashTools.current.clear()\n                        bashToolsProcessedIdx.current = 0\n                      }\n                      skipIdleCheckRef.current = true\n                      void onSubmitRef.current(pending.input, {\n                        setCursorOffset: () => {},\n                        clearBuffer: () => {},\n                        resetHistory: () => {},\n                      })\n                    }}\n                  />\n                )}\n                {focusedInputDialog === 'ide-onboarding' && (\n                  <IdeOnboardingDialog\n                    onDone={() => setShowIdeOnboarding(false)}\n                    installationStatus={ideInstallationStatus}\n                  />\n                )}\n                {\"external\" === 'ant' &&\n                  focusedInputDialog === 'model-switch' &&\n                  AntModelSwitchCallout && (\n                    <AntModelSwitchCallout\n                      onDone={(selection: string, modelAlias?: string) => {\n                        setShowModelSwitchCallout(false)\n                        if (selection === 'switch' && modelAlias) {\n                          setAppState(prev => ({\n                            ...prev,\n                            mainLoopModel: modelAlias,\n                            mainLoopModelForSession: null,\n                          }))\n                        }\n                      }}\n                    />\n                  )}\n                {\"external\" === 'ant' &&\n                  focusedInputDialog === 'undercover-callout' &&\n                  UndercoverAutoCallout && (\n                    <UndercoverAutoCallout\n                      onDone={() => setShowUndercoverCallout(false)}\n                    />\n                  )}\n                {focusedInputDialog === 'effort-callout' && (\n                  <EffortCallout\n                    model={mainLoopModel}\n                    onDone={selection => {\n                      setShowEffortCallout(false)\n                      if (selection !== 'dismiss') {\n                        setAppState(prev => ({\n                          ...prev,\n                          effortValue: selection,\n                        }))\n                      }\n                    }}\n                  />\n                )}\n                {focusedInputDialog === 'remote-callout' && (\n                  <RemoteCallout\n                    onDone={selection => {\n                      setAppState(prev => {\n                        if (!prev.showRemoteCallout) return prev\n                        return {\n                          ...prev,\n                          showRemoteCallout: false,\n                          ...(selection === 'enable' && {\n                            replBridgeEnabled: true,\n                            replBridgeExplicit: true,\n                            replBridgeOutboundOnly: false,\n                          }),\n                        }\n                      })\n                    }}\n                  />\n                )}\n\n                {exitFlow}\n\n                {focusedInputDialog === 'plugin-hint' && hintRecommendation && (\n                  <PluginHintMenu\n                    pluginName={hintRecommendation.pluginName}\n                    pluginDescription={hintRecommendation.pluginDescription}\n                    marketplaceName={hintRecommendation.marketplaceName}\n                    sourceCommand={hintRecommendation.sourceCommand}\n                    onResponse={handleHintResponse}\n                  />\n                )}\n\n                {focusedInputDialog === 'lsp-recommendation' &&\n                  lspRecommendation && (\n                    <LspRecommendationMenu\n                      pluginName={lspRecommendation.pluginName}\n                      pluginDescription={lspRecommendation.pluginDescription}\n                      fileExtension={lspRecommendation.fileExtension}\n                      onResponse={handleLspResponse}\n                    />\n                  )}\n\n                {focusedInputDialog === 'desktop-upsell' && (\n                  <DesktopUpsellStartup\n                    onDone={() => setShowDesktopUpsellStartup(false)}\n                  />\n                )}\n\n                {feature('ULTRAPLAN')\n                  ? focusedInputDialog === 'ultraplan-choice' &&\n                    ultraplanPendingChoice && (\n                      <UltraplanChoiceDialog\n                        plan={ultraplanPendingChoice.plan}\n                        sessionId={ultraplanPendingChoice.sessionId}\n                        taskId={ultraplanPendingChoice.taskId}\n                        setMessages={setMessages}\n                        readFileState={readFileState.current}\n                        getAppState={() => store.getState()}\n                        setConversationId={setConversationId}\n                      />\n                    )\n                  : null}\n\n                {feature('ULTRAPLAN')\n                  ? focusedInputDialog === 'ultraplan-launch' &&\n                    ultraplanLaunchPending && (\n                      <UltraplanLaunchDialog\n                        onChoice={(choice, opts) => {\n                          const blurb = ultraplanLaunchPending.blurb\n                          setAppState(prev =>\n                            prev.ultraplanLaunchPending\n                              ? { ...prev, ultraplanLaunchPending: undefined }\n                              : prev,\n                          )\n                          if (choice === 'cancel') return\n                          // Command's onDone used display:'skip', so add the\n                          // echo here — gives immediate feedback before the\n                          // ~5s teleportToRemote resolves.\n                          setMessages(prev => [\n                            ...prev,\n                            createCommandInputMessage(\n                              formatCommandInputTags('ultraplan', blurb),\n                            ),\n                          ])\n                          const appendStdout = (msg: string) =>\n                            setMessages(prev => [\n                              ...prev,\n                              createCommandInputMessage(\n                                `<${LOCAL_COMMAND_STDOUT_TAG}>${escapeXml(msg)}</${LOCAL_COMMAND_STDOUT_TAG}>`,\n                              ),\n                            ])\n                          // Defer the second message if a query is mid-turn\n                          // so it lands after the assistant reply, not\n                          // between the user's prompt and the reply.\n                          const appendWhenIdle = (msg: string) => {\n                            if (!queryGuard.isActive) {\n                              appendStdout(msg)\n                              return\n                            }\n                            const unsub = queryGuard.subscribe(() => {\n                              if (queryGuard.isActive) return\n                              unsub()\n                              // Skip if the user stopped ultraplan while we\n                              // were waiting — avoids a stale \"Monitoring\n                              // <url>\" message for a session that's gone.\n                              if (!store.getState().ultraplanSessionUrl) return\n                              appendStdout(msg)\n                            })\n                          }\n                          void launchUltraplan({\n                            blurb,\n                            getAppState: () => store.getState(),\n                            setAppState,\n                            signal: createAbortController().signal,\n                            disconnectedBridge: opts?.disconnectedBridge,\n                            onSessionReady: appendWhenIdle,\n                          })\n                            .then(appendStdout)\n                            .catch(logError)\n                        }}\n                      />\n                    )\n                  : null}\n\n                {mrRender()}\n\n                {!toolJSX?.shouldHidePromptInput &&\n                  !focusedInputDialog &&\n                  !isExiting &&\n                  !disabled &&\n                  !cursor && (\n                    <>\n                      {autoRunIssueReason && (\n                        <AutoRunIssueNotification\n                          onRun={handleAutoRunIssue}\n                          onCancel={handleCancelAutoRunIssue}\n                          reason={getAutoRunIssueReasonText(autoRunIssueReason)}\n                        />\n                      )}\n                      {postCompactSurvey.state !== 'closed' ? (\n                        <FeedbackSurvey\n                          state={postCompactSurvey.state}\n                          lastResponse={postCompactSurvey.lastResponse}\n                          handleSelect={postCompactSurvey.handleSelect}\n                          inputValue={inputValue}\n                          setInputValue={setInputValue}\n                          onRequestFeedback={handleSurveyRequestFeedback}\n                        />\n                      ) : memorySurvey.state !== 'closed' ? (\n                        <FeedbackSurvey\n                          state={memorySurvey.state}\n                          lastResponse={memorySurvey.lastResponse}\n                          handleSelect={memorySurvey.handleSelect}\n                          handleTranscriptSelect={\n                            memorySurvey.handleTranscriptSelect\n                          }\n                          inputValue={inputValue}\n                          setInputValue={setInputValue}\n                          onRequestFeedback={handleSurveyRequestFeedback}\n                          message=\"How well did Claude use its memory? (optional)\"\n                        />\n                      ) : (\n                        <FeedbackSurvey\n                          state={feedbackSurvey.state}\n                          lastResponse={feedbackSurvey.lastResponse}\n                          handleSelect={feedbackSurvey.handleSelect}\n                          handleTranscriptSelect={\n                            feedbackSurvey.handleTranscriptSelect\n                          }\n                          inputValue={inputValue}\n                          setInputValue={setInputValue}\n                          onRequestFeedback={\n                            didAutoRunIssueRef.current\n                              ? undefined\n                              : handleSurveyRequestFeedback\n                          }\n                        />\n                      )}\n                      {/* Frustration-triggered transcript sharing prompt */}\n                      {frustrationDetection.state !== 'closed' && (\n                        <FeedbackSurvey\n                          state={frustrationDetection.state}\n                          lastResponse={null}\n                          handleSelect={() => {}}\n                          handleTranscriptSelect={\n                            frustrationDetection.handleTranscriptSelect\n                          }\n                          inputValue={inputValue}\n                          setInputValue={setInputValue}\n                        />\n                      )}\n                      {/* Skill improvement survey - appears when improvements detected (ant-only) */}\n                      {\"external\" === 'ant' &&\n                        skillImprovementSurvey.suggestion && (\n                          <SkillImprovementSurvey\n                            isOpen={skillImprovementSurvey.isOpen}\n                            skillName={\n                              skillImprovementSurvey.suggestion.skillName\n                            }\n                            updates={skillImprovementSurvey.suggestion.updates}\n                            handleSelect={skillImprovementSurvey.handleSelect}\n                            inputValue={inputValue}\n                            setInputValue={setInputValue}\n                          />\n                        )}\n                      {showIssueFlagBanner && <IssueFlagBanner />}\n                      {\n                      }\n                      <PromptInput\n                        debug={debug}\n                        ideSelection={ideSelection}\n                        hasSuppressedDialogs={!!hasSuppressedDialogs}\n                        isLocalJSXCommandActive={isShowingLocalJSXCommand}\n                        getToolUseContext={getToolUseContext}\n                        toolPermissionContext={toolPermissionContext}\n                        setToolPermissionContext={setToolPermissionContext}\n                        apiKeyStatus={apiKeyStatus}\n                        commands={commands}\n                        agents={agentDefinitions.activeAgents}\n                        isLoading={isLoading}\n                        onExit={handleExit}\n                        verbose={verbose}\n                        messages={messages}\n                        onAutoUpdaterResult={setAutoUpdaterResult}\n                        autoUpdaterResult={autoUpdaterResult}\n                        input={inputValue}\n                        onInputChange={setInputValue}\n                        mode={inputMode}\n                        onModeChange={setInputMode}\n                        stashedPrompt={stashedPrompt}\n                        setStashedPrompt={setStashedPrompt}\n                        submitCount={submitCount}\n                        onShowMessageSelector={handleShowMessageSelector}\n                        onMessageActionsEnter={\n                          // Works during isLoading — edit cancels first; uuid selection survives appends.\n                          feature('MESSAGE_ACTIONS') &&\n                          isFullscreenEnvEnabled() &&\n                          !disableMessageActions\n                            ? enterMessageActions\n                            : undefined\n                        }\n                        mcpClients={mcpClients}\n                        pastedContents={pastedContents}\n                        setPastedContents={setPastedContents}\n                        vimMode={vimMode}\n                        setVimMode={setVimMode}\n                        showBashesDialog={showBashesDialog}\n                        setShowBashesDialog={setShowBashesDialog}\n                        onSubmit={onSubmit}\n                        onAgentSubmit={onAgentSubmit}\n                        isSearchingHistory={isSearchingHistory}\n                        setIsSearchingHistory={setIsSearchingHistory}\n                        helpOpen={isHelpOpen}\n                        setHelpOpen={setIsHelpOpen}\n                        insertTextRef={\n                          feature('VOICE_MODE') ? insertTextRef : undefined\n                        }\n                        voiceInterimRange={voice.interimRange}\n                      />\n                      <SessionBackgroundHint\n                        onBackgroundSession={handleBackgroundSession}\n                        isLoading={isLoading}\n                      />\n                    </>\n                  )}\n                {cursor && (\n                  // inputValue is REPL state; typed text survives the round-trip.\n                  <MessageActionsBar cursor={cursor} />\n                )}\n                {focusedInputDialog === 'message-selector' && (\n                  <MessageSelector\n                    messages={messages}\n                    preselectedMessage={messageSelectorPreselect}\n                    onPreRestore={onCancel}\n                    onRestoreCode={async (message: UserMessage) => {\n                      await fileHistoryRewind(\n                        (\n                          updater: (prev: FileHistoryState) => FileHistoryState,\n                        ) => {\n                          setAppState(prev => ({\n                            ...prev,\n                            fileHistory: updater(prev.fileHistory),\n                          }))\n                        },\n                        message.uuid,\n                      )\n                    }}\n                    onSummarize={async (\n                      message: UserMessage,\n                      feedback?: string,\n                      direction: PartialCompactDirection = 'from',\n                    ) => {\n                      // Project snipped messages so the compact model\n                      // doesn't summarize content that was intentionally removed.\n                      const compactMessages =\n                        getMessagesAfterCompactBoundary(messages)\n\n                      const messageIndex = compactMessages.indexOf(message)\n                      if (messageIndex === -1) {\n                        // Selected a snipped or pre-compact message that the\n                        // selector still shows (REPL keeps full history for\n                        // scrollback). Surface why nothing happened instead\n                        // of silently no-oping.\n                        setMessages(prev => [\n                          ...prev,\n                          createSystemMessage(\n                            'That message is no longer in the active context (snipped or pre-compact). Choose a more recent message.',\n                            'warning',\n                          ),\n                        ])\n                        return\n                      }\n\n                      const newAbortController = createAbortController()\n                      const context = getToolUseContext(\n                        compactMessages,\n                        [],\n                        newAbortController,\n                        mainLoopModel,\n                      )\n\n                      const appState = context.getAppState()\n                      const defaultSysPrompt = await getSystemPrompt(\n                        context.options.tools,\n                        context.options.mainLoopModel,\n                        Array.from(\n                          appState.toolPermissionContext.additionalWorkingDirectories.keys(),\n                        ),\n                        context.options.mcpClients,\n                      )\n                      const systemPrompt = buildEffectiveSystemPrompt({\n                        mainThreadAgentDefinition: undefined,\n                        toolUseContext: context,\n                        customSystemPrompt: context.options.customSystemPrompt,\n                        defaultSystemPrompt: defaultSysPrompt,\n                        appendSystemPrompt: context.options.appendSystemPrompt,\n                      })\n                      const [userContext, systemContext] = await Promise.all([\n                        getUserContext(),\n                        getSystemContext(),\n                      ])\n\n                      const result = await partialCompactConversation(\n                        compactMessages,\n                        messageIndex,\n                        context,\n                        {\n                          systemPrompt,\n                          userContext,\n                          systemContext,\n                          toolUseContext: context,\n                          forkContextMessages: compactMessages,\n                        },\n                        feedback,\n                        direction,\n                      )\n\n                      const kept = result.messagesToKeep ?? []\n                      const ordered =\n                        direction === 'up_to'\n                          ? [...result.summaryMessages, ...kept]\n                          : [...kept, ...result.summaryMessages]\n                      const postCompact = [\n                        result.boundaryMarker,\n                        ...ordered,\n                        ...result.attachments,\n                        ...result.hookResults,\n                      ]\n                      // Fullscreen 'from' keeps scrollback; 'up_to' must not\n                      // (old[0] unchanged + grown array means incremental\n                      // useLogMessages path, so boundary never persisted).\n                      // Find by uuid since old is raw REPL history and snipped\n                      // entries can shift the projected messageIndex.\n                      if (isFullscreenEnvEnabled() && direction === 'from') {\n                        setMessages(old => {\n                          const rawIdx = old.findIndex(\n                            m => m.uuid === message.uuid,\n                          )\n                          return [\n                            ...old.slice(0, rawIdx === -1 ? 0 : rawIdx),\n                            ...postCompact,\n                          ]\n                        })\n                      } else {\n                        setMessages(postCompact)\n                      }\n                      // Partial compact bypasses handleMessageFromStream — clear\n                      // the context-blocked flag so proactive ticks resume.\n                      if (feature('PROACTIVE') || feature('KAIROS')) {\n                        proactiveModule?.setContextBlocked(false)\n                      }\n                      setConversationId(randomUUID())\n                      runPostCompactCleanup(context.options.querySource)\n\n                      if (direction === 'from') {\n                        const r = textForResubmit(message)\n                        if (r) {\n                          setInputValue(r.text)\n                          setInputMode(r.mode)\n                        }\n                      }\n\n                      // Show notification with ctrl+o hint\n                      const historyShortcut = getShortcutDisplay(\n                        'app:toggleTranscript',\n                        'Global',\n                        'ctrl+o',\n                      )\n                      addNotification({\n                        key: 'summarize-ctrl-o-hint',\n                        text: `Conversation summarized (${historyShortcut} for history)`,\n                        priority: 'medium',\n                        timeoutMs: 8000,\n                      })\n                    }}\n                    onRestoreMessage={handleRestoreMessage}\n                    onClose={() => {\n                      setIsMessageSelectorVisible(false)\n                      setMessageSelectorPreselect(undefined)\n                    }}\n                  />\n                )}\n                {\"external\" === 'ant' && <DevBar />}\n              </Box>\n              {feature('BUDDY') &&\n              !(companionNarrow && isFullscreenEnvEnabled()) &&\n              companionVisible ? (\n                <CompanionSprite />\n              ) : null}\n            </Box>\n          }\n        />\n      </MCPConnectionManager>\n    </KeybindingSetup>\n  )\n  if (isFullscreenEnvEnabled()) {\n    return (\n      <AlternateScreen mouseTracking={isMouseTrackingEnabled()}>\n        {mainReturn}\n      </AlternateScreen>\n    )\n  }\n  return mainReturn\n}\n"],"mappings":"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","ignoreList":[]}