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